Go Micro — Agent Harness & Service Framework for Go
Build agents as services with memory, tools, guardrails, planning, delegation, and MCP/A2A interop — all in Go.
Evidence shows guardrails like MaxSteps, LoopLimit, ApproveTool, but no explicit least-privilege defaults; user confirmation exists via ApproveTool but not default; data flow transparency via MCP/A2A gateways and tool wrappers, but logging not detailed; sensitive data handling has TLS and secrets management advice, but not framework-internal; dependency security has govulncheck workflow with ALLOWLIST, but known unfixed vulns; external effects include x402 payments and deployment, but side-effect control not explicit; rollback via durable flows and checkpoints, but no explicit rollback mechanism; source attribution via Apache-2.0, but publisher unverified.
Self-consistency: README and code examples align, but no execution verified; dependency availability: go.mod lists deps, but availability not verified; failure messages: error handling examples and CLI diagnostics, but not comprehensive.
Audience and scenarios: developer-oriented with quick start and examples; capability boundaries: guardrails and tool wrappers, but limits not explicit; trigger precision: CLI commands and event-driven flows, but triggers not explicit; environment fit: multiple deployment options, but not all environments covered.
Information architecture: README, docs, examples well-structured; install notes: install script and Docker options; naming stability: versioned module path; examples and FAQ: extensive examples and docs; known limitations: SECURITY.md mentions TLS default disabled, but not comprehensive; license: Apache-2.0; versioning and changelog: version support, but no CHANGELOG; maintenance responsibility: commercial support and community channels.
Output usability: CLI and API with clear output formats; marginal value: agent harness and framework with unique features; cost-benefit: open-source free, but commercial support paid.
Claim traceability: README features have code examples and doc links; cross-source corroboration: test files and CI workflows; fact-inference separation: docs distinguish feature descriptions and design intent.
- Publisher identity unverified; assess supply chain risk carefully.
- Known unfixed vulnerabilities (e.g., pgx-related) exist; monitor dependency security.
- TLS certificate verification disabled by default; enable explicitly in production.
- No CHANGELOG provided; version history not transparent.
What does this agent do, and when should you use it?
Go Micro is an agent harness and service framework written in Go. It provides the runtime around an agent: tools, memory, guardrails, workflows, and protocols. Agents are services that register, discover, and expose a Chat RPC endpoint. Services are structs with methods; their endpoints become AI-callable tools automatically. The framework includes pluggable abstractions for registry, broker, store, and model provider, supporting 9 LLM providers. It integrates MCP for tools and A2A for agent interop, and supports paid tools via x402. A CLI (`micro`) scaffolds, runs, and debugs services and agents. Workflows provide durable execution.
Running micro run starts services, launches a gateway, an interactive console, and hot-reload. micro run --prompt "..." uses an LLM to generate services and an agent. Agents have built-in plan and delegate tools for multi-step planning and delegation to other agents. Services communicate via gRPC and are registered/discovered via the registry. Endpoints are exposed as MCP tools at /mcp/tools. micro a2a serve starts an A2A gateway making agents reachable over A2A protocol. micro mcp serve supports x402 payments. Flows enable durable, checkpointed execution that resumes after crashes.
- Go teams wanting to integrate AI agents into existing microservices without rewriting services.
- Developers who need agents to call internal APIs as tools, with automatic schema generation.
- Organizations requiring interop with other agent frameworks via A2A protocol.
- Companies wanting to monetize agent tool calls using x402 stablecoin payments.
- Teams needing persistent conversation memory and crash-resilient workflows.
- Developers wishing to generate backend services and agents from natural language prompts.
What are this agent's strengths and limitations?
- Agent-as-service: endpoints automatically become AI tools.
- Built-in MCP and A2A support for cross-framework interop.
- Durable memory and workflows survive crashes.
- Pluggable model providers (9 LLMs) and dependency injection.
- CLI with hot-reload, templates, and one-command deploy.
- Relatively new framework with smaller ecosystem.
- x402 payments require external facilitator setup.
- Learning curve for harness and flow concepts.
- Some features (like A2A) may require additional configuration.
How do you install or deploy this agent?
Install the CLI: curl -fsSL https://go-micro.dev/install.sh | sh, or go install go-micro.dev/v6/cmd/micro@latest. Binary install requires no Go.
How do you use this agent?
Quick start: micro new helloworld, then cd helloworld && micro run, then curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call -H 'Content-Type: application/json' -d '{"name":"World"}'. For prompt-based generation, set an API key: export ANTHROPIC_API_KEY=..., then micro run --prompt "a task management system". Programmatic agent: micro.NewAgent("task-mgr", micro.AgentServices("task"), micro.AgentPrompt("..."), micro.AgentProvider("anthropic")), then agent.Ask(ctx, "...").
How does this agent compare with similar options?
No explicit competitors mentioned, but it can be compared to other Go microservice frameworks (e.g., go-kit) or general agent frameworks like LangChain.