Skill: .NET Agent Framework Authoring

[artl93]

Problem

The Microsoft Agent Framework (built from dotnet/extensions) provides first-party abstractions for building AI agents in .NET. However, going from "I want to build an agent" to a well-structured, production-ready agent application involves a long series of decisions: which scenario template to start from, which AI provider to target, how to wire up dependency injection, how to configure logging for observability, and how to follow modern .NET patterns throughout. AI models today don't reliably know these patterns because the framework is new and evolving.

What expert .NET knowledge would this encode?

• Scenario selection guidance: Chat agents, tool-calling agents, multi-agent orchestration, RAG pipelines — which template fits which use case, with decision tree
• Target framework selection: .NET 8 LTS vs .NET 9 vs .NET 10 tradeoffs for agent applications (hosting model, IChatClient availability, support lifecycle)
• Project scaffolding: Correct packages (Microsoft.Extensions.AI, Microsoft.Extensions.AI.OpenAI, Microsoft.Extensions.AI.Abstractions), project structure based on the dotnet/extensions templates
• Dependency injection setup: Proper registration of IChatClient, middleware pipelines (function invocation, OpenTelemetry, rate limiting), keyed services for multi-model scenarios
• Logging and observability: Structured logging with ILogger, OpenTelemetry integration for tracing agent calls, configuring LoggerMessage source generators for high-perf logging in hot paths
• Modern .NET best practices: Options pattern for configuration, health checks, graceful shutdown, nullable reference types, top-level statements vs minimal hosting — applied specifically to agent applications
• Tool authoring: Defining tools with [Description], proper parameter binding, async tool patterns, error handling in tool invocations
• Provider configuration: Wiring up Azure OpenAI, OpenAI, Ollama, or other providers via the IChatClient abstraction

Skill concept

A guided skill that walks the developer through building a .NET AI agent application end-to-end:

1. Understand the goal — What kind of agent? (Conversational, tool-calling, multi-step, multi-agent?) What's the deployment target? (Console app, ASP.NET service, Azure Function?)
2. Guide scenario selection — Based on answers, recommend the right starting template and architecture
3. Guide target framework and provider selection — Based on deployment needs, model provider, and support requirements
4. Scaffold the project — Generate the project file, hosting setup, DI registration, and initial agent structure
5. Wire up cross-cutting concerns — Logging, configuration, health checks, OpenTelemetry — following the same patterns used in dotnet/extensions itself
6. Validate the result — Ensure the agent builds, DI resolves correctly, and a basic prompt/response roundtrip works

Why customers would value this

AI agent development in .NET is exploding, but the gap between "hello world chat completion" and "production agent service" is enormous. Customers need guidance on the full stack: not just calling an LLM, but structuring the application around it with proper DI, logging, configuration, error handling, and observability. This is exactly the kind of end-to-end guidance the .NET team is uniquely positioned to provide — it's the same patterns used internally in dotnet/extensions and ASP.NET.

Scope

In scope:

• Agent scaffolding from dotnet/extensions templates
• Scenario selection guidance (chat, tool-calling, multi-agent)
• Target framework selection
• DI setup with IChatClient and middleware
• Logging, configuration (Options pattern), and OpenTelemetry
• Tool authoring patterns
• Provider-agnostic setup (Azure OpenAI, OpenAI, Ollama)

Out of scope:

• Custom model provider implementation
• Fine-tuning or model training
• Semantic Kernel migration (separate skill)
• Deployment/infrastructure (separate concern)