Steer

See every run working now. Change its course before its next step.

The run guard already follows every live run in memory and is asked before each step whether the step may run. Steering puts a person in that loop: a live view of what is running, nudges that reach the agent at its next check, and a kill switch — from the console, your phone or Slack.

Start free Steer on Traza Cloud

Mission Control

What is running, what it is about to do, and how runs like it ended.

A run is live while its last activity — a span arriving, or a pre-call check naming its next step — is recent. Each row is the guard’s own state: the step the run is on (or the tool it is about to call), what it has spent, its verdict, any pending nudges, and its foresight, read from memory and the cached Fate Map. On Traza Cloud the grid covers every project of your organization at once and updates as runs change.

Runs in flight, as GET /v1/runs/live lists them
Run	Now	Steps	Cost	Guard	Foresight	Success odds
`live-doomed-0`support-agent	`tool:search_orders`	5	$0.0020	continue	likely_failure	10% CI 4–21% · 50 runs
`live-doomed-1`support-agent	`tool:search_orders`	4	$0.0020	continue	likely_failure	10% CI 4–21% · 50 runs
`live-doomed-2`support-agent	`tool:search_orders`	6	$0.0020	continue	likely_failure	10% CI 4–21% · 50 runs
`live-early-0`support-agent	`llm:gpt-4o`	1	$0.0020	continue	on_track	54% CI 47–62% · 180 runs
`live-healthy-0`support-agent	`tool:issue_refund`	4	$0.0040	continue	on_track	77% CI 67–84% · 90 runs
`live-novel-0`support-agent	`tool:delete_database`	2	$0.0020	continue	novel	54% CI 47–62% · 180 runs

Demo corpus Real output of traza-server 0.28.0 over the engine’s seeded behaviour corpus (226 runs, 1,342 spans), recorded 2026-10-18 by scripts/demo-numbers.mjs. Synthetic runs with known outcomes, not customer data.

The demo corpus’s six runs still in flight, before any nudge or policy.

Nudges

Words for a running agent, or a veto of its next step.

A nudge is queued for one run and delivered once, at the run’s next pre-call check — the check the hook pack and both SDKs already make before every step. advice is words for the agent; the verdict stays the guard’s own. block answers that check stop with the message as its first reason, and every other check of the run in the two seconds after, so a batch of tool calls is refused together. It trips nothing: after the hold, the run is judged as usual.

A check that names no next step is a verdict read: it answers with no nudges and leaves them pending, so a dashboard polling a run can never take the agent’s nudges. On the demo run, a verdict read made between queueing and delivery returned none.

Queued for live-doomed-0: advice “The order does not exist. Stop searching and escalate to a human.”

Its next check: POST /v1/fuses/check {"run":"live-doomed-0","next":{"tool":"search_orders"}}

{"verdict": "continue",
 "reasons": [],
 "nudges": [{"kind": "advice", "message": "The order does not exist. Stop searching and escalate to a human."}]}

Queued for live-doomed-0: block “Do not call search_orders again.”

Its next check: POST /v1/fuses/check {"run":"live-doomed-0","next":{"tool":"search_orders"}}

{"verdict": "stop",
 "reasons": ["Do not call search_orders again."],
 "nudges": [{"kind": "block", "message": "Do not call search_orders again."}]}

Engine output from the demo corpus, with no fuse policy beyond the cell’s global one.

From your phone

Approve, kill or nudge, from the notification.

The console installs as an app on your phone or desktop — a web app, no app store — and asks once whether it may send you notifications. Alert rules then gain a push destination per person: a run stopped by a fuse, a run whose foresight reaches likely_failure, a quota event.

Approve resets the run with a grant, so it may go on.
Kill pulls the kill switch: the run stays stopped until someone resets it.
Nudge… opens the run with the nudge box focused; the agent hears it at its next check.

Each action button carries a one-time token, bound to you, the run and the action, that expires after 15 minutes and works once. Push messages go only through the browser vendors’ push services, encrypted end to end to your device. The app caches no telemetry offline.

9:41●●●

Traza Cloud · Foresight

live-doomed-0 likely failure

runs that took this path succeeded 5 of 50 times (10.0%, 95% CI 4.3–21.4%); the agent's overall success rate is 54%

ApproveKillNudge…

Nudge live-doomed-0

adviceblock

The order does not exist. Stop searching and escalate to a human.

Send nudge

Its next pre-call check · next: search_orders

verdict continue

nudges: [advice] delivered

Illustration of the console on a phone. The run, its foresight, the nudge and the check’s answer are engine output from the demo corpus.

Slack, interactive

The same three buttons where your team already talks.

Install the Traza app in your Slack workspace and fuse and foresight alerts arrive as interactive messages with Approve, Kill and Nudge…, which opens a box for the message. Each person links their Slack account to their Traza account once; every click is then checked against their role in the organization before anything reaches the engine, and the message is updated in place with who did what.

Every interaction request is verified with Slack’s signing secret and refused when older than five minutes. The bot token is stored encrypted. Slack alerts are on Pro and up.

Topology

Which agents a run involved, and where they bounced it back and forth.

A run’s agent graph, computed from its stored spans: who delegated to whom, who handed control to whom, and cycles — control returning to an agent straight from the one it handed off to. A fuse policy may cap them with max_handoff_cycles, so two agents ping-ponging a task are stopped like any loop.

GET /v1/runs/11111111…/topology, the demo Claude Code session

claude-code general-purpose claude-code

Agents of the session
Agent	Steps	Model calls	Tool calls	Errors
`claude-code`	11	7	4	2
`general-purpose`	4	2	1	0

claude-code → general-purpose → claude-code: 1 cycle

Demo corpus Real output of traza-server 0.28.0 over the engine’s synthetic Claude Code and Codex transcripts (4 sessions), imported with traza-server import, recorded 2026-10-18 by scripts/demo-numbers.mjs. Synthetic runs with known outcomes, not customer data.

Claude Code

One command puts the gate in front of every session.

The engine’s Claude Code hook pack asks the pre-call check before each tool call, naming the tool. A stop or a block nudge denies the call with the reason shown to Claude; advice is added as context. It never answers “allow”, so your own permission prompts still ask what they would have asked.

Run the importer with --watch beside it, and the session is a live run with foresight in Mission Control: the same session id the hook checks.

From a checkout of the open engine, in your project

python3 examples/claude-code/install.py --url https://api.trazadb.com
export TRAZA_TOKEN=tzk_…   # a read key: the hook asks the check and reads recall

Claude Code and Codex on Traza Cloud

Stated plainly

What steering does not do.

Delivery is at most once, and needs a check. An answer lost on the way loses the nudge with it. An agent that never checks never hears its nudges.
A veto blocks a two-second window, not a turn. A later call of the same batch that waits behind a long one gets past it. Use the kill switch to stop a run.
A nudge’s author is a credential, not a person. Its text reaches the agent as written; the hook pack relays it as queued in Traza, not as anyone’s words.
A step in flight is never interrupted. Everything here acts between steps.
Handoff cycles count named agents only. Name agents with gen_ai.agent.name, or a run gets service nodes but no turns.

The full Steer guide, limitations included