THESIS

Agent systems need a
different foundation.

Five primitives. One family. Build anything agentic on top.

Agent products do not behave like traditional software. They do not finish. They make decisions across time and across environments. They hand work off to other agents, to services, to humans, to themselves an hour later. The thing you shipped is a choreography, not a function.

To build real products on this substrate, you need primitives that match the work. You need a way to declare intent. A way to observe the handoff. A way for any process, anywhere, to pull work to itself. A way to capture what actually happened. A way to prove it with evidence that is not narration.

Those primitives compose. That composition is the product surface.

THE FIVE PRIMITIVES

The smallest set that holds up.

01

Cue

The declared intent. When, what, where.

A cue is the unit of agency. It says the thing you want done. Cues are composable. You fire one. You schedule another. You chain many into a pipeline.

02

Execution

One fire of a cue. The handoff boundary.

Every time the declared intent crosses into the world, an execution exists. Executions are where observability lives: status, timing, retries, evidence. Every handoff is one.

03

Worker

Any process, anywhere. Pulls work to itself.

A worker can be a daemon on a laptop, a container, an edge node, or a cloud box. No public URL. No ingress. The handoff finds the worker, not the other way around. Agents live where they belong.

04

Outcome

Write-once report of what happened.

Outcome is what the handler claims. Reported, not assumed. It carries success, result, and metadata. One outcome per execution. It is the unit of truth.

05

Evidence

Proof fields, not narration.

external_id, result_url, result_type, artifacts. The tweet ID, the Stripe charge, the file hash, the pull request number. Evidence is how an outcome goes from claimed to verified. This is what separates agent work from agent output.

Each primitive carries one distinct property. Delivery is not completion. Completion is not verification. Collapse them and the system loses the ability to tell a successful-looking failure from the real thing.

HOW THEY COMPOSE

LEGO bricks. Infinite configurations.

Scheduled agents. Cue (cron) + Execution + Outcome + Evidence. The simplest agent product. One line of declaration, one call of proof.

Multi-step pipelines. Cue chains. Each execution's outcome becomes an input to the next cue's payload. Stateful work across hours or days, without a workflow engine.

Multi-environment fleets. Worker pull lets agents live anywhere. Mac mini on a desk, container in Kubernetes, edge node behind NAT. Same primitive reaches all of them.

Evidence-gated approvals. Verification policies require specific evidence before a cue is marked done. Agents that don't produce proof get flagged. Humans approve where humans should.

Cross-agent coordination. Each agent declares its own intent. Central observability holds the system together. Nothing has to know about nothing else. The primitives do the carrying.

Build on the primitives. The configurations are infinite. The primitives stay the same. That's the point.

CueAPI coordination infrastructure logo

Start coordinating.

pip install cueapi. First cue in 60 seconds. Free forever to start.

How do I know if my agent ran successfully?
Ctrl+K