Why a runtime

A successful flight
is not an airline.

A commercial aviation analogy for understanding why capable AI agents need an operation you can own.

The transition

Start with commercial aviation.

It gives us a familiar way to visualize the difference between demonstrating an agent and operating one as part of a real business. In this analogy, the model is the pilot and one agent run is one flight.

Most agent demos show that single flight.

A typical demo gives the model a destination and some tools, then lets it plan a route and complete the task. Reaching the destination counts as success.

One successful flight proves only the beginning.

An airline must operate continuously. It dispatches work, assigns resources, controls authority, monitors every flight, accounts for fuel, coordinates with people on the ground, recovers from failures, and explains what happened afterward.

The same transition happens when agents begin performing real work. One code review, research task, or support response proves that an agent is capable. Once that agent changes repositories, handles transactions, operates infrastructure, or communicates with customers every day, its execution becomes part of the business.

From analogy to engineering

A prompt describes the flight.A runtime operates
the airline.

DestinationBusiness objective

PilotModel

Aircraft and cockpitAgent implementation and tools

Flight planPrompt, workflow, or graph

ClearancePolicies and approvals

Assigned airspaceEnvironment, runner, and network

FuelTokens, context, time, and money

Flight recorderEvents and trajectories

DispatchTasks and dispatchers

Ground interventionHuman input, steering, and recovery

Incident reviewReplay and evaluation

Updated proceduresImproved runtime behavior

The category

The pilot is one part of an airline. The model is one part of a production agent operation.

That operation needs durable state, explicit authority, controlled environments, resource limits, intervention, recovery, evidence, evaluation, and improvement.

Cayu is the production runtime for operating that work.

A different kind of software

The model chooses behavior at runtime.

In conventional software, developers write the control flow and frameworks standardize repeatable plumbing. An agent receives a goal, context, capabilities, and boundaries. Then it decides what to do next.

Conventional application

The developer determines control flow.
Function inputs are bounded.
Side effects happen at known call sites.
Errors usually have known outcomes.
Tests compare inputs and outputs.

Agent operation

The model chooses the next action.
Context is assembled dynamically.
Tool sequences are generated at runtime.
External effects can become ambiguous.
Evals must inspect the trajectory.

More capable agents need more control over the loop.

The consequence

A better model can combine capabilities beyond the paths an application developer enumerated. It can work longer, cross more system boundaries, delegate, retry, and change real state.

Runtime engineering expands tuning beyond the system prompt. It spans model selection, context assembly, tool shape, authority, execution, recovery, economics, evaluation, and the improvement process itself.

Tuning a production agent is runtime engineering.

The runtime surface

Every operational decision has a name.

Twelve questions define the runtime surface. Cayu exposes their answers as Python contracts you can configure, replace, and compose.

01Identity

Who is doing the work?

Identity and model behavior remain visible as explicit runtime configuration.

AgentSpec
ModelProvider
ThinkingConfig
ModelRequest

02Context

What does it know right now?

The runtime decides what enters context, what stays, and what gets summarized.

ContextPolicy
ContextCompactor
KnowledgeStore
KnowledgeInjectionPolicy

03Capability

What can it attempt?

Capabilities are typed and registered. A tool’s effect is distinct from permission to use it.

Tool
ToolSpec
Workflow
McpToolset

04Authority

What is it authorized to do?

Authority can depend on arguments, provenance, external state, or a human decision.

ToolPolicy
CommandPolicy
ToolApprovalRequest
TaintAwareToolPolicy

05Execution

Where does it act?

The same agent can move between local, isolated, remote, or application-owned execution.

Environment
EnvironmentFactory
Runner
WorkspaceBinding
ArtifactStore

06Access

How does it reach the outside world?

The agent can use an authorized capability without receiving the underlying secret.

Vault
CredentialProxy
VirtualCredentialSpec
HttpEgressPolicy

07Durability

What survives a crash?

Long-running work can resume across process boundaries with its causal history intact.

Session
Event
SessionStore
RunRequest

08Recovery

What if an effect is uncertain?

The runtime checks durable state and external evidence before recovery continues.

ToolEffect
ToolRoundRecoveryRequest
ToolApprovalRecoveryRequest
IncompleteSessionRecoveryResult

09Economics

How much may it consume?

Cost belongs to the operation, including retries, branches, subagents, caching, and compaction.

UsageMetrics
PriceBook
BudgetPolicy
BudgetLedger
BudgetReservation

10Orchestration

How does work continue?

Durable runtime primitives let work react, delegate, branch, and continue.

TaskStore
Dispatcher
EventWatcher
SubagentSpec
SubagentTool

11Evidence

How do we prove it is better?

The full path through the runtime becomes evidence alongside the final answer.

Trajectory
EvalSuite
EvalCase
EvalAssertion
LLMJudge

12Improvement

How does it improve?

Comparisons, policies, and hooks let you select verified changes and update behavior.

ForkSessionRequest
EvalRunComparison
LoopPolicy
BeforeStopDecision
RuntimeHook

Cayu makes operational guarantees explicit.

Configure, replace, or modify the contracts that enforce them.

Where prototypes fail

Production breaks at the boundaries.

The process died after the agent submitted a payment. Did it happen?

Answering requires durable effects, idempotency, checkpoints, receipts, and recovery.

The agent needs a credential. Should the model ever receive it?

Capability and credential possession are different. Vaults, virtual credentials, proxies, egress, and environment boundaries make that distinction enforceable.

The agent completed the task and cost four times as much. Is it better?

Answering requires usage, retries, branches, context, caches, budgets, and trajectory-level evaluation to be measured together.

Runtime ownership

The runtime is your design surface.

Cayu includes working defaults and public contracts for replacing them.

Configure

Select models, tools, policies, budgets, environments, storage, and evaluation.

Replace

Implement your own providers, context policies, runners, stores, factories, dispatchers, and hooks.

Modify

Inspect, change, or fork the open-source runtime when you need to go beyond its public contracts.

Every consequential runtime decision can be code and configuration you own.

Read the runtime contracts

Capabilities unlocked by ownership

Full control changes what you can build.

Cayu’s programmable primitives let you compose behaviors beyond a fixed product menu.

Adaptive economics

Spend context once. Explore many futures.

Prepare shared state, compact it at the right boundary, fork independent strategies, and measure realized provider usage across the whole causal group.

Branching intelligence

Evaluate, critique, and repair.

Run competing strategies from the same checkpoint, let a separate evaluator find a material weakness, and launch a repair from durable evidence.

Counterfactual work

Compute safely while authority waits.

Explore approved and denied futures while a real decision is pending. Keep both auditable, then use only the relevant analysis.

Verified selection

Promote the verified winner.

Generate candidates in isolated workspaces, reject reward hacking, rerun real gates, and publish only the verified result.

Trust-aware containment

Let provenance change authority.

Carry taint across forks and reconstruction, quarantine unsafe work, and transfer only a sanitized, provenance-bearing artifact.

Sessionsbecomebranches

Branchesbecomecandidates

Trajectoriesbecomeevidence

Evaluatorsbecomeselectors

Policiesbecomeconstraints

Verified candidatesbecomenew behavior

Explore the executable advanced examples

The improvement loop

Build agents that improve themselves under rules you own.

The execution loop completes today’s work while the improvement loop uses it to improve tomorrow’s operation.

01Run
02Observe
03Experiment
04Verify
05Promote
06Run again

A Cayu application can observe completed work, generate changes to prompts, tools, policies, context, models, configuration, or source code, test isolated candidates, reject regressions, and promote the verified winner.

Developers choose the governance level: approve every change, supervise the policy, or let the loop run autonomously inside evidence, safety, authority, and budget boundaries they own.

Human-guidedHuman-supervisedFully autonomous

Three answers

Who owns the operation?

Agent framework

“Here are the parts for constructing a flight.”

Useful for packaging behavior. Insufficient as the operation.

Managed agent

“Give us the destination. Fly with our airline.”

Convenient when the provider’s runtime can own the boundary.

Cayu

“Here is the runtime for operating your own airline.”

Own how work is authorized, executed, improved, and recovered.

Frameworks package the loop. Managed platforms own the operation. Cayu gives you the runtime to operate and improve it yourself.

The ownership boundary

Your application is still the business.

Your application owns

Customers and product experience
Authentication and business authorization
Domain rules and workflows
User-facing interfaces and decisions

Cayu operates

Agent execution and durable state
Tool authority and environments
Budgets, evidence, and recovery
The programmable substrate for improvement