Go Micro

Agent harness and microservice framework, in one Go runtime.

Free· Open source (Apache 2.0). Commercial support available separately; hosted model access via Atlas Cloud is billed by that provider.AgentsModel-agnostic: Claude (Anthropic), OpenAI, and 300+ models via Atlas Cloud

Visit website →

Best for

Go teams building production agent systems that need to coexist with — or expose — real microservices, and want durable workflows plus MCP tool integration without stitching five libraries together.

Skip if

Python or TypeScript shops, prototype notebooks, or teams that just need a thin LLM wrapper without a service framework attached.

Go Micro is an Apache-2.0 licensed Go framework that fuses two things that usually live in separate stacks: an AI agent harness (memory, tools, guardrails, middleware, durable workflows) and a full microservices runtime (service discovery, RPC, pluggable transports, config, brokers). The pitch is that in a real production system your agents need to call services, and your services increasingly need to be callable by agents — so Go Micro treats every service endpoint as an MCP-exposable tool automatically, and gives agents first-class discovery of other agents and services on the same mesh.

Developers scaffold with `micro new`, run everything locally with hot reload via `micro run`, and can talk to a running agent from the terminal with `micro chat`. Under the hood the abstractions are Go interfaces, so registry, broker, transport, store, and model backend are all swappable. It plugs into Claude, OpenAI, and roughly 300 additional models through Atlas Cloud, but you can point it at any provider with a client.

The durable-workflow layer is the piece that matters for long-running agents: code paths are checkpointed, so a tool call that takes minutes, a human-in-the-loop wait, or a crash mid-run resumes from the last committed step instead of re-executing side effects. That, plus the built-in service mesh, is what separates it from the more common 'agent SDK stapled to a REST server' pattern. Common workflows include: standing up an agent that fronts an existing gRPC/HTTP service estate; building agent-to-agent systems where specialized agents coordinate over the registry; and shipping self-hostable agent products where the same binary handles both the agent loop and the surrounding services.

Editor's take

The interesting bet here is that agents and microservices are converging, and Go Micro is one of the few frameworks built on that premise instead of bolting an agent loop onto a web server. If you're already in Go and you're tired of writing MCP adapters by hand, it's worth an afternoon. If you're not in Go, it isn't for you.

— The AI Tool Bible editorial team

Pros

✅ Unifies agent runtime and microservice framework — one binary handles both the LLM loop and the surrounding services.
✅ Automatically exposes service endpoints as MCP tools, so agents can call your existing services without hand-written adapters.
✅ Durable, checkpointed workflows survive restarts and long tool calls without re-running side effects.
✅ Every abstraction (registry, broker, transport, store, model) is a Go interface — genuinely pluggable.
✅ Apache 2.0 with a large existing Go Micro community (23k+ GitHub stars) and no vendor lock-in on models.
✅ Local dev loop is tight: `micro new`, `micro run` with hot reload, and `micro chat` to talk to the agent from the terminal.

Cons

⚠️ Go-only — if your team's stack is Python or TypeScript, most of the surrounding ecosystem (LangChain, LlamaIndex, DSPy) doesn't apply.
⚠️ The framework is opinionated about services; teams that just want a thin agent library will find it heavier than they need.
⚠️ Documentation and examples for the newer AI-agent surface are thinner than the mature microservice docs.
⚠️ Model routing through Atlas Cloud is convenient but adds a hosted dependency and its own billing if you use it.
⚠️ Durable workflows require you to think about idempotency and checkpoint boundaries — not a drop-in for casual scripts.

Use cases

Production AI agents that call internal microservicesAgent-to-agent systems with service discoveryMCP tool servers backed by existing gRPC/HTTP APIsDurable long-running agent workflowsSelf-hosted agent products in GoMulti-model routing across Claude, OpenAI, and open modelsChat-frontends over existing service estatesHuman-in-the-loop workflows with checkpointed resume