Microsoft Agent Framework for Go Enters Public Preview

Microsoft has released a Go SDK for its Microsoft Agent Framework, bringing production-grade AI agent building to Go developers for the first time. Announced on July 10, 2026 as a public preview, the Go SDK lets you build agents that call tools, hold context, coordinate with other agents, stream output, and emit traces, all in native Go. It joins the framework's existing .NET and Python SDKs, and it installs with a single go get github.com/microsoft/agent-framework-go.

For anyone building automation, content pipelines, or backend services in Go, this closes a real gap. Until now, serious agent tooling meant reaching for Python or wiring up a third-party library. The framework's headline capabilities, tools, Model Context Protocol support, multi-agent workflows, and OpenTelemetry tracing, now ship as first-class Go APIs.

What Microsoft Shipped

The Go SDK is a public preview of the same agent concepts Microsoft already ships in .NET and Python, rebuilt idiomatically for Go. The agent-framework-go repository exposes providers, agent construction, tool calling, and workflow orchestration. Microsoft is explicit that the surface is still moving: "Because this is a public preview, APIs may evolve as we collect feedback." That is the standard preview caveat, so treat it as production-capable but version-pinned rather than frozen.

Out of the box, the Go SDK ships model providers for Microsoft Foundry, Azure OpenAI and OpenAI-compatible endpoints, Anthropic, Gemini, and A2A. That provider spread matters: you are not locked to Azure. You can point the same agent code at Claude or Gemini by swapping a provider, which is exactly the portability creators want when model prices and quality shift week to week.

How the Go SDK Fits the Broader Framework

The Microsoft Agent Framework is the convergence of two earlier Microsoft projects: the enterprise-focused Semantic Kernel and the research-focused AutoGen. Microsoft shipped Agent Framework 1.0 for .NET and Python in April 2026, folding both predecessors into a single production line and putting the old frameworks into maintenance mode. The Go SDK is the third language to land, and it inherits the same building blocks documented in the Agent Framework overview.

Here is how the three SDKs compare as of this preview:

The practical read: if you want the most stable, fully documented surface today, Python and .NET are further along. If your stack is Go, the preview is finally a native option instead of a shim.

A Minimal Agent in Go

Creating an agent takes a provider, a credential, a model deployment, and instructions. Microsoft's own starting example looks like this:

agent := foundryprovider.NewAgent(
    endpoint,
    credential,
    foundryprovider.ModelDeployment(model),
    foundryprovider.AgentConfig{
        Instructions: "You are a helpful assistant.",
    },
)
resp, err := agent.RunText(ctx, msg).Collect()

The shape is deliberately familiar to Go developers: construct with functional options, run with a context, collect a streamed response. From there you attach tools, wire in Model Context Protocol servers for external data and actions, add middleware, and register context providers. Automatic tool calling means the model decides when to invoke a tool and the framework executes it, rather than you hand-rolling the call loop.

Multi-Agent Workflows: Routing, Checkpoints, Human Review

The framework's real differentiator is workflows. Beyond single agents, the Go SDK supports multi-agent orchestration with routing between agents, checkpoints for pause and resume, streaming intermediate results, and human review steps. Checkpoints matter for anything long-running: a content-generation or research pipeline can pause, persist state, and resume without losing work. Human review lets you gate an agent's action behind an approval, which is the difference between a demo and a system you would run against real accounts or spend.

Every agent run can emit OpenTelemetry traces, so you can see which tools fired, how long each step took, and where a workflow stalled. That observability is what turns an agent from a black box into something you can debug and cost-account. This mirrors the direction other vendors are taking; see how Gemini's managed agents added background tasks and MCP for the same production concerns.

Go vs Other Agent Options

Go developers have not been entirely empty-handed. Community libraries like LangChainGo have offered agent primitives for a while. What Microsoft brings is a first-party, multi-language framework with a shared mental model across Go, Python, and .NET, plus native Agent2Agent (A2A) support for agent-to-agent communication and built-in workflow orchestration rather than a loose collection of chains. If your team already runs the framework in Python and wants a Go service to participate in the same agent mesh, the shared abstractions and A2A provider are the pitch. If you just need a single agent with tool calls, the lighter community options are still viable.

What This Enables

For creators and builders working in Go, this unlocks a few concrete things. You can now build a content or media pipeline as a Go service that orchestrates multiple specialized agents, one to draft, one to fact-check, one to format, with checkpoints between stages and a human approval before anything ships. You can embed an agent inside an existing Go backend, CLI, or worker without bolting on a Python sidecar. And because the provider layer is swappable, you can run the same workflow against Claude, Gemini, or an OpenAI-compatible endpoint and pick per task on quality and cost. Microsoft has been pushing agent frameworks across its stack, including the separately announced Windows Agent Framework; the Go SDK extends that reach to server-side and cloud-native workloads where Go dominates.

How to Get Started

Install the module with go get github.com/microsoft/agent-framework-go, pick a provider that matches the model you want, and start with a single tool-using agent before graduating to a multi-agent workflow. Because this is a preview with evolving APIs, pin your module version and read the release notes before upgrading. Wire OpenTelemetry from day one so you can see token spend and latency as you scale. Then add a human-review checkpoint on any workflow that touches real money, real accounts, or published output.

Frequently Asked Questions

Is the Microsoft Agent Framework Go SDK production-ready?

It is a public preview, not a GA release. The building blocks match the GA .NET and Python SDKs, but Microsoft warns the Go APIs may still change. It is safe to build with as long as you pin the version and expect some churn before GA.

Which model providers does the Go SDK support?

At preview it ships providers for Microsoft Foundry, Azure OpenAI and OpenAI-compatible endpoints, Anthropic, Gemini, and A2A. You can switch providers without rewriting your agent logic.

How is this different from Semantic Kernel and AutoGen?

The Microsoft Agent Framework is the successor to both. It merges Semantic Kernel's enterprise features with AutoGen's agent abstractions and adds graph-based workflows. The older frameworks are now in maintenance mode, so new capabilities land in Agent Framework.

Does the Go SDK support MCP?

Yes. Model Context Protocol is a first-class feature alongside tools, middleware, context providers, approvals, and automatic tool calling, so agents can connect to external data and action servers.

Can Go agents work with agents written in Python or .NET?

Yes, through the A2A (Agent2Agent) provider. Because all three SDKs share the same framework concepts, a Go service can participate in a multi-agent system that also includes Python and .NET agents.

What does the framework add over a library like LangChainGo?

First-party support, a shared model across three languages, native A2A communication, built-in multi-agent workflow orchestration with checkpoints and human review, and OpenTelemetry tracing. For a single tool-using agent, community libraries still work; for orchestrated multi-agent systems, the framework does more out of the box.