Autogent //Agent Runtime Systems

Production-grade runtimes
for the agent era.

The systems substrate that takes an agent program and executes it reliably, efficiently, and safely on real hardware over real time. Lab notes, products, and on-prem delivery — under one roof.

Explore the lab Talk to the lab

Layers: 08
Live products: 03
Users / mo: 240k

autogent.runtime·control-plane · region: prod-eu-1

build 0.1.0+8f4b·uptime 14d 02h

LIVE

RUNS / s▲ +4.1%

312

p99 LLM▼ −6.3%

1.84s

KV HIT▲ +0.2%

87.3%

L1Execution ModelAn agent program becomes a runnable unit — process, graph, or actor.L2Scheduling & DispatchToken-aware schedulers co-batch model calls and tool calls under SLOs.47 q · 312/s L3Memory & StateKV cache, scratchpad, and working memory as paged, evictable, shareable resources.L4Execution EnvironmentsMicroVM and container sandboxes isolate generated code, browsers, and shells.2 sandbox · ok L5Tools & CapabilitiesMCP-style tool surfaces with capability-scoped access — no ambient authority.12 caps · 3 deny L6Communication & CoordinationAgents talk to agents over A2A, ACP, ANP — typed, traceable, governable.agent_α ↔ β L7Durability & RecoveryCrash-safe resume, idempotent tool calls, durable execution across restarts.ckpt 8f4b · 1.2s L8Observability & EvaluationTrace, replay, evaluate, and account for every step in production.

What we do // three pillars

A research lab.A product studio.A delivery partner.

Autogent ships agent infrastructure across three surfaces — and the same systems thinking flows through all of them.

01 The Lab

Lab.

We study the systems substrate underneath modern agents — schedulers, KV caches, sandboxes, durable execution, observability — and turn it into practical field guides.

8-layer taxonomyliving articleopen access

02 Consumer

Products.

We don't just write about agent runtimes — we ship them. Three live C-end products with paying users, high-traffic backends, and conversion rates that pay for the runtime work itself.

3 products live240k MAU4.7% conversion

03 On-Prem

Delivery.

Workshop → consulting → POC → production. We bring agent-grade reliability into your stack, on your hardware, with your data, on your timeline.

air-gappedBYO modelstraining included

The Stack // L1 — L8

Eight layers between an agent program and the real world.

Scroll the stack. Each layer is the systems substrate underneath modern agents — the same taxonomy used in our field guide, rendered as the production tools you'd actually use to operate it.

agent.run·run_a8c4f203 · v0.1.0

STEP 03/12

agent.ts

import { agent, plan, call, observe } from "@autogent/runtime";

export const guide = agent("runtime_assistant", {
  steps: [
    plan(({ topic }) => prompt`outline a field guide to ${topic}`),
    call.tool("mcp.search.web", { topK: 8 }),
    observe(({ hits }) => evaluate(hits, { rubric: "coverage" })),
  ],
  retries: { maxAttempts: 3, idempotent: true },
});

Execution graphlive

retries: 3 · idempotent
mode: graph
trace_id: 9f…b1

01 / 08L1 Execution Model

L1 L2 L3 L4 L5 L6 L7 L8

agent.run·run_a8c4f203 · v0.1.0
STEP 03/12
agent.ts
import { agent, plan, call, observe } from "@autogent/runtime"; export const guide = agent("runtime_assistant", { steps: [ plan(({ topic }) => prompt`outline a field guide to ${topic}`), call.tool("mcp.search.web", { topK: 8 }), observe(({ hits }) => evaluate(hits, { rubric: "coverage" })), ], retries: { maxAttempts: 3, idempotent: true }, });
Execution graphlive
retries
3 · idempotent
mode
graph
trace_id
9f…b1
●step.complete · plan142ms · ok
L1Execution Model
An agent program becomes a runnable unit — process, graph, or actor.
How the runtime represents an agent: as a process, a graph, or an actor. Defines the smallest unit of scheduling and recovery.
autogent.scheduler·continuous-batch · prod-eu-1
312 / s
QUEUE▲ +12
47
DISPATCH/s▲ +4.1%
312
p99 LATENCY▼ −6.3%
1.84s
jobkinddetailtokenswait
job_3a1fmodelgpt-4o · prompt+plan4121.84s
job_3a20toolmcp.bash · grep—12ms
job_3a21modelclaude-3.5 · review21884ms
job_3a22subagentruntime_assistant.sub_2—146ms
job_3a23toolmcp.fs.read · /workspace/**—188ms
quanta 18ms · slo p99 1.9stokens 1.42k/s
L2Scheduling & Dispatch
Token-aware schedulers co-batch model calls and tool calls under SLOs.
Continuous batching, priority queues, and SLO-aware dispatch across LLM and tool work.
autogent.kv-cache·paged · 4096 pages
HOT 87.3%
KV-cache pages · 16 × 8 gridcold ◐ hot
page_03f1 evictingdisk
HIT▲ +0.2%
87.3%
MISS▼ −0.2%
12.7%
EVICT/s— 0%
1.4
policy
LRU + prefix-share
shared between agent.run · run_a8c4 + sub_2
page_size 16 toklast_evict 12:04:04.110Z page_03f1 → disk
L3Memory & State
KV cache, scratchpad, and working memory as paged, evictable, shareable resources.
First-class treatment of agent state: KV caches, episodic memory, and shared scratchpads.
firecracker·sandbox-7e2d · microVM
ISOLATED
[KERN]init guest · cpu=2 mem=512M kernel=lkvm-5.15
[KERN]drives ro=workspace.img rw=overlay.img
[KERN]net tap0 · cidr=10.42.0.0/24 · egress=deny
sandbox-7e2d ready · 412ms

user@autogent:~$ ls /workspace
research/ notes/ agent.ts

$
EPERMoperation not permitted
capability: fs.write denied by policy v0.3
hostmicroVMprocess
caps: fs.read /workspace/** · http: api.weather.compolicy v0.3
L4Execution Environments
MicroVM and container sandboxes isolate generated code, browsers, and shells.
Strong isolation for code, browser, and shell tools via Firecracker, gVisor, and friends.
capability-broker·mcp · policy v0.3
3 DENY · 12 ALLOW
capability manifest
1{
2 "agent": "runtime_assistant",
3 "capabilities": {
4 "fs.read": [allow
5 "/workspace/**",
6 "/notes/**"
7 ],
8 "fs.write": [scoped
9 "/workspace/out/**"
10 ],
11 "http": {
12 "allow": [allow
13 "api.weather.com",
14 "*.openai.com"
15 ]
16 },
17 "shell": false,deny
18 "secrets": [
19 "OPENAI_API_KEY"
20 ]
21 },
22 "policy": "v0.3"
23}
tool calls · last 60s5 / 142
12:04:03.918Zmcp.http.get api.weather.com → 200 · 84ms
12:04:04.001Zmcp.fs.read /workspace/notes.md → 4.2KB · 12ms
12:04:04.110Zmcp.fs.read /etc/passwd → DENIED
12:04:04.244Zmcp.search.web "agent runtime" → 8 hits · 312ms
12:04:04.398Zpolicy.warn rate(http) 47/min approaching cap 60/min
broker latency p95 1.4msdeny rate 4.2%
L5Tools & Capabilities
MCP-style tool surfaces with capability-scoped access — no ambient authority.
Typed tools, capability manifests, and policy-based brokering between agents and the world.
autogent.bus·A2A · v0.3 · TLS
α ↔ β
agent_alphaorchestrator
01plan
02delegate
03wait
agent_betasummarizer
01recv
02summarize
03ack
A2A frame · in flight
1{
2 "from": "agent_alpha",
3 "to": "agent_beta",
4 "type": "task.delegate",
5 "trace_id": "9f…b1",
6 "payload": {
7 "task": "summarize_guide",
8 "args": {
9 "url": "/lab"
10 },
11 "deadline_ms": 12000
12 }
13}
codec protobufauth mTLSttl 12s
frames/s 18.4 · p99 4.1mstrace_id 9f…b1 · seq 42
L6Communication & Coordination
Agents talk to agents over A2A, ACP, ANP — typed, traceable, governable.
Wire protocols and patterns for multi-agent coordination across processes and organisations.
autogent.workflow·durable · run_a8c4f203
RESUMED
run timelinenow: step.43
step.40plan142ms
ckpt_8f3acheckpoint12ms
step.41tool.bash218ms
host kill
ckpt_8f4bresume from
step.42tool.fs.read84ms
step.43llm.completion1840ms
resumed from ckpt_8f4b
replay 1.2s · idempotent ✓
RECOVERY▼ −18%
1.2s
JOURNAL—
142KB
ATTEMPTS— ok
2 / 3
guarantees
idempotentexactly-once
journal page 12 · sha 8f4b…2creplay deterministic
L7Durability & Recovery
Crash-safe resume, idempotent tool calls, durable execution across restarts.
Workflow engines, deterministic replay, idempotency keys — the agent survives the machine.
autogent.trace·otel · run_a8c4f203 · trace 9f…b1
2.14s
flamegraphhighlighted: llm.completion
0ms
546ms
1091ms
1637ms
2183ms
agent.run
2140ms
plan
142ms
llm.completion
1840ms
tool.bash
21ms
mcp.fs.read
60ms
trace.flush
60ms
llm.completion
1.84s412 tok$0.0042eval 0.91
p99 (60r)▼ −6.3%
1.84s
EVAL▲ +0.04
0.91
latency · last 60 runs
min 1.83median 1.86max 1.97
spans 6 · sampling 100% · cost $0.0042eval gpt-4o judge 0.91
L8Observability & Evaluation
Trace, replay, evaluate, and account for every step in production.
OpenTelemetry-grade traces, evaluations, and cost accounting wired through the whole stack.

The Lab // flagship field guide

A systems field guide to
agent runtime infrastructure.

Field guideLiving article·2025-11·Autogent Lab

Agent Runtime Systems: A Field Guide

Autogent

LLM-driven agents are increasingly deployed as long-running, tool-using, multi-step programs rather than one-shot model calls. This shift has produced a flurry of new infrastructure — token-aware schedulers, paged key–value caches, hierarchical memory managers, microVM sandboxes, tool protocols, durable execution engines, and standardized telemetry — but the field is often described through application-facing frameworks (LangGraph, AutoGen, CrewAI) or narrow component writeups. This guide frames those components as layers of an agent runtime system: a systems substrate, analogous to a classical operating system plus a distributed runtime, that takes an agent program and executes it reliably, efficiently, and safely on real hardware over real time.

Explore the labliving article · 8 layers

LLM agentsagent runtimeoperating systemsdistributed systemsschedulingKV cache

Solutions // products & on-prem

Two shapes of delivery. One systems backbone.

Whether you're shipping a consumer agent or rolling out an enterprise runtime, the same eight-layer thinking flows through every engagement.

From our portfoliolive · paying users

We don't just consult. We ship our own consumer agents.

Three production C-end agentic products, hundreds of thousands of monthly users, and the conversion numbers to prove the runtime work pays for itself. Every reliability primitive on this page comes from systems we operate ourselves.

01
Three products in production
We operate our own consumer agent products — paying users, real revenue, real on-call rotations. The runtime work on this page is the work that keeps them up.
02
High-volume traffic, calm graphs
12M+ sessions per month, p99 LLM latency under 1.9s, KV-cache hit rate above 87%. The dashboards on this page are not mockups of someone else's stack.
03
Conversion you can put on a board
4.7% paid conversion across the portfolio, with retention curves that flatten — because the agent actually finishes the task, not just talks about it.
04
Human-in-the-loop, by design
Pauses, approvals, and steering as first-class primitives in every product we ship. It is the reason customers trust the agent with the long tasks.
05
Methodology, not magic
Every harness, prompt strategy, and eval pipeline is encoded from systems we run ourselves — and is what we transfer to enterprise partners on day one.

autogent.guide·prod · session_4f2c · paying

LIVE

Summarize the L4 sandbox section of the field guide for me, focused on microVMs vs gVisor.

◆

runtime_assistantstep 02 / 04

Pulling section L4 from the guide · examining isolation tradeoffs between Firecracker microVMs and gVisor user-space kernels...

mcp.fs.read·12msmcp.search.web·312msllm.completion·1.84s

approvalrequest: read /workspace/private/notes.md · scope: this session only

PRODUCTS LIVE▲ +1 ytd

MAU▲ +38%

240k

SESSIONS / MO▲ +24%

12.4M

CONVERSION▲ +1.2pt

4.7%

// 30-day rolling · across the autogent portfolio · q1 2026

For enterpriseson-prem

From workshop to production, on your hardware.

A four-phase delivery model designed for regulated and air-gapped environments. We bring our methodology, leave behind a runtime your team owns.

Book a workshop

01
Workshop
Hands-on agent-training intensive for your engineers. We map your domain to the 8-layer taxonomy and leave with a working POC scope.
2 days
02
Consulting
Architecture and procurement support: runtime selection, model strategy, isolation model, governance plan.
4 – 8 weeks
03
POC
We build a thin slice end-to-end on your stack — sandboxed, observable, evaluated against your acceptance criteria.
6 – 10 weeks
04
Delivery
Production rollout on-prem or in your cloud, with knowledge transfer, runbooks, and a 90-day operator on-call.
12+ weeks

How we work // operating principles

Built for teams that need agents to finish the job.

Before public case studies and social channels are live, the strongest signal is how we work: clear systems boundaries, production proof, and ownership transfer.

Production before polish

We test runtime ideas inside systems with real users, traffic, failures, and support pressure before packaging them for partners.

Boundaries over buzzwords

We name where the runtime ends, where the workflow engine begins, and what has to be observable, recoverable, and governed.

Transfer, not dependency

Engagements leave behind runbooks, architecture decisions, eval harnesses, and a runtime your team can operate without us.

BYO-cloudair-gapped deliveryoperator training

Autogent Lab // notes

From the lab.

Field notes, design notes, and reference architectures from the people building agent runtimes for production.

The lab notebook is organized by runtime track.

Explore the lab →

Autogent // Talk to the lab

Bring agent-grade reliability to your stack.

We work with a small number of teams each quarter — lab collaborations, product partnerships, and on-prem deliveries. Workshop slots open every six weeks.

Book a workshop Explore the lab

Workshops / yr: ≈ 12
POCs / yr: ≈ 8
On-prem deliveries: select
Office: Abu Dhabi

Autogentlab.com // Abu Dhabi · Globalautogent.runtime · v0.1.0 · 2026

Production-grade runtimes
for the agent era.

A research lab.A product studio.A delivery partner.

Lab.

Products.

Delivery.

Eight layers between an agent program and the real world.

An agent program becomes a runnable unit — process, graph, or actor.

Token-aware schedulers co-batch model calls and tool calls under SLOs.

KV cache, scratchpad, and working memory as paged, evictable, shareable resources.

MicroVM and container sandboxes isolate generated code, browsers, and shells.

MCP-style tool surfaces with capability-scoped access — no ambient authority.

Agents talk to agents over A2A, ACP, ANP — typed, traceable, governable.

Crash-safe resume, idempotent tool calls, durable execution across restarts.

Trace, replay, evaluate, and account for every step in production.

A systems field guide to
agent runtime infrastructure.

Agent Runtime Systems: A Field Guide

Two shapes of delivery. One systems backbone.

We don't just consult. We ship our own consumer agents.

From workshop to production, on your hardware.

Workshop

Consulting

POC

Delivery

Built for teams that need agents to finish the job.

Production before polish

Boundaries over buzzwords

Transfer, not dependency

From the lab.

KV cache as a first-class distributed resource

Agent runtime vs. workflow engine: a clarifying boundary

MicroVM sandboxes for tool use, in three diagrams

Bring agent-grade reliability to your stack.

Production-grade runtimesfor the agent era.

Lab.

Products.

Delivery.

An agent program becomes a runnable unit — process, graph, or actor.

Token-aware schedulers co-batch model calls and tool calls under SLOs.

KV cache, scratchpad, and working memory as paged, evictable, shareable resources.

MicroVM and container sandboxes isolate generated code, browsers, and shells.

MCP-style tool surfaces with capability-scoped access — no ambient authority.

Agents talk to agents over A2A, ACP, ANP — typed, traceable, governable.

Crash-safe resume, idempotent tool calls, durable execution across restarts.

Trace, replay, evaluate, and account for every step in production.

Agent Runtime Systems: A Field Guide

We don't just consult. We ship our own consumer agents.

From workshop to production, on your hardware.

Workshop

Consulting

POC

Delivery

Production before polish

Boundaries over buzzwords

Transfer, not dependency

KV cache as a first-class distributed resource

Agent runtime vs. workflow engine: a clarifying boundary

MicroVM sandboxes for tool use, in three diagrams

Bring agent-grade reliability to your stack.

Production-grade runtimes
for the agent era.