The AI Backend

Build and scale AI agents like APIs. Deploy, observe, and prove.

AI has outgrown chatbots and prompt orchestrators. Backend agents need backend infrastructure.

Docs · Quick Start · Python SDK · Go SDK · TypeScript SDK · REST API · Examples · Discord

AgentField is an open-source control plane that lets you build AI agents callable by any service in your stack - frontends, backends, other agents, cron jobs - just like any other API. You write agent logic in Python, Go, or TypeScript. AgentField turns it into production infrastructure: routing, coordination, memory, async execution, and cryptographic audit trails. Every function becomes a REST endpoint. Every agent gets a cryptographic identity. Every decision is traceable.

from agentfield import Agent, AIConfig
from pydantic import BaseModel

app = Agent(
    node_id="claims-processor",
    version="2.1.0",# Canary deploys, A/B testing, blue-green rollouts
    ai_config=AIConfig(model="anthropic/claude-sonnet-4-20250514"),
)

class Decision(BaseModel):
    action: str# "approve", "deny", "escalate"
    confidence: float
    reasoning: str

@app.reasoner(tags=["insurance", "critical"])
async def evaluate_claim(claim: dict) -> dict:

    # Structured AI judgment - returns typed Pydantic output
    decision = await app.ai(
        system="Insurance claims adjuster. Evaluate and decide.",
        user=f"Claim #{claim['id']}: {claim['description']}",
        schema=Decision,
    )

    if decision.confidence < 0.85:
        # Human approval - suspends execution, notifies via webhook, resumes when approved
        await app.pause(
            approval_request_id=f"claim-{claim['id']}",
            approval_request_url=f"https://internal.acme.com/approvals/claim-{claim['id']}",
            expires_in_hours=48,
        )

    # Route to the next agent - traced through the control plane
    await app.call("notifier.send_decision", input={
        "claim_id": claim["id"],
        "decision": decision.model_dump(),
    })

    return decision.model_dump()

app.run()
# This single line exposes: POST /api/v1/execute/claims-processor.evaluate_claim
# The agent auto-registers with the control plane, gets a cryptographic identity, and every
# execution produces a verifiable, tamper-proof audit trail.

What you just saw: app.ai() calls an LLM and returns structured output. app.pause() suspends for human approval. app.call() routes to other agents through the control plane. app.run() auto-exposes everything as REST. Read the full docs →

Prompt to production (recommended)

Describe the system in one line. Get a production-ready multi-agent backend.

Works in Claude Code, Codex, Gemini CLI, OpenCode, Aider, Windsurf, and Cursor.

curl -fsSL https://agentfield.ai/install.sh | bash

In Claude Code, fire it with the shipped slash command:

/agentfield a claims processor with risk scoring and human approval

Or paste any of these directly — the skill auto-matches, no slash command needed:

Build a claims-processor agent with risk scoring, pattern detection,
and human approval for low-confidence decisions.

Build a research agent that spawns parallel investigators and recurses
into deeper sub-questions until the answer has citation-grade provenance.

Build a compliance reviewer for support transcripts — extract claims,
check each against policy, flag violations, emit a signed audit trail.

You get a Docker Compose stack already wired up — the agent, the control plane, and a local curl you paste into a terminal to try it.

See it in action →

Prefer to write it yourself?

af init my-agent --defaults                            # Scaffold agent
cd my-agent && pip install -r requirements.txt
af server          # Terminal 1 → Dashboard at http://localhost:8080
python main.py     # Terminal 2 → Agent auto-registers

# Call your agent
curl -X POST http://localhost:8080/api/v1/execute/my-agent.demo_echo \
  -H "Content-Type: application/json" \
  -d '{"input": {"message": "Hello!"}}'

# Go
af init my-agent --defaults --language go && cd my-agent && go run .

# TypeScript
af init my-agent --defaults --language typescript && cd my-agent && npm install && npm run dev

# Docker (control plane only)
docker run -p 8080:8080 agentfield/control-plane:latest

What You Get

Build - Python, Go, or TypeScript. Every function becomes a REST endpoint.

• Reasoners & Skills - @app.reasoner() for AI judgment, @app.skill() for deterministic code
• Structured AI - app.ai(schema=MyModel) → typed Pydantic/Zod output from any LLM
• Harness - app.harness("Fix the bug") dispatches multi-turn tasks to Claude Code, Codex, Gemini CLI, or OpenCode
• Cross-Agent Calls - app.call("other-agent.func") routes through the control plane with full tracing
• Discovery - app.discover(tags=["ml*"]) finds agents and capabilities across the mesh. tools="discover" lets LLMs auto-invoke them.
• Memory - app.memory.set() / .get() / .search() - KV + vector search, four scopes, no Redis needed

Run - Production infrastructure for non-deterministic AI.

• Async Execution - Fire-and-forget with webhooks, SSE streaming, retries. No timeout limits - agents run for hours or days.
• Human-in-the-Loop - app.pause() suspends execution for human approval. Crash-safe, durable, audited.
• Canary Deployments - Traffic weight routing, A/B testing, blue-green deploys. Roll out agent versions at 5% → 50% → 100%.
• Observability - Automatic workflow DAGs, Prometheus /metrics, structured logs, execution timeline.

Govern - IAM for AI agents. Identity, access control, and audit trails - built in.

• Cryptographic Identity - Every agent gets a W3C DID (decentralized identifier) - not a shared API key. Agents authenticate to each other the way services authenticate with mTLS, but with cryptographic signatures that travel with the agent.
• Verifiable Credentials - Tamper-proof receipt for every execution. Offline-verifiable: af vc verify audit.json.
• Policy Enforcement - Tag-based policy gates with cryptographic verification. "Only agents tagged 'finance' can call this" - enforced by infrastructure, not prompts.

See the full production-ready feature set →

Built With AgentField

Autonomous Engineering Team One API call spins up PM, architect, coders, QA, reviewers - hundreds of coordinated agents that plan, build, test, and ship. View project →	Deep Research Engine Recursive research backend. Spawns parallel agents, evaluates quality, generates deeper agents, and recurses -10,000+ agents per query. View project →
Reactive MongoDB Intelligence Atlas Triggers + agent reasoning. Documents arrive raw and leave enriched - risk scores, pattern detection, evidence chains. View project →	Autonomous Security Audit 250 coordinated agents trace every vulnerability source-to-sink and adversarially verify each finding. Confirmed exploits, not pattern flags. View project →
CloudSecurity AF AI-native cloud infrastructure security scanner that performs shift-left attack path analysis directly from IaC, prioritizing the most dangerous risk chains before deployment. View project →

See all examples →

Built something with AgentField? Submit your project to be featured on the examples page.

See It In Action

_{Real-time workflow DAGs · Execution traces · Agent fleet management · Audit trails}

Architecture

The control plane is a stateless Go service. Agents connect from anywhere - your laptop, Docker, Kubernetes. They register capabilities, the control plane routes calls between them, tracks execution as DAGs, and enforces policies. Full architecture docs →

Is AgentField for you?

Yes if you’re building beyond chatbots or small multi-agent workflows. If your agents are making decisions inside backend systems like approving refunds, processing claims, coordinating research, or running code, and you need routing, async execution, tracing, and audit trails.

Not yet if you’re still in the chatbot or early workflow stage, tools like LangChain or CrewAI are a great fit to explore and iterate. When you start pushing toward larger, production-grade agent systems, that’s where we come in.

Learn More

• The AI Backend - Our thesis on why every backend needs a reasoning layer
• IAM for AI Backends - Why agents need identity, not API keys
• vs Agent Frameworks - How AgentField compares to LangChain, CrewAI, and workflow engines
• Full Documentation

Community

License

Apache 2.0