Go services. Less code to write.

Goa is a design-first Go framework that generates HTTP, gRPC, and JSON-RPC APIs from a single contract. Describe your types, operations, and validation in Go. Goa generates the server and client code, CLI clients, and OpenAPI/protobuf specifications. You and your coding agent implement the business logic.

For a coding agent, that's less repetitive code to write, fewer representations to keep in sync, and a clear contract to reason from.

Quickstart · Documentation · Examples · Build AI agents with Goa-AI

Give your coding agent a contract

A new field can affect a handler, a client, validation, and an API specification. With Goa, your agent changes the design and regenerates those pieces together.

• Spend tokens on the interesting work. Goa generates routing, serialization, validation, and clients. Your agent can focus on requirements, business rules, and tests.
• Start from useful context. Types, descriptions, examples, errors, and constraints live together in the design. The agent can read the relevant contract before exploring the implementation.
• Make edits predictable. Change design/, regenerate gen/, implement outside it. The same structure carries across services and transports.
• Let the compiler guide the next step. When a generated interface changes, Go identifies implementations and callers that need updating. Tests cover the behavior.

Install the Goa service designer skill in your application repository:

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

The installer requires Node.js and npm and lets you choose your coding tool. The skill guides design changes, generation, implementation, and verification, and points the agent to relevant Goa documentation.

Then give it a real task:

Add a catalog service with a product lookup by SKU over HTTP and gRPC. Use the Goa service designer skill. Define the contract, generate the code, implement the lookup, and test successful and missing-product responses.

See the coding-agent workflow · Other skill installation options

One design. Three ways to call it.

This service exposes the same greeting over HTTP, gRPC, and JSON-RPC:

package design

import . "goa.design/goa/v3/dsl"

var _ = Service("hello", func() {
	Description("Greets people by name.")
	JSONRPC(func() {
		POST("/rpc")
	})

	Method("greet", func() {
		Description("Return a personal greeting.")
		Payload(func() {
			Field(1, "name", String, "Name to greet", func() {
				MinLength(1)
			})
			Required("name")
		})
		Result(String)

		HTTP(func() {
			GET("/hello/{name}")
		})
		GRPC(func() {
		})
		JSONRPC(func() {
		})
	})
})

Goa generates the three transports, their Go clients, request validation, a CLI client, OpenAPI specifications, and Protocol Buffer definitions. They all call the same generated service interface. Your complete hello.go implementation is ordinary Go:

package helloapi

import (
	"context"

	genhello "hello/gen/hello"
)

type hellosrvc struct{}

// NewHello returns the greeting service.
func NewHello() genhello.Service {
	return &hellosrvc{}
}

// Greet returns a greeting for the supplied name.
func (s *hellosrvc) Greet(ctx context.Context, p *genhello.GreetPayload) (string, error) {
	return "Hello, " + p.Name + "!", nil
}

Here, genhello is the generated gen/hello package. The generated transports reject an empty name before calling Greet. Add a field or change a validation rule in the design, then regenerate the corresponding code and specifications.

Try it

Start with Go 1.26 or later; Go 1.27.1 is recommended:

mkdir hello && cd hello
go mod init hello
go get goa.design/goa/v3@latest
mkdir design

Save the design above as design/design.go. For all three transports, install the Protocol Buffer compiler and the Go protobuf generators. For an HTTP-only first run, omit both JSONRPC blocks and the GRPC block.

Generate the code and starter application:

go mod tidy
go run goa.design/goa/v3/cmd/goa gen hello/design
go run goa.design/goa/v3/cmd/goa example hello/design

Replace the starter hello.go with the implementation above, then run:

go mod tidy
go run ./cmd/hello --http-port=8000

In another terminal:

curl http://localhost:8000/hello/Alice
# "Hello, Alice!"

Try the generated HTTP, gRPC, and JSON-RPC clients

If you kept all three transports in the design, each command returns "Hello, Alice!":

go run ./cmd/hello-cli --url=http://localhost:8000 hello greet --name=Alice
go run ./cmd/hello-cli --url=grpc://127.0.0.1:8080 hello greet --message '{"name":"Alice"}'
go run ./cmd/hello-cli --jsonrpc --url=http://localhost:8000 hello greet --body '{"name":"Alice"}'

gen replaces the generated tree. example creates missing application files and leaves existing ones alone. Keep your implementation outside gen/, and use go run as above to run the generator version selected by your module.

For a guided walkthrough, follow the HTTP quickstart.

More of your service, generated

Design in Goa	Get from the generator
Types, methods, validation, and errors	Typed service interfaces, endpoints, clients, and boundary validation
HTTP routes, parameters, headers, and bodies	Server handlers, encoders/decoders, Go clients, CLI commands, and OpenAPI specifications
gRPC messages, metadata, and status mappings	Protocol Buffer definitions, server/client adapters, serialization, and CLI commands
JSON-RPC methods and error mappings	Server/client code, request dispatch, batches, and notifications
Streaming methods	WebSocket and SSE support for HTTP, SSE for JSON-RPC, and gRPC streams
Result views	Named response shapes and the code to select and serialize them

Build on these with security schemes, interceptors, and production guidance, or extend generation with plugins.

One ecosystem. Services and AI agents.

Goa-AI brings the same approach to AI applications. Reuse Goa types and bind tools to service methods, so your API and agent tools share a contract.

• Build AI agents with typed tools, structured completions, agent composition, streaming, and evaluation suites.
• Create MCP servers that expose tools, resources, and prompts from your design.
• Host a tool registry for discovery and invocation across providers.
• Run locally or durably with the in-memory engine for local execution or the Temporal engine for durable workflows.

You implement the planner and application behavior; Goa-AI generates contracts, schemas, codecs, and integration code.

Explore Goa-AI → · Quickstart · A service and an agent sharing one design

Upgrading to v3.32.0

v3.32.0 fixes client-interceptor imports in generated transport clients and command starters, exposes the corresponding generation-plan query to plugins, and updates dependencies. Goa now requires Go 1.26 or later.

Projects upgrading from v3.30.x must also account for the intentional source and transport changes introduced in v3.31. Read the upgrade guide before regenerating; it separates those migrations from the v3.32 changes. The release notes explain the benefits and fixes.

Keep exploring

• Learn the design language: DSL reference and code generation.
• Choose a transport: HTTP guide, gRPC guide, and JSON-RPC reference.
• See complete applications: Examples cover security, streaming, file uploads, interceptors, tracing, and more.
• Give an agent focused documentation: Start with llms.txt, then load the relevant guide's Markdown version.

Sponsors

Goa is supported by these sponsors. Thank you for helping keep the project growing.

Bounce back stronger after every incident Run incidents end-to-end. Rapidly fix and learn from incidents, so you can build more resilient products. Explore incident.io →

Enterprise DevEx for your API Create feature-rich SDKs. Speed up integrations and reduce errors by giving your API the DevEx it deserves. Integrate with Goa →

Join the community

Questions, ideas, and contributions are welcome.

• Talk with us: Gophers Slack #goa and GitHub Discussions.
• Get help: Goa Guru and Goa Design Wizard.
• Follow along: Bluesky and Design First on Substack.
• Contribute: Report a bug or open a pull request.

MIT licensed. See LICENSE · Go Report Card.