# Microsoft Agent Framework — Open-source .NET, Python and Go SDK for building AI agents and graph-based multi-agent workflows.

> Source: The Agents Index — https://theagentsindex.com/microsoft-agent-framework (structured, researched, re-verified)
> Facts last verified: 2026-09-19

Microsoft Agent Framework is an MIT-licensed SDK for building AI agents and graph-based multi-agent workflows in .NET, Python and Go. It is the successor to Semantic Kernel and AutoGen, combining their agent abstractions with session state, middleware and telemetry.

| Fact | Value |
| --- | --- |
| Website | https://learn.microsoft.com/en-us/agent-framework/ |
| Price | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction |
| Free tier | Yes |

The entire framework is free under the MIT licence with no paid tier, no seats and no usage cap; the only spend is inference and tooling billed by the model provider you configure.

## What it does

**Writes code** · Partly — Agents you build can write and run code through CodeAct or a provider-hosted code interpreter, but both are gated: the documented CodeAct connector is in preview and code interpreter depends on the model provider you choose.

> CodeAct lets an agent solve a task by writing code and executing it through an `execute_code` tool. Instead of asking the model to emit one tool call at a time, CodeAct gives it a sandboxed place to combine control flow, data transformation, and tool orchestration
> — https://learn.microsoft.com/en-us/agent-framework/agents/code-act · CodeAct page, opening paragraph above 'Why CodeAct'

**Whole-codebase work** · Partly — The Harness targets long multi-step work with context compaction, file memory and todo tracking, and shell tools default to working-directory confinement; the vendor documents no repository indexing or repo-wide migration.

> A harness wraps a chat client with the scaffolding an agent needs to work through long, multi-step tasks - planning / execution modes, a todo list to plan against, context compaction, file memory
> — https://learn.microsoft.com/en-us/agent-framework/get-started/harness · Step 6: Agent Harness, opening paragraph

**Ships it** · Partly — The beta agent-framework-tools package gives an agent local or Docker shell execution, so it can run any command you approve; no deploy, release or pull-request step is documented.

> Shell execution can modify files, launch processes, access credentials, and communicate with external systems. Use the least-privileged execution tier that supports the task.
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/tools/shell-tools · Shell tools, warning under the tool table

**Done-for-you service** · No — Microsoft ships a package you install and run yourself; nobody builds or operates the agent for you, and support is the public GitHub repository, discussions and office hours.

> Microsoft Agent Framework is an open-source SDK for building AI agents that can reason, use tools, and interact with users and other agents. It supports multiple AI providers and languages.
> — https://learn.microsoft.com/en-us/agent-framework/support/faq · FAQ, General section, answer to 'What is Agent Framework?'

_Not established: Debugs and fixes, Writes tests, Reviews code_

## How much it does unattended

**Runs autonomously** · Yes — The agent-mode provider ships an explicitly autonomous execute mode that works a plan to completion, and the Harness keeps an agent progressing through long multi-step tasks without a person each turn.

> Execute is autonomous. The agent works through the plan, makes reasonable choices when details are ambiguous, and marks todos complete.
> — https://learn.microsoft.com/en-us/agent-framework/agents/planning-and-todos · Plan and execute modes section, numbered item 2

**Multi-agent** · Yes — Five built-in orchestration patterns coordinate several agents on one task, and a parent agent can additionally delegate concurrent work to named child agents in their own sessions.

> Agent Framework provides several built-in multi-agent orchestration patterns:
> — https://learn.microsoft.com/en-us/agent-framework/workflows/orchestrations/ · Workflow orchestrations page, sentence introducing the Sequential/Concurrent/Handoff/Group Chat/Magentic table

**Agent permissions** · Yes — Approval is per tool and configurable in code: the local shell tool asks for every command by default, regex allow and deny lists pre-filter commands, and disabling approval requires an explicit unsafe acknowledgement.

> `LocalShellTool` runs commands directly on the host. It defaults to a persistent shell, a 30-second timeout, 64-KiB output truncation, working-directory confinement, and approval for every command.
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/tools/shell-tools · Python pivot, 'Use LocalShellTool' section, paragraph under the heading

## Which models it runs on

**Claude** · Yes — Anthropic is a first-class model provider with its own client package, reachable through Anthropic directly or through Foundry, Bedrock and Vertex AI endpoints.

> Anthropic — Claude model inference through Anthropic and supported hosted endpoints.
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/model-providers/ · C# pivot, 'Available providers' bullet list, Anthropic entry

**GPT** · Yes — Both OpenAI directly and Azure OpenAI are listed model providers, covering Chat Completions and the Responses API, with Microsoft Foundry as a third route to the same models.

> OpenAI — OpenAI Chat Completions and Responses APIs.
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/model-providers/ · C# pivot, 'Available providers' bullet list, OpenAI entry

**Open models** · Yes — Ollama, ONNX Runtime GenAI and Foundry Local are all listed as providers for running open-weight models locally, though the comparison table shows they support fewer hosted-tool features than the cloud providers.

> Ollama — Local open-source model inference.
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/model-providers/ · C# pivot, 'Available providers' bullet list, Ollama entry

**Model choice** · Yes — You choose the model: eleven providers are documented and, in .NET, any inference service implementing the standard chat-client interface can back an agent without framework changes.

> Any inference service that provides a `Microsoft.Extensions.AI.IChatClient` implementation can back a `ChatClientAgent`.
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/model-providers/ · C# pivot, first line of 'Available providers'

## Where you use it

**In your editor** · No — Not an editor product. The documented client surfaces are OpenAI-compatible HTTP, A2A, AG-UI web apps, Telegram and MCP; no IDE or editor extension appears in the docs.

> After choosing a host, select the client integration that fits your scenario:
> — https://learn.microsoft.com/en-us/agent-framework/hosting/ · Hosting overview, 'Choose a protocol separately' — the six-item client integration list (OpenAI-compatible endpoints, A2A hosting, A2A agent service, AG-UI, Telegram bots, MCP tools)

**On the command line** · Partly — A terminal surface exists only as developer tooling: the DevUI command line launches agents from a directory, and the Harness console apps are explicitly samples rather than shipped components.

> If you have agents and workflows organized in a directory structure, launch DevUI from the command line:
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/ui/devui/ · Python pivot, Quick Start, 'Option 2: Directory Discovery (CLI)'

**In a browser** · Partly — DevUI gives a browser interface for running and debugging agents, but the vendor labels it a sample app unfit for production; shipping a real web surface means adding the preview AG-UI or ChatKit integrations.

> DevUI is a **sample app** to help you visualize and debug your agents and workflows during development. It is **not** intended for production use.
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/ui/devui/ · DevUI page, Important callout beneath the introduction

_Not established: In your pipeline_

## Whose machine it runs on

**Self-hosted** · Yes — Self-hosting is one of the two documented hosting models: the agent runs in your own web service, container or runtime and you keep routing, identity, storage and scaling.

> Your application runs in your web service, container, runtime, or existing infrastructure.
> — https://learn.microsoft.com/en-us/agent-framework/hosting/ · Choose a hosting model table, 'Who operates the infrastructure?' row, Self-hosting column

**Open source** · Yes — The whole framework is published under the MIT licence on GitHub, permitting commercial use, modification and redistribution without a fee or a contributor agreement.

> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction
> — https://github.com/microsoft/agent-framework/blob/main/LICENSE · LICENSE file, MIT License grant paragraph

## What it costs to run

**How it meters** · Partly — The framework itself costs nothing, so all spend is model and tool consumption metered by whichever provider you configure; Microsoft publishes no calculator and states the usage cost is yours.

> Third-Party Systems are Non-Microsoft Products under the Microsoft Product Terms and are governed by their own third-party license terms. You are responsible for any usage and associated costs.
> — https://learn.microsoft.com/en-us/agent-framework/overview/ · Overview, Important callout at the end of 'Why Agent Framework?'

**Free tier** · Yes — No sales call, no account and no licence fee: the packages install from PyPI and NuGet under an MIT grant that is explicitly free of charge.

> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software")
> — https://github.com/microsoft/agent-framework/blob/main/LICENSE · LICENSE file, MIT License grant paragraph

**API access** · Yes — The product is itself a code library, and its hosting packages additionally expose an agent over OpenAI-compatible Responses and Chat Completions endpoints from your own server.

> OpenAI-compatible endpoints for Responses and Chat Completions-compatible APIs.
> — https://learn.microsoft.com/en-us/agent-framework/hosting/ · 'Choose a protocol separately' section, first bullet

**MCP server** · Partly — Another agent can reach yours over MCP or A2A, but the Python hosting packages that expose those endpoints are prerelease, and you must build and secure the server yourself.

> MCP tools for exposing an agent or workflow as a native MCP tool.
> — https://learn.microsoft.com/en-us/agent-framework/hosting/ · 'Choose a protocol separately' section, final bullet

**Bring your own key** · Yes — You bring your own inference: the framework requires you to configure your chosen provider's keys and endpoints, and it never brokers or resells model access.

> API Dependencies: Requires proper configuration of LLM provider keys and endpoints
> — https://github.com/microsoft/agent-framework/blob/main/TRANSPARENCY_FAQ.md · Limitations answer, 'Framework-Specific Limitations' bullet list

## Buying it for a team

**Admin controls** · Partly — Constraints are real but developer-set in code, not an admin console: per-tool approval, regex shell allow and deny lists, and FIDES policy middleware that blocks a sensitive tool before it runs.

> `ShellPolicy` applies regular-expression allow and deny lists before execution. Deny rules take precedence.
> — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/tools/shell-tools · Python pivot, 'Restrict commands with ShellPolicy' section

**Audit log** · Partly — Agent actions are traceable via OpenTelemetry, and the FIDES security provider keeps per-session audit records of policy decisions, but there is no administrative action log because there is no admin plane.

> `SecureAgentConfig` stores labels, hidden variables, audit records, and pending approvals in the active `AgentSession`.
> — https://learn.microsoft.com/en-us/agent-framework/agents/security · Python pivot, 'Keep security state scoped to a session' section

## What happens to your code

**Opt out of training** · Partly — Microsoft makes no training claim for the framework and instead pushes the question to whichever model or tool provider you configure, telling you to review their retention and privacy terms first.

> Provider Due Diligence: Before integrating any external service, you should review their privacy policies, security practices, data retention policies, and terms of service to ensure they meet your organization's requirements and regulatory obligations.
> — https://github.com/microsoft/agent-framework/blob/main/TRANSPARENCY_FAQ.md · 'What data can Microsoft Agent Framework provide to external services?' answer, Important Security Considerations list

**Data residency** · Partly — Because you host it, residency follows your deployment and your chosen providers; Microsoft explicitly makes keeping data inside your compliance and geographic boundaries your responsibility rather than guaranteeing a region.

> It is your responsibility to manage whether your data will flow outside of your organization's Azure compliance and geographic boundaries and any related implications, and that appropriate permissions, boundaries and approvals are provisioned.
> — https://learn.microsoft.com/en-us/agent-framework/overview/ · Overview, Important callout at the end of 'Why Agent Framework?'

**Getting out** · Yes — Nothing is locked in a vendor store: sessions and history go to a session store you implement over your own database or blob storage, and there are no credits to expire.

> Your application controls routing, identity, authorization, request policy, storage, deployment, and scaling.
> — https://learn.microsoft.com/en-us/agent-framework/hosting/self-hosting/ · C# pivot, first paragraph of 'Self-host Agent Framework applications'

_Not established: Certifications_

## Platform record (as of 2026-08-30)

Reported by the code-hosting platform, not by the vendor.

| Fact | Value |
| --- | --- |
| Licence | MIT |
| Stars | 13219 |
| Forks | 2240 |
| Last push | 2026-08-30 |

## Provenance

1 of 23 sources behind the facts above are independent of the vendor.

## Coverage elsewhere

Pages about this product that the vendor does not control. The label states how independent each one is.

| Source | Kind | Read |
| --- | --- | --- |
| pypi.org | Platform record | 2026-08-24 |

## What changed

- 2026-09-19 — Capabilities · Commercial terms · Free tier · Price
- 2026-09-02 — Capabilities · Commercial terms · Free tier
- 2026-08-31 — Capabilities · Commercial terms · Free tier
- 2026-08-23 — Alternatives · Documentation link · One-liner · Repository · Summary
- 2026-08-19 — One-liner · Summary

## Correcting this record

Anything marked "Not established" is a question we have not answered — it is not a No. If you represent Microsoft Agent Framework, or anything here is wrong or out of date, you can supply it with a source: the operations this site accepts from an agent are listed at https://theagentsindex.com/.well-known/agents.json — that catalogue needs no key to read, and each entry states its own auth.

Supplying evidence is free. Nothing that can be bought here changes what a field says, whether a gap is closed, or how this record is scored.