Aixgo · Open source · MIT

The AI Agent Framework That Ships in <20MB

Build, deploy, and scale AI agents in Go. No containers. No cold starts. No Python.

Status

Stable. The agent types, the orchestration patterns and the provider integrations are implemented; the latest release is named below, and the blog says what each one changed.

One Go module. Nothing to install alongside it at runtime.

MIT · 13 patterns · 8+ providers · one binary

<20MB
Single binary, no interpreter and no dependencies to ship
<100ms
Cold start, which is what makes serverless viable
13
Orchestration patterns, all implemented
8+
LLM providers behind one interface

01Quick start

Four steps from an empty directory to a running agent.

The configuration describes the agents and the wiring between them. The Go file does nothing but hand that configuration to the runtime.

  1. Install the module

    terminal
    go get github.com/aixgo-dev/aixgo
  2. Describe the agents

    config/agents.yaml
    supervisor:
      name: coordinator
      model: gpt-4o-mini  # OpenAI - fast orchestration
      max_rounds: 10
    
    agents:
      - name: data-producer
        role: producer
        interval: 1s
        outputs:
          - target: analyzer
    
      - name: analyzer
        role: react
        model: claude-3-5-haiku  # Anthropic - strong reasoning
        prompt: |
          You are a data analyst. Analyze incoming data and provide insights.
        inputs:
          - source: data-producer
        outputs:
          - target: logger
    
      - name: logger
        role: logger
        inputs:
          - source: analyzer
  3. Point main at the config

    main.go
    package main
    
    import (
        "github.com/aixgo-dev/aixgo"
        _ "github.com/aixgo-dev/aixgo/agents"
    )
    
    func main() {
        if err := aixgo.Run("config/agents.yaml"); err != nil {
            panic(err)
        }
    }
  4. Build it and run it anywhere

    terminal
    # Local development
    go run main.go
    
    # Production - single <20MB binary
    go build -o agent
    ./agent
    
    # Edge, Lambda, Cloud Run, Kubernetes - one binary, zero configuration

Read the guides →

02Why Go

What changes when an agent ships as a compiled binary.

Python won prototyping because it is quick to write. The costs arrive later, at the point where the thing has to be deployed and kept running.

Container size

Python frameworks
1.2GB with dependencies
Aixgo
<20MB single binary
What that buys you
Deploy to edge devices, serverless, anywhere

Startup performance

Python frameworks
30-45s cold start
Aixgo
<100ms instant startup
What that buys you
True serverless viability, real-time response

Runtime safety

Python frameworks
Runtime - discover errors in production
Aixgo
Compile-time - compiler catches errors before deploy
What that buys you
Ship with confidence, sleep at night

LLM data validation

Python frameworks
Runtime only - type changes found in production
Aixgo
Compile-time - type changes caught before deploy, auto-retry
What that buys you
Refactor with confidence, LLM errors auto-recover

03Side by side

The six differences that show up in production.

What matters in productionPython frameworksAixgo
Deploy anywhere1GB+ containers, complex deps<20MB binary, zero deps
Cold start speed10-45 seconds<100ms
Type safetyRuntime discoveryCompile-time guarantees
ConcurrencyGIL bottleneckNative parallelism
Scaling patternRewrite for distributionSame code, local to distributed
Operational costHigh compute overhead60-70% infrastructure savings

04In the binary

What you get without adding a dependency.

13 orchestration patterns

Supervisor, Sequential, Parallel, Router, Swarm, RAG, Reflection, Ensemble and more, all production-ready. Go channels locally, gRPC when the same code runs distributed.

8+ LLM providers

OpenAI, Anthropic, Google Gemini, xAI, Vertex AI, HuggingFace, Ollama and vLLM behind one interface. Switching provider is a config change, and the model name selects it.

Observability that is already wired

OpenTelemetry tracing, Langfuse, Prometheus metrics and automatic cost tracking. Kubernetes health probes are included.

Security controls in the framework

4 auth modes, RBAC, SSRF protection, prompt injection defense and SIEM integration. Rate limiting and audit logging are built in.

Type-safe validation

Pydantic AI-style validation with automatic retry, worth a 40-70% improvement in structured output reliability, checked at compile time.

60-70% lower infrastructure cost

<20MB binaries, <100ms cold starts and roughly 50MB of memory. The Router pattern saves 25-50% on LLM spend; Ollama runs inference locally for none.

05Releases

Latest release: v0.7.4 · 2 May 2026

This line maintains itself: a workflow reads the GitHub API, a gate checks what it wrote, and a daily run fails loudly if the deployed page ever falls behind. No one edits it by hand. Release notes · All releases · What each release changed

Start with the quick start.

Four steps, ending with a running multi-agent system you can read top to bottom.

MIT · issues and discussions welcome