AgentOven

Architecture

AgentOven's four-layer stack — independently deployable and horizontally scalable.

AgentOven is designed as a four-layer stack. Each layer is independently deployable and horizontally scalable.

Layer 1 — CLI & SDKs

The developer-facing interface. The Rust CLI manages kitchens, agents, and recipes from the terminal. Python, TypeScript, and Rust SDKs provide programmatic access with idiomatic APIs, async support, and built-in retry logic.

Technologies: Rust CLI (clap + tokio), Python SDK (httpx + pydantic), TypeScript SDK (fetch + zod), Rust SDK (reqwest + serde)

Layer 2 — Control Plane

The brain of AgentOven. A Go service that hosts the agent registry, recipe workflow engine, task router, authentication, and RBAC. It exposes a REST + gRPC API consumed by the CLI and SDKs.

Technologies: Go (Chi + pgx), Agent Registry, Recipe Engine (DAG executor), Task Router, Auth (JWT + RBAC)

Layer 3 — Protocol Layer

Standards-based communication. A2A (Agent-to-Agent) enables inter-agent discovery and task delegation. MCP (Model Context Protocol) provides tool integration, letting agents call external APIs and services.

Technologies: A2A Protocol (JSON-RPC 2.0), Agent Cards (/.well-known/agent.json), MCP Tool Server, SSE Streaming

Layer 4 — Infrastructure

The backing services that power the control plane. PostgreSQL for persistent state, Redis for caching and pub/sub, and an OpenTelemetry Collector for traces, metrics, and logs.

Technologies: PostgreSQL (state + registry), Redis (cache + pub/sub), OpenTelemetry Collector, Prometheus + Grafana

Data Flow

When a task is sent to an agent, it follows this path:

  1. Client sends task via SDK / CLI / HTTP
  2. Control Plane authenticates, routes to correct agent
  3. A2A Protocol delivers the task as a JSON-RPC message
  4. Agent processes the task (possibly calling MCP tools)
  5. Response streams back via SSE or returns as JSON
  6. Traces and metrics are emitted to OpenTelemetry Collector
Design Principles

Framework Agnostic — The control plane doesn't care what framework your agent uses. It manages lifecycle, not inference.

Protocol First — A2A and MCP are first-class citizens, not afterthoughts. Every agent is discoverable and composable.

Observable by Default — Every request is traced. Every agent emits metrics. Structured logs flow through the OTel pipeline.

Horizontally Scalable — Stateless control plane, connection-pooled database, Redis pub/sub — scale each layer independently.