📦 Microsoft 🏷 Agent Framework 🏷 .NET 🏷 Python 🏷 Harness

What Is a Claw?

In the Microsoft Agent Framework, a "Claw" is a self-contained unit of agent capability — a modular component that encapsulates a specific skill or interaction pattern. Think of it as a plugin with agency: it can observe, reason, and act within a defined scope.

Claws are composable by design. A single agent can equip multiple claws to handle different aspects of a task, from data retrieval to user interaction to external API calls. Each claw declares its capabilities, inputs, and outputs, making them discoverable and orchestratable by the harness.

The Harness Architecture

The Agent Harness is the runtime orchestrator that manages the lifecycle of claws and coordinates their execution. It provides:

  • Message routing — directing user inputs and inter-claw messages to the right handlers
  • State management — maintaining conversation context, memory, and claw state across turns
  • Tool execution — safely invoking external tools and APIs with proper sandboxing
  • Error recovery — graceful handling of claw failures without crashing the entire agent

The harness follows a pipeline pattern: input → preprocessing → claw selection → execution → postprocessing → output. Each stage is extensible via middleware.

Six Building Blocks

The framework is organized around six fundamental building blocks:

  1. Agent — the top-level entity that owns identity, configuration, and claw registry
  2. Claw — a modular capability unit with defined inputs, outputs, and behavior
  3. Harness — the runtime that orchestrates claw execution and manages state
  4. Memory — pluggable storage for conversation history, vector embeddings, and structured data
  5. Planner — the reasoning component that decomposes tasks and selects which claws to invoke
  6. Connector — adapters for external services (LLM providers, databases, APIs, messaging platforms)

Why Now

Microsoft argues the timing is right for a standardized agent framework because:

  • LLM capabilities have reached the threshold where multi-step reasoning is reliable enough for production use
  • Tool-use and function-calling patterns have matured across model providers
  • Enterprise demand for AI agents has shifted from experimentation to deployment
  • The ecosystem lacks a batteries-included framework that handles the hard parts (state, memory, orchestration) while remaining extensible

The framework aims to be the ASP.NET / Flask of agent development — opinionated enough to be productive, flexible enough for real-world requirements.

Running Example

Throughout the blog series, a running example builds a customer support agent that can:

  • Answer product questions using a knowledge base (RAG claw)
  • Look up order status via an API (connector claw)
  • Escalate to a human agent when confidence is low (routing claw)
  • Maintain conversation context across sessions (memory claw)

Each post in the series adds a new building block to this example, showing how the components compose in practice.

Series Roadmap

The blog series is planned as a multi-part deep dive:

  1. Part 1 — Introduction & core concepts (this article)
  2. Part 2 — Building your first Claw
  3. Part 3 — The Harness: orchestration & state
  4. Part 4 — Memory systems & RAG integration
  5. Part 5 — Planning & multi-step reasoning
  6. Part 6 — Connectors & external integrations
  7. Part 7 — Production deployment & observability

Dual Language Support

The framework ships with first-class support for both .NET (C#) and Python, reflecting the two dominant ecosystems in enterprise AI development.

Both implementations share the same conceptual model and API surface, with language-idiomatic adaptations. A claw written in Python can interoperate with a .NET harness via the standard message protocol, enabling mixed-language agent architectures.

The .NET SDK leverages Microsoft.Extensions.AI for LLM integration, while the Python SDK builds on openai and azure-ai client libraries.

Getting Started

To start building with the Microsoft Agent Framework:

  • Install the SDK: dotnet add package Microsoft.AgentFramework or pip install microsoft-agent-framework
  • Scaffold a new agent project with the CLI template
  • Define your first claw by implementing the IClaw interface (.NET) or extending the Claw base class (Python)
  • Register claws with the harness and configure your LLM connector
  • Run the agent locally with the built-in development server

The framework includes a dev dashboard for inspecting agent state, message flow, and claw execution traces during development.