GOA-AI

Design-First Agents

Define the contract. Generate the infrastructure. Execute with confidence.

The Agentic Crisis

🥀 Brittle Wiring

Hand-rolled JSON schemas and string-based tool calling fail at the first sign of drift.

🌫️ Opaque Loops

"Why is it looping?" "What did it just do?" Traditional agents are a black box until they fail.

⚰️ Ephemeral State

Process crashes = lost runs. No durability, no resumption, no production readiness.

✨ The Goa-AI Way

Strong contracts, real-time streaming, and durable execution. Built for engineering teams, not scripts.

Philosophy

The Design-First Loop

Stop writing glue code. Express your intent in Go DSL and let the framework handle the heavy lifting.

1. DESIGN

Define agents, tools, and policies in a typed DSL.

↓

2. GENERATE

`goa gen` produces tool specs, codecs, and workflows.

↓

3. EXECUTE

The runtime enforces policies, streams events, and ensures durability.

Agent("assistant", func() {
    Use(WeatherTools)
    RunPolicy(func() {
        DefaultCaps(MaxToolCalls(10))
        TimeBudget("5m")
    })
})
            

Power Feature

BindTo & Inject

Already have services? Connect them in seconds.

BindTo: Direct Mapping

Maps tool definitions directly to Goa service methods. No manual transformation, no brittle mapping layers.

Tool("search", func() {
    BindTo("SearchService", "Query")
})
            

Inject: Stealth Context

Strip infrastructure fields (auth, tenant_id) from the LLM's view. Populated automatically by runtime interceptors.

Tool("get_data", func() {
    Inject("session_id", "user_id")
})
            

Composition

Composition that Scales

In Goa-AI, an agent is just another tool. Orchestrate specialists without breaking a sweat.

Specialist Autonomy

Each child agent has its own planner, tools, and run lifecycle.

Linked Run Trees

Parent receives a RunLink handle. Full traceability from orchestrator to deep specialist.

Agent("orchestrator", func() {
    UseAgentToolset("research_svc", "analyst", "export")
})
        

Reliability

The Temporal Engine

Runs that survive the impossible. Infrastructure, not just code.

Automatic Retries

Failed tools retry without re-calling the LLM. Absorb network blips transparently.

Stateful Resumption

Browser closes? Server restarts? Workers poll and resume exactly where they left off.

Pause & Clarify

Agent needs help? It pauses (consuming zero compute) and waits for human input to resume.

Policy Guardrails

Runtime enforces tool budgets, time limits, and consecutive failure caps at the workflow level.

RAD FEATURE

The Pulse Stream

Real-time visibility across distributed boundaries. Radically transparent agents.

Typed Event Firehose

Every thought, tool call, and chunk is a typed event on a Redis stream.

Audience Profiles

Filter streams for UserChat, AgentDebug, or Metrics consumption.

switch e := event.(type) {
case *stream.PlannerThought:
    fmt.Printf("💭 %s", e.Data.Content)
case *stream.ToolStart:
    fmt.Printf("🔧 Running %s", e.Data.ToolName)
}
            

The Ecosystem

The Universal Bridge (MCP)

Goa-AI is a two-way Model Context Protocol powerhouse.

Consume MCP Servers

Instantly turn any MCP server (filesystem, postgres, etc.) into a typed Goa toolset.

Toolset(FromMCP("fs", "local-mcp"))

Expose Your Services

One line in your DSL turns your Goa service into an MCP server for any agent to use.

Service("calc", func() { MCP("calc", "1.0") })

Scalability

The Company Catalog

Dynamic tool discovery and invocation across process boundaries.

Global Discovery

Toolsets register with the clustered registry. Any agent can find them by name at runtime.

Coordinated Health

Clustered nodes handle distributed health checks. Automatic failover for remote toolsets.

Registry Nodes form a cluster via Redis + gRPC. Unified tool catalog for the entire enterprise.

Implementation

Clean-Room Quickstart

1. Design your toolset

var Weather = Toolset("weather", func() {
    Tool("get", func() {
        Args(func() { Attribute("city", String) })
        Return(Temperature)
    })
})
            

2. Register your agent

assistant.Register(ctx, rt, assistant.Config{
    Planner:  &MyPlanner{},
    Executor: &MyExecutor{},
})
            

3. Run it!

client := assistant.NewClient(rt)
out, _ := client.Run(ctx, userMsg)
fmt.Println(out.RunID)
            

Success!

Type-safe, validated, and streamed in under 5 minutes of setup.

The Opus Summary

Infrastructure First

Stop building scripts. Start building durable, design-first reasoning systems.

Type Safety Matters

From DSL to JSON Schema to Go types. The compiler is your best friend again.

Ecosystem Ready

MCP, Registry, and Composition make Goa-AI ready for enterprise scale today.

Rad Visibility

Pulse streaming ensures your agents are never a black box.