Let agents reason. Let Goa generate.

Goa is a Go framework that gives coding agents less code to write and one contract to reason from. Generate HTTP, gRPC, and JSON-RPC servers, typed clients, validation, and API specifications. Build AI agents, MCP servers, and tool registries with Goa-AI.

Build a service Build an AI agent

GitHub Goa Goa-AI

Give your coding agent the Goa skill

Open source. MIT licensed. Built in Go.

Goa Guru

Goa Services Goa-AI AI agents

design/catalog.goDesign excerpt

Service("catalog", func() {
    JSONRPC(func() { POST("/rpc") })
    Method("lookup", func() {
        Payload(LookupPayload)
        Result(Product)
        HTTP(func() { GET("/products/{sku}") })
        GRPC(func() {})
        JSONRPC(func() {})
    })
})

goa gen example.com/catalog/design

Code your agent doesn’t have to write

HTTP + gRPC + JSON-RPC
Typed clients
Service interfaces
Validation + codecs
OpenAPI + Protocol Buffers
Command-line clients

design/catalog.goDesign excerpt

Agent("assistant", "Find products", func() {
    Use("catalog", func() {
        Tool("lookup", "Find a product by SKU", func() {
            Args(LookupPayload)
            Return(Product)
            BindTo("lookup")
        })
    })
})

goa gen example.com/catalog/design

Code your agent doesn’t have to write

Tool JSON schemas
Typed payload codecs
Service bindings
Typed tool descriptors
Runtime registrations
AGENTS_QUICKSTART.md

Read the complete example

A smaller job for your coding agent.

A model shouldn’t have to rediscover your architecture or rewrite the same plumbing every time you add a feature.

Generate once. Skip the token spend.: Every generated transport, client, and schema is code the LLM doesn’t need to compose. Spend that work on domain logic, useful tests, and better tools.
Give context a source of truth.: Types, constraints, descriptions, and methods live in the design. Consistent generated structure gives the agent a map of the codebase and a clear place to make changes.
Turn drift into compiler errors.: Change the contract and regenerate every representation together. Go flags incompatible callers and implementations, giving your agent concrete feedback for the next edit.

Develop with a coding agent

Teach your agent the Goa way.

Install the Goa service designer skill in your project. It guides your coding agent through design, generation, implementation, and verification—including which files to edit and which to regenerate.

Installation and workflow

npx skills add goadesign/goa --skill goa-service-designer

Run in your project. Requires Node.js and npm.

Then give your agent a real task:

Use the goa-service-designer skill to add a catalog service with HTTP and gRPC endpoints. Generate the code, implement product lookup, and test it.

One ecosystem. Two ways to build.

Start with a service, an agent, or both. The same design language connects them.

Goa

One contract. Every transport.

Define your service once. Generate its APIs, clients, validation, and specifications together. Implement the business logic behind a typed Go interface.

HTTP · gRPC · JSON-RPC: Servers, typed clients, and CLI clients from the same service design.
Streaming built into the design: WebSocket, Server-Sent Events, gRPC streaming.
Contracts that stay connected: Go types, validation, encoding, error mappings, OpenAPI, and Protocol Buffers.

Explore Goa GitHub

Goa-AI

Agents with a system behind them.

Design the tools and outcomes. Generate the contracts. Use the runtime to coordinate model calls, tool execution, human input, and durable workflows.

Typed tools and structured answers: Generated schemas, codecs, service bindings, and completion helpers.
Composition and evaluation: Agents as tools, linked child runs, typed evaluation suites, and scenario hooks.
Execution you can operate: Typed events, confirmations, cancellation, and policies. Local execution to start; Temporal for durability.

Explore Goa-AI GitHub

Your services belong in the AI ecosystem.

Goa-AI also builds the infrastructure that makes tools available—to your agents and to other AI applications.

Create MCP servers from your services.

Expose service methods as MCP tools. Publish resources and prompt templates. Goa-AI generates the protocol handling and adapters, so MCP becomes another interface to your application. Agents can also consume external MCP tools.

Build an MCP server

MCP("catalog", "1.0.0")
JSONRPC(func() { POST("/mcp") })

Method("lookup", func() {
    Payload(LookupPayload)
    Result(Product)
    Tool("lookup", "Find a product by SKU")
})

Inside a Goa service. Add Resource and StaticPrompt to expose more MCP capabilities.

Host a registry for your tools.

Run the included registry server as a shared catalog and invocation gateway. Publish toolsets, discover their schemas, and route calls to healthy providers. Agents and tool providers can deploy and scale independently. Backed by Redis and Pulse.

Host a tool registry

catalogsearchbilling

Your tool registryDiscover schemas. Route calls. Track health.

Your agents and applications

Design the intent. Generate the repetition.

One workflow for you, your team, and your coding agent.

Describe the contract
Define types, operations, and constraints in a readable Go design.
Run the generator
Let goa gen produce the code derived from that contract.
Build the behavior
You and your coding agent write service logic, planners, and tests.
Change with feedback
Regenerate after a design change. Compile, test, and review the result.

Questions before you start

Why use Goa if a coding agent can write the code?: A coding agent authors code by inference; Goa derives contract code from your design. Each generated server, client, codec, and schema is code the model does not need to write separately. The design concentrates context, the generated structure stays consistent, and the compiler identifies incompatible implementations after changes. Your agent still writes business logic and tests.
What is the difference between Goa and Goa-AI?: Goa designs and generates Go service APIs: HTTP, gRPC, JSON-RPC, clients, validation, and specifications. Goa-AI extends the same DSL and generator with typed tools, AI agents, structured completions, evaluations, and MCP servers. It also provides an agent runtime and a hosted tool registry server. You can start with either framework; Goa-AI does not require a separately deployed Goa service.
Can I use Goa-AI just to build an MCP server?: Yes. Add MCP declarations to a Goa service to generate a server exposing tools, resources, and prompt templates. Implement the service methods behind the generated adapters. You do not need to run a Goa-AI agent to serve MCP.
How does generation reduce LLM work?: Goa generates the transport and contract code without an LLM composing those files. That removes a category of output-token work. Total savings depend on the task, model, context, and iterations; compare complete changes, including tests and review, to measure the effect in your project.

Build on open foundations.

Goa and Goa-AI are part of an open-source toolkit for Go services, agents, observability, and distributed systems.

Explore the ecosystem

Working examples Ask the community Gophers Slack Contribute

Let agents reason. Let Goa generate.

Code your agent doesn’t have to write

Code your agent doesn’t have to write

A smaller job for your coding agent.

Teach your agent the Goa way.

One ecosystem. Two ways to build.

Goa

Goa-AI

Your services belong in the AI ecosystem.

Create MCP servers from your services.

Host a registry for your tools.

Design the intent. Generate the repetition.

Describe the contract

Run the generator

Build the behavior

Change with feedback

Questions before you start

Build on open foundations.

Sponsors

Trusted by Engineering Teams Worldwide