{"id":60832,"date":"2026-09-16T14:00:00","date_gmt":"2026-09-16T21:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/dotnet\/?p=60832"},"modified":"2026-09-16T14:00:00","modified_gmt":"2026-09-16T21:00:00","slug":"build-your-own-ai-agent-harness-in-csharp-the-maf-claw-live-series","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/build-your-own-ai-agent-harness-in-csharp-the-maf-claw-live-series\/","title":{"rendered":"Build Your Own AI Agent Harness in C#, the MafClaw Live Series"},"content":{"rendered":"

A few weeks ago I wrote about going from dotnet run<\/code> to a Foundry Hosted Agent in three lines of C#<\/a>. The feedback was great. Developers liked the deployment story, the managed infrastructure, and especially the part where we did not<\/strong> spend the afternoon writing a Dockerfile, a session store, a telemetry pipeline, and a small distributed system just to expose one agent \ud83d\ude05.<\/p>\n

But that post starts near the end of the journey. It assumes you already have an agent worth deploying.<\/p>\n

So the next question is:<\/p>\n

\n

“What should I put inside the agent before I deploy it?”<\/p>\n<\/blockquote>\n

Tools. Planning. Safe file access. Human approval. Memory. Skills. Shell commands. Code execution. Background agents. Observability. Governance. Evaluations.<\/p>\n

That list gets big very quickly.<\/p>\n

The good news is that you do not need to build the runtime for all of it from scratch. Microsoft Agent Framework includes an agent harness<\/strong>, and I am building a complete C# agent with it live, one capability at a time, in a four-part series called From Model to Agent: The Agent Framework Harness, Live in C#<\/strong>.<\/p>\n

The series streams live simultaneously on the .NET YouTube channel<\/a><\/strong> and Microsoft Reactor<\/strong>, four consecutive Thursdays in September, and every session stays available afterward on demand on both platforms. Two sessions are already available, and two more are coming. Let me show you what we are building and why the harness makes this much easier.<\/p>\n

Register for the live Agent Framework series<\/a><\/div><\/p>\n

What we build across four sessions<\/h2>\n

We start with this:<\/p>\n

AIAgent agent = chatClient.AsHarnessAgent(new HarnessAgentOptions\n{\n    ChatOptions = new ChatOptions\n    {\n        Instructions = instructions,\n        Tools = tools\n    }\n});<\/code><\/pre>\n
Then we grow the same agent through four stages:<\/p>\n
    \n
  1. Give it tools, web search, and a plan.<\/li>\n
  2. Let it work with files, approvals, and durable memory.<\/li>\n
  3. Add skills, shell, CodeAct, and background agents.<\/li>\n
  4. Add observability, governance, evaluations, and a hosted deployment.<\/li>\n<\/ol>\n
    That is the complete journey: from one call around an IChatClient<\/code> to a capable agent that we can inspect, evaluate, govern, and run in Microsoft Foundry.<\/p>\n
    First: what is an agent harness?<\/h2>\n
    A language model can generate text. An agent needs more.<\/p>\n
    It needs a loop that can call tools, inspect the results, update a plan, remember useful information, request approval for risky actions, manage a growing context window, and keep working until the task is complete.<\/p>\n
    That surrounding runtime is the harness<\/strong>.<\/p>\n
    <\/i>Where the term comes from<\/strong><\/p>The Microsoft Agent Framework team introduced the concept in the excellent Build your own claw and agent harness with Microsoft Agent Framework<\/a> series. Their explanation is simple: a “claw” is a CLI-style agent built on top of a harness. You bring the model, instructions, and domain tools. The harness supplies the agentic machinery around them.<\/div><\/p>\n
    In .NET, the key line is this one:<\/p>\n
    AIAgent agent = chatClient.AsHarnessAgent(new HarnessAgentOptions\n{\n    ChatOptions = new ChatOptions\n    {\n        Instructions = \"You are a personal finance education assistant.\",\n        Tools = [StockTools.GetStockPrice]\n    }\n});<\/code><\/pre>\n
    That call gives the agent a complete pipeline with capabilities such as:<\/p>\n