Building AI Agents with .NET and Semantic Kernel

Why .NET for AI Agents

Most multi-agent frameworks are Python-only, which creates friction for enterprise development teams whose primary language is C#. The Microsoft Agent Framework eliminates this friction by providing a .NET SDK that is a full peer of the Python SDK, not a wrapper or port. Agents written in .NET have access to the same capabilities, patterns, and APIs as their Python counterparts.

For organizations with existing .NET codebases, the framework integrates naturally with established services, data access layers, and business logic. A company with years of C# business rules can expose those rules as Semantic Kernel plugins without rewriting them in Python. An agent that needs to query an Entity Framework database or call a .NET gRPC service does so using the same patterns the team already knows.

The .NET runtime also offers performance advantages for certain workloads. Ahead-of-time compilation, efficient memory management, and the mature async/await pattern make .NET well-suited for high-throughput agent systems that process many concurrent conversations. For deployments that need to handle hundreds of simultaneous agent sessions, .NET's runtime characteristics can reduce infrastructure costs compared to equivalent Python implementations.

Setting Up a .NET Agent Project

Creating a new agent project starts with adding the Microsoft Agent Framework NuGet packages. The core package provides the agent abstractions, conversation management, and orchestration components. Additional packages add specific model providers (Azure OpenAI, OpenAI, local models), memory backends (Azure AI Search, Chroma), and integration features (MCP support, A2A protocol).

The framework follows standard .NET patterns for configuration and dependency injection. Agents, plugins, and model services are registered with the dependency injection container at startup and resolved automatically when needed. Configuration comes from the standard .NET configuration system, supporting appsettings.json, environment variables, user secrets, and Azure Key Vault.

Agent definitions in .NET use C# classes with attributes that describe the agent's behavior. The system message, supported tools, and conversation policies are declared as properties or constructor parameters, with the framework handling the runtime plumbing. This declarative approach keeps agent definitions concise and readable while providing compile-time checking that catches configuration errors before runtime.

Building Plugins in C#

Semantic Kernel plugins in .NET are C# classes with methods decorated with the KernelFunction attribute. Each method's parameters are annotated with descriptions that the LLM uses to understand how to call the function. The framework automatically serializes arguments from the LLM's function call format, invokes the method, and returns the result to the agent conversation.

Strong typing is a significant advantage of the .NET plugin system. Parameters and return types are validated at compile time, eliminating a common class of runtime errors that plague dynamically-typed Python implementations. Nullable reference types, enum parameters, and complex object types are all supported, giving developers precise control over the data flowing between agents and tools.

Dependency injection works seamlessly with plugins. A plugin that needs database access receives its DbContext through constructor injection. A plugin that calls external APIs receives an HttpClient from the framework's HttpClientFactory. This integration means plugins follow the same patterns as the rest of the application, making them testable, maintainable, and consistent with existing code.

Cross-Runtime Interoperability

The Agent-to-Agent (A2A) protocol enables .NET agents to communicate with Python agents and vice versa. An agent written in C# can participate in a conversation with agents written in Python, with the framework handling message serialization, transport, and protocol negotiation transparently. This interoperability means teams can use whichever language is most appropriate for each agent without limiting their options for the overall system.

The Model Context Protocol (MCP) provides a standardized way for agents to expose and consume tool capabilities across process and language boundaries. A .NET agent can discover and use tools provided by a Python service, or expose its own tools for Python agents to consume. This protocol-based approach decouples tool providers from tool consumers, enabling modular system architectures where components can be developed, deployed, and updated independently.

In practice, cross-runtime systems often assign different responsibilities to each language based on their strengths. Python agents might handle data science tasks using pandas, numpy, and machine learning libraries, while .NET agents manage business logic, database operations, and enterprise integrations. The A2A protocol connects these specialists into a cohesive system that leverages the best of both ecosystems.

Deployment Patterns

NET agent systems deploy as standard .NET applications, using familiar patterns and infrastructure. ASP.NET Core hosting provides the web server foundation for agents that communicate over HTTP or WebSocket. Background services handle long-running agent conversations that persist across requests. Azure Functions enable serverless agent architectures that scale to zero when idle.

Docker containerization works the same way as any .NET application, with the framework's dependencies resolved through NuGet packages at build time. Kubernetes orchestration provides scaling, load balancing, and fault tolerance for production deployments. Azure Container Apps offers a managed alternative that handles infrastructure automatically while supporting the same container images.

For teams using Azure, the Foundry Agent Service provides a fully managed hosting environment specifically designed for agent workloads. .NET agents deploy to the service with minimal configuration and receive automatic scaling, monitoring, and integration with Azure security services. This managed approach is the fastest path to production for organizations that want to focus on agent logic rather than infrastructure management.