The agent stack, explained.

An agent harness is everything that wraps a model call to turn it into a working agent: rendering the prompt, executing tool calls, handling retries and timeouts, and recording what happened.

The AgentOven Executor runs managed agents. It renders the prompt template, calls the Model Router, executes tool calls through the MCP Gateway and emits an OpenTelemetry span for each step. Agents already built in LangGraph, LangChain or CrewAI run in framework-native runtimes (local, Docker or Kubernetes), and external agents are proxied over A2A.

The agent loop is the cycle an agent repeats: call the model, run the tools it asks for, feed the results back, and continue until it has an answer or hits a limit.

Agents with agentic behavior run this loop in the Executor until the model returns a final answer or max_turns is reached (10 by default, configurable per agent). Recipe steps can loop as well, with a loop condition and a maximum number of iterations.

Context engineering is choosing what goes into the model's context window on every turn (instructions, history, retrieved knowledge and tool results) so the agent stays accurate without overflowing or overspending.

Each agent has a context budget (16,000 tokens by default). A sliding window keeps recent turns, summarises older ones and sets prompt-cache breakpoints, and a budget report shows where tokens go. Prompts are versioned in the Prompt Store. The enterprise edition adds session compaction with a threshold and auto-compact.

Agent memory is how an agent keeps state beyond a single request: the conversation so far (short-term) and durable facts and past episodes (long-term).

Sessions keep multi-turn conversation state for each agent. The enterprise edition backs sessions with Redis for speed and PostgreSQL for durability. Long-term memory layers for facts, episodes and knowledge are in development.

Tool calling lets a model act by invoking functions and APIs. The Model Context Protocol (MCP) is the open standard for exposing those tools to agents.

Register HTTP or SSE tools once per kitchen. The MCP Gateway exposes them over JSON-RPC (tools/list and tools/call), injects credentials so agents never hold secrets, and records every call in the trace.

Multi-agent orchestration coordinates several specialised agents on one task: who runs when, what runs in parallel, and how results are combined.

Recipes are DAG workflows. Steps can be agents, conditions, routers, fan-out and fan-in, map, sub-recipes, RAG retrieval and human gates, with retries and timeouts per step. Agents hand work to each other over A2A through the control plane's A2A gateway, whichever framework they were built in.

Human-in-the-loop means a person reviews or approves an agent's action before it takes effect, typically for high-risk or irreversible steps.

Add a human gate step to any recipe and the run pauses until someone approves or rejects it through the API or dashboard. The enterprise edition also requires approval to promote an agent version to a new environment.

Guardrails are checks that run on an agent's inputs and outputs to catch sensitive data, prompt injection and off-policy content before it causes harm.

Built-in guardrails cover PII detection, prompt injection, content filtering, topic restriction, regex rules, maximum length and LlamaGuard 3, and you can add your own. The enterprise edition sets default guardrails for a whole workspace.

Evals measure whether an agent behaves correctly on a known set of cases, so a prompt, model or tool change can be checked before it ships.

Test suites run a set of inputs against an agent on demand or on a schedule, and results are kept with each run. LLM-judge scoring is on the roadmap.

An RL environment for agents is a simulated setting where an agent can act, be scored and be improved, without touching real customers or systems.

Describe your domain as a typed world schema, then build scenarios with simulated users, injected tool faults and facts that stay hidden until the agent asks. Each episode is graded only on the world state the agent changed and produces a reward you can compare across agent configurations. Available in early access; automated optimisation is on the roadmap.

Model routing chooses which model and provider serves each request, trading off quality, cost, latency and availability.

The Model Router picks a provider by strategy (fallback, cost-optimized, latency-optimized or round-robin), fails over on errors and rate limits, rotates API keys and tracks cost per agent and per kitchen.

Agent observability is being able to see every model call, tool call and handoff an agent made, with timing and cost, to debug and audit it.

Traces and metrics export over OpenTelemetry (OTLP) to Grafana, Datadog, Jaeger or any compatible backend, and every response carries a trace ID. The enterprise edition adds an immutable audit trail and a traceability matrix.

Declarative agents are defined in version-controlled files, so changes are reviewed and deployed like any other code.

agentoven apply takes YAML, JSON or TOML manifests for agents, tool sets and recipes. The enterprise edition imports an AGENTS.md file directly into registered agents.

Background agents run without a user waiting on them, on a schedule or in response to events.

A standalone scheduler dispatches recipes and test suites on cron schedules, or hands them to Apache Airflow.