When AI moves from chatbots into backends, making decisions, not just answering questions, it needs infrastructure, not frameworks.
Docs | Quick Start | Python SDK | Go SDK | TypeScript SDK | REST API
AgentField is the backend infrastructure layer for autonomous AI.
AI has outgrown frameworks and is moving from chatbots into backends—making decisions about refunds, coordinating supply chains, managing portfolios. These agents need infrastructure, not prompt wrappers.
AgentField is an open-source control plane that treats AI agents as first-class backend services and makes agents production-ready.
Scale Infrastructure (think: Kubernetes)
- Routing & Discovery: Agents find and call each other through standard REST APIs
- Async Execution: Fire-and-forget tasks that run for minutes, hours, or days
- Durable State: Built-in memory with vector search—no Redis or Pinecone required
- Observability: Automatic workflow DAGs, Prometheus metrics, structured logs
Trust Infrastructure (think: Okta, rebuilt for agents)
- W3C DIDs: Every agent gets a cryptographic identity—not a shared API key
- Verifiable Credentials: Tamper-proof audit trails for every action
- Policy Enforcement: Boundaries enforced by infrastructure, not prompts
Write Python, Go, TypeScript, or call via REST. Get production infrastructure automatically.
Software keeps adding layers when complexity demands it. Frontend/backend separation. Data lakes and pipelines. Now: a reasoning layer that sits alongside your services, making decisions that used to be hardcoded.
We call this the AI Backend. Not a chatbot, not a copilot—infrastructure for software that can think.
Guided autonomy: Agents that reason freely within boundaries you define. Predictable enough to trust. Flexible enough to be useful.
📖 Read: The AI Backend — Our thesis on why every serious backend will need a reasoning layer.
Real-time Observability • Execution Flow • Audit Trails
Python
from agentfield import Agent, AIConfig
app = Agent(node_id="researcher", ai_config=AIConfig(model="gpt-4o"))
@app.skill()
def fetch_url(url: str) -> str:
return requests.get(url).text
@app.reasoner()
async def summarize(url: str) -> dict:
content = fetch_url(url)
return await app.ai(f"Summarize: {content}")
app.run() # → POST /api/v1/execute/researcher.summarizeGo
agent, _ := agentfieldagent.New(agentfieldagent.Config{
NodeID: "researcher",
AgentFieldURL: "http://localhost:8080",
})
agent.RegisterSkill("summarize", func(ctx context.Context, input map[string]any) (any, error) {
url := input["url"].(string)
// Your agent logic here
return map[string]any{"summary": "..."}, nil
})
agent.Run(context.Background())TypeScript
import { Agent } from '@agentfield/sdk';
const agent = new Agent({
nodeId: 'researcher',
agentFieldUrl: 'http://localhost:8080',
});
agent.reasoner('summarize', async (ctx, input: { url: string }) => {
const content = await fetch(input.url).then(r => r.text());
return await ctx.ai(`Summarize: ${content}`);
});
agent.run(); // → POST /api/v1/execute/researcher.summarizeREST / Any Language
# Call any agent from anywhere—no SDK required
curl -X POST http://localhost:8080/api/v1/execute/researcher.summarize \
-H "Content-Type: application/json" \
-d '{"input": {"url": "https://example.com"}}'// Frontend (React, Next.js, etc.)
const result = await fetch("http://localhost:8080/api/v1/execute/researcher.summarize", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ input: { url: "https://example.com" } }),
}).then(r => r.json());curl -fsSL https://agentfield.ai/install.sh | bashaf init my-agent --defaults
cd my-agent && pip install -r requirements.txtAgentField uses a control plane + agent node architecture. You'll need two terminal windows:
Terminal 1 – Start the Control Plane:
af serverOpens the dashboard at http://localhost:8080
Terminal 2 – Start Your Agent:
python main.pyAgent auto-registers with the control plane
curl -X POST http://localhost:8080/api/v1/execute/my-agent.demo_echo \
-H "Content-Type: application/json" \
-d '{"input": {"message": "Hello!"}}'Other Languages / Options
Go:
af init my-agent --defaults --language go
cd my-agent && go mod download
go run .TypeScript:
af init my-agent --defaults --language typescript
cd my-agent && npm install
npm run devInteractive mode (choose language, set author info):
af init my-agent # No --defaults flagDocker / Troubleshooting
If running the control plane in Docker and your agent node runs outside that container, make sure the control plane can reach the agent at the URL it registers.
Option A (agent on your host, control plane in Docker):
docker run -p 8080:8080 ghcr.io/agent-field/agentfield-control-plane:latest
# Python agents (recommended)
export AGENTFIELD_URL="http://localhost:8080"
export AGENT_CALLBACK_URL="http://host.docker.internal:8001"
python main.py
# Go agents
export AGENTFIELD_URL="http://localhost:8080"
export AGENT_PUBLIC_URL="http://host.docker.internal:8001"Option B (agent + control plane both in Docker Compose / same network):
- Set the agent callback/public URL to the agent container's service name, e.g.
http://my-agent:8001.
Linux note: host.docker.internal may require --add-host=host.docker.internal:host-gateway or using a Compose setup where both containers share a network.
Next Steps: Build Your First Agent | Deploy to Production | Examples
Most frameworks stop at "make the LLM call." But production agents need:
See the production-ready feature set →
Agents that run for hours or days. Webhooks with automatic retries. Backpressure handling when downstream services are slow.
# Fire-and-forget: webhook called when done
result = await app.call(
"research_agent.deep_dive",
input={"topic": "quantum computing"},
async_config=AsyncConfig(
webhook_url="https://myapp.com/webhook",
timeout_hours=6
)
)Agents that discover and invoke each other through the control plane. Every call tracked. Every workflow visualized as a DAG.
# Agent A calls Agent B—routed through control plane, fully traced
analysis = await app.call("analyst.evaluate", input={"data": dataset})
report = await app.call("writer.summarize", input={"analysis": analysis})Standard REST APIs. No magic abstractions. Build agents the way you build microservices.
# Every agent is an API endpoint
curl -X POST http://localhost:8080/api/v1/execute/researcher.summarize \
-H "Content-Type: application/json" \
-d '{"input": {"url": "https://example.com"}}'Cryptographic identity for every agent. Tamper-proof audit trails for every action. Learn more about Identity & Trust.
AgentField isn't a framework you extend. It's infrastructure you deploy on.
See how AgentField compares to agent frameworks →
| Agent Frameworks | DAG/Workflow Engines | AgentField | |
|---|---|---|---|
| Architecture | Monolithic scripts | Predetermined pipelines | Distributed microservices |
| Execution | Synchronous, blocking | Scheduled, batch | Async-native (webhooks, SSE, WebSocket) |
| Coordination | Manual message passing | Central scheduler | Service mesh with discovery |
| Memory | External (Redis, Pinecone) | External | Built-in + vector search |
| Multi-language | SDK-locked | Config files | Native REST APIs (any language) |
| Long-running | Timeouts, hacks | Designed for batch | Hours/days, durable execution |
| Audit | Logs (trust me) | Logs | Cryptographic proofs (W3C DIDs/VCs) |
Not a DAG builder. Agents decide what to do next—dynamically. The control plane tracks the execution graph automatically.
Not tool attachment. You don't just give an LLM a bag of MCP tools and hope. You define Reasoners (AI logic) and Skills (deterministic code) with explicit boundaries. Learn more.
- Control Plane: Stateless Go service that routes, tracks, and orchestrates
- Async by Default: Fire-and-forget or wait. Webhooks with retries. SSE streaming.
- Long-Running: Tasks that run for hours or days with durable checkpointing
- Backpressure: Built-in queuing and circuit breakers
- Discovery: Agents register capabilities. Others find them via API.
- Cross-Agent Calls:
app.call("other.reasoner", input={...})routed through control plane - Workflow DAGs: Every execution path visualized automatically
- Shared Memory: Scoped to global, agent, session, or run—with vector search
- W3C DIDs: Every agent gets a cryptographic identity
- Verifiable Credentials: Tamper-proof receipts for every action
- Prometheus Metrics:
/metricsendpoint out of the box - Policy Enforcement: "Only agents signed by 'Finance' can access this tool"
Explore the full feature set →
When agents move from answering questions to making decisions, approving refunds, coordinating supply chains, moving money, "check the logs" isn't enough.
AgentField gives every agent a W3C Decentralized Identifier (DID)—a cryptographic identity. Every execution produces a Verifiable Credential: a tamper-proof receipt showing exactly what happened, who authorized it, and the full delegation chain.
# Export audit trail for any workflow
curl http://localhost:8080/api/ui/v1/workflows/{workflow_id}/vc-chainFor compliance teams: mathematical proof, not trust.
📖 Read: IAM for AI Backends — Why OAuth can't secure autonomous software, and what replaces it.
Learn more about the core architecture →
- You're building an AI backend - agents that make decisions, not just answer questions
- You're building multi-agent systems that need to coordinate
- You need production infrastructure: async, retries, observability
- You want agents as standard backend services with REST APIs
- You need audit trails for compliance or debugging
- You have multiple teams deploying agents independently
- You're building a single chatbot (prompt orchestration frameworks like LangChain, CrewAI, LlamaIndex etc.. are great for that)
- You're prototyping and don't need production concerns yet
When you're ready to ship agents to production, we'll be here.
If you are Backend Engineers shipping AI into production who want standard APIs, not magic or Platform Teams who don't want to build another homegrown orchestrator or Enterprise Teams in regulated industries (Finance, Health) needing audit trails or Frontend Developers who just want to fetch() an agent without Python headaches, AgentField is built for you.
- 📖 The AI Backend — Why every backend needs a reasoning layer
- 📖 IAM for AI Backends — Why agents need identity, not just API keys
- 📚 Documentation — Full technical reference
- 🚀 Examples — Production patterns and use cases
Agents are becoming part of production backends. They need identity, governance, and infrastructure. That's why AgentField exists.
Built by developers who got tired of duct-taping agents together.
agentfield.ai
![@github-actions[bot]](https://avatars.githubusercontent.com/in/15368?s=64&v=4){kind=small}
