Agent as a Backend

Your agent doesn't need a backend. It is the backend.

Define capabilities, not endpoints. Agentend handles intent routing, memory hydration, model orchestration, and event streaming — so you ship agent-powered products, not infrastructure.

Intent
Classify
Memory
Workers
Events
Frontend

The Paradigm Shift

What if you didn't need any of this?

Traditional Backend

Routes & Endpoints
Controllers
Request Serializers
Auth Middleware
API Versioning
Response Formatting

Agent as a Backend

Capabilities
Workers
Memory
Events

All that complexity collapses into intent-driven capabilities.

This is all you write

No routes. No controllers. Just capabilities.

from agentend import Agentend, Capability, tool

app = Agentend()

@app.capability("invoice_processing")
class InvoiceProcessor(Capability):
    """Extract, verify, and summarize invoices."""
    workers = ["extract", "verify", "summarize"]

    def get_domain_context(self, ctx):
        return "You process business invoices. Be precise with amounts."

    @tool
    def save_invoice(self, data: dict) -> str:
        db.invoices.insert(data)
        return f"Invoice {data['id']} saved"

if __name__ == "__main__":
    app.serve()

How Agent as a Backend Works

01

User sends an intent

Natural language, not a structured API call. The agent understands what you need.

02

Kernel classifies & routes

Small model, <10ms. Picks the right Capability from the registry.

03

Context Bus hydrates memory

5 tiers, progressive loading. Only pulls what the task actually needs.

04

Workers execute, events stream

Typed workers call models. AG-UI protocol streams results in real-time.

6

Worker Slots

5

Memory Tiers

13

Event Types

18

Modules

Everything you need. Nothing you don't.

18 modules, zero boilerplate.

Fleet

6 typed worker slots with benchmark-backed model defaults

Memory

5-tier context bus with progressive hydration

Events

AG-UI protocol — 13 event types streamed via SSE

Orchestrator

DAG workflows with parallel steps and HITL interrupts

Protocols

AG-UI + MCP + A2A — the protocol triangle

Security

PALADIN 5-layer injection defense, built in

Cache

Dual-layer semantic cache — hash + vector similarity

Budgets

Per-tenant token budget enforcement with hard limits

Plugins

8 hook points, YAML manifests, pip-installable

Observability

OpenTelemetry traces + metrics on all critical paths

Persistence

SQLAlchemy 2.0 async with multi-tenant RLS

Builder

Chat-to-build: create capabilities without code

Architecture

Intent
Kernel
Memory
Workers
AG-UI
Frontend

Start building in minutes

Production-ready agent backends. Not another wrapper.

$ pip install agentend[all]
$ agentend init myapp && cd myapp && agentend serve