The open source backend for AI agents
Write a plain function; the backend turns it into a production endpoint with queues, retries, durable state, and versioned deploys. Build agents like APIs. Ship them like software.
If you can write an API, you can write an agent.
A reasoner is a plain function in Python, TypeScript, or Go. The plane turns it into a production endpoint your services call, with queues, retries, and streaming built in. The plane itself is a single lightweight Go binary that scales horizontally.
app = Agent("risk-engine")
@app.reasoner(tags=["fintech"])
async def score_transaction(tx: dict) -> dict:
verdict = await app.ai(...)
return verdict.model_dump()The parts you stop bolting on.
No Celery, no Redis, no Temporal, no separate vector store. The backend ships with the services you would otherwise run and glue together, each one a single call:
# the decorated function is already all of this:
$ curl -X POST .../execute/support.triage
{"status": "completed", "result": ...}
$ curl -X POST .../execute/async/support.triage
{"execution_id": "ex_9d2", "status": "queued"}
# poll it, or take the HMAC-signed webhookFrom one agent to a fleet of thousands.
Nodes deploy independently; the plane routes, queues, retries, and scales. Executions stay durable for minutes or days. No timeout ceilings, no orchestration code.
Deploy agents the way you deploy software.
Canary a new version on live traffic, run two reasoners head to head, switch blue to green in one step, shift load at runtime, let unhealthy versions drop out of routing on their own, and watch every execution stream through one pane.
When security asks, you already have the answer.
Every agent carries a cryptographic identity, every cross-agent call is signed, and every execution leaves a verifiable receipt. Your POC clears review without a meeting. The full governance story lives on the enterprise page.
$ af vc verify run-8f31.json
signature ed25519 valid
chain platform → node → function intact
execution risk-engine.score_transactionWhat teams build on it.
Any system that reasons and acts, on one plane. The gold entries ship as open blueprints: complete multi-agent systems you fork and adapt instead of starting blank.
Wired into the stack you already run.
Integrations are governed surfaces, not connectors. A warehouse event, an incident, or a pull request wakes an agent; its actions flow back out under the same identity, policy, and audit.
One install, laptop to production.
From the first function to a governed fleet, this is the only piece of infrastructure you add. Everything else you already have: your services, your data, and an inference provider. Open models on your GPUs or any API, swapped in one line. Apache-2.0, yours to fork and keep.
model: qwen
The model is the interchangeable part. Every agent runs on the open model you point it at, and swapping is one line of config. No contract, no lock-in, no meter running against someone else's cloud.
Forked, extended, and run in production.
Developed in the open; forked and extended inside banks, software giants, universities, and public health institutions.
- Is it another agent framework?
- No. It is infrastructure: a stateless Go control plane your agents register with. Write the agent in Python, TypeScript or Go.
- How does anything call my agent?
- Over plain REST. Every reasoner becomes POST /api/v1/execute/<agent>.<reasoner>, so a fetch() from the frontend works without an SDK.
- What if a server dies mid-run?
- The run is durable and resumes where it stopped. Long jobs run async for hours or days and report back by webhook.
- Which models?
- Yours. Open weights, a local endpoint or a hosted API, called on your key. The plane does not care which.
- Do I need Redis or a vector database?
- No. Memory is built in, scoped to a workflow, session or user, with vector search included.
- How do I prove what an agent did?
- Every agent carries a W3C DID, and every step emits a signed Verifiable Credential you can hand to an auditor.
- How do I watch it run?
- Each run draws a live execution DAG. Prometheus metrics sit at /metrics, and the logs are structured and correlated.
- Where does it run?
- On a laptop for the POC, in Docker or on your own cluster in production. Apache-2.0, inside your network.
Join the community
Ask how others wire their agents, share what you shipped, and hear about releases first.
Join the DiscordTaking it past the POC?
Identity, audit, private deployment, and a design partnership. The enterprise page makes the case to your leadership for you.
See enterpriseShip your first agent as an API.
Install the backend, write a function, and call it over REST before lunch.