Agent execution infrastructure

Make every agent execution reproducible.

Ontral captures the observations that shaped an AI-agent execution into a deterministic capsule — so teams can replay failures, find the first divergence, test alternative decisions, and prevent regressions.

Your agent may be nondeterministic. Its execution history should not be.

Request early access Watch replay demo

Private preview API

import ontral
ontral.record(app="support-agent")

support-agent · productionarmed · recording

Live executionrecorded

01model.request

02retrieval.policy_v7

03tool.customer.lookup

04model.response

05tool.refund.execute

06outcome.incorrect_refund

Exact replayserved from capsule

01model.request

02retrieval.policy_v7

03tool.customer.lookup

04model.response

05tool.refund.execute

06outcome.incorrect_refund

cap_8f3a91 · 1,204 observations · root 8f21…e104read-only

provider calls

external tool calls

world mutations

illustrative replay · demo capsule

The failure problem

Logs show what was emitted. They do not reconstruct the world the agent saw.

An agent’s execution is shaped by everything it observed. Any of these can differ the next time you run it:

model outputs
tool responses
retrieval results
state
time
randomness
concurrency
external services
application code
side-effect boundaries

Traditional trace

what you have today

logs
spans
prompt
final output

You can inspect fragments. You cannot reconstruct the historical universe.

Ontral capsule

what Ontral captures

observations
ordering
state
tool activity
time
randomness
effects
exceptions

You can reconstruct the execution.

Observability and replay solve different problems. Traces tell you what your system emitted — a capsule lets you re-run the past.

Execution capsule

Capture the observations that shaped the run.

One ontral.record() captures supported observations across model, tool, network, retrieval, runtime, state, exception, and execution-ordering boundaries — sealed into one durable, verifiable capsule. Select a class to see what is recorded.

cap_8f3a91root 8f21…e104 · content-addressed

Observation class

Retrieval

Retrieved documents and their exact versions at execution time — preserved even after the index, the store, or the document changes.

content-addressed blobs · replay eligibility requires coverage of the run’s nondeterministic boundaries

Exact replay

Reproduce the failure without repeating the damage.

Replay serves the captured observations back to the agent instead of calling live providers or external systems again. It works after the model changed, the documents changed, the database changed — or the provider is gone.

provider calls

external tool calls

world mutations

The original execution was nondeterministic. The captured capsule is deterministic.

ontral · replay — demo capsule

$ ontral replay cap_8f3a91 --attest

capsule restored       1,204 events
provider calls         0
external tool calls    0
world mutations        0
replay status          identical
attestation            verified

Execution debugger

Find the first meaningful divergence.

Replay a capsule against current code, prompts, or models. Ontral walks both executions together and stops at the first observation where they disagree. Select a node to inspect it.

Execution debugger · illustrativecap_8f3a91 ↔ current @ HEAD

nodehistorical · cap_8f3a91current · HEAD

Selected node

policy.retrieve

boundary: retrieval
source: doc v7
replay: doc v8
class: first divergence

The retrieval boundary returned document v8 where the capsule recorded v7. Every later difference is downstream of this observation.

first divergence · policy.retrieve · v7 → v8

Counterfactual replay

Change one observation. Replay the alternate history.

From an existing production capsule, replace a single observation and replay the downstream execution. The live tail stays dry-run: no emails, no charges, no mutations.

Replace

policy_v7 → policy_v8

Replay from

node 09

Keep fixed

code
customer state
previous tool responses
captured model observations

Original · recorded

09 · retrieval.policy — v7

10 · model.response — decision: refund

11 · tool.refund.execute — $4,000.00

outcome.incorrect_refund

Counterfactual · dry-run

09 · retrieval.policy — swap v7 → v8

10 · model.response — decision: escalate

11 · tool.escalate.create — dry-run · no live ticket

outcome.human_escalation

verified · zero side effects

What happened?

exact replay

What caused it?

divergence analysis

Would the correction work?

counterfactual replay

Could it regress?

corpus testing

Regression testing

Turn production failures into permanent tests.

Promote important production capsules into a regression corpus. Ontral re-executes the corpus and fails the build when behavior changes in ways you forbid — before the change ships.

Gate changes to

code
prompts
models
tool schemas
retrieval
policies
MCP servers

Test cases come from executions that actually happened — not scenarios engineers invented.

PR #482 · upgrade retrieval pipeline

illustrative CI report · replay gate

412 capsules replayed

identical398

semantically equivalent10

changed3

unsafe effect attempted1

Build failedforbidden change class detected

cap_2c11d8 · tool.refund.execute attempted during replay — effect blocked, build rejected

Drift monitoring

Know when the same agent starts behaving differently.

Ontral replays a pinned historical corpus on a schedule and alerts when outcomes or important intermediate decisions flip — not when a benchmark score moves.

Compare a pinned corpus against

model updates
model aliases over time
prompt changes
code changes
retrieval changes
tool changes

Status · design-partner capability, shaped with early teams

Behavioral drift detecteddesign-partner capability

corpus: refund-escalation · 64 capsules
previous: safe escalation
current: autonomous refund
first divergence: model.response · node 142
trigger: model alias updated upstream

alert → escalation policy reviewoutcome flip

Replay fidelity

Exactness is proven, not assumed.

When an agent touches an uninstrumented source of nondeterminism — a raw socket, a native extension, an unsupported client — replay fails closed and reports the exact uncovered boundary.

Incomplete capture is a first-class diagnostic, not a silent success.

Replay incompletefail-closed

source        thread-3
operation     socket.connect
coverage      unsupported boundary
remediation   install the relevant interceptor
              or annotate the boundary

designed to fail closed · eligibility reported per capsule

Illustrative attestation · cap_8f3a91

original root · capture

8f21c39ab7…e104

replay root · attested

8f21c39ab7…e104

Matchtwo roots · one execution · independently verifiable

Cryptographic evidence

Every capsule is independently verifiable.

Content-addressed storage — every observation hashed into the capsule root.
Tamper detection — any modified byte changes the root.
Replay attestation — proof that a replay corresponds to a captured execution.
Export and import — verify the same capsule across environments.
Durable incident evidence — for audits, postmortems, and disputes.

This is not blockchain. It is verifiable execution evidence.

Integrations

Capture the boundaries that shape execution.

Interceptors sit at the boundaries where nondeterminism enters — providers, networks, protocols, and the runtime itself.

All execution boundaries →

OpenAIcore sdk

Requests, responses, streams, and tool calls.

Anthropiccore sdk

Messages, streaming, and tool use.

HTTPXcore sdk

Async and sync HTTP at the client boundary.

Requestscore sdk

Classic HTTP calls and their exact payloads.

MCPcore sdk

Protocol traffic to and from MCP servers.

Python timecore sdk

Clock reads served back on replay.

Python randomnesscore sdk

random, UUIDs, and sampled seeds.

Async executioncore sdk

Task and thread ordering as recorded lanes.

Custom toolscore sdk

Wrap internal tools as explicit captured boundaries.

Enterprise

Your execution data. Your deployment boundary.

The control plane is being productized with design partners. Deployment follows your data boundary, not ours.

Ontral Cloud

Hosted capsule store and replay engine.

early access

Customer VPC

Capsules never leave your network.

design partner

Self-hosted

Run the full stack on your infrastructure.

design partner

On-premise

For regulated and air-gapped environments.

design partner

Control plane · design-partner roadmap

Enterprise details →

organizations + workspaces
projects + environments
SSO + SAML
SCIM
RBAC
audit logs
encryption
retention
redaction
customer-managed keys
regional residency
customer-controlled storage

Roadmap items are built with design partners — not all are generally available today.

Use cases

Built for agents that take consequential action.

One infrastructure layer. These are workloads it serves — not separate Ontral products.

Customer support

Reproduce an incorrect refund or a contradictory answer.

Financial operations

Inspect why an invoice, approval, or payment was handled incorrectly.

Coding agents

Replay against changed code and locate the first incompatible operation.

Security operations

Investigate why an automated agent took — or skipped — an action.

Internal operations

Reconstruct decisions involving tools, retrieval, and changing company state.

Category clarity

Agent execution infrastructure. Nothing broader.

Ontral is

execution capture
exact replay
debugging
counterfactual testing
regression infrastructure
drift control
execution evidence

Ontral is not

an agent builder
a prompt-management tool
a generic observability dashboard
an agent marketplace
a model-training platform
an all-in-one governance suite

Observability and replay solve different problems. Keep your traces — add the capsule.

Make every important agent execution reproducible.

Work with Ontral to make production failures replayable, explainable, testable, and preventable.

Apply for early access Become a design partner

Read the technical overview →