Steer on Traza Cloud

Steering is the engine’s live runs, nudges and run topology, with Traza Cloud’s reach added: every project at once, your phone, your Slack. The engine side is in its Steer guide.

Mission Control

The organization’s Live page lists the runs working right now in every project, and each project has its own. A row is a run’s state in the run guard: the step it is on (or the tool it is about to call, when a pre-call check named it), its steps, cost and tokens, its guard verdict and reasons, its pending nudges, its foresight, and a small graph of its agents. Rows update as runs change.

A run is live while its last activity is recent: a span arriving, or a pre-call check that names its next step. Reading a run’s verdict does not keep it live, so a dashboard polling a run cannot.

Runs in progress come first. A run with no activity for 30 seconds moves below them, dimmed, as idle or finished: the live view cannot tell a finished run from a paused one, so it says both, and the run leaves the board when its last activity falls out of the live window (15 minutes by default). A run its guard stopped stays with the runs in progress until someone approves it or the window passes. The board shows a page of cards at a time, with Show more for the rest; its filters and search cover every live run, not just the cards on screen.

Each row has three actions:

Action	What happens on the engine
Nudge	Queues advice (words for the agent) or a block (a veto of its next step), delivered at its next pre-call check
Kill	Pulls the kill switch: POST /v1/fuses/runs/{run}/trip. The run stays stopped until someone resets it
Approve to continue	Resets the run, with a grant that raises its limits so it can go on

Your role in the organization decides which actions you see.

The same live view is in the API, with a read or full key:

curl -s https://api.trazadb.com/v1/runs/live -H "Authorization: Bearer $TRAZA_API_KEY"

# As server-sent events: a snapshot, then one event per changed run
curl -sN https://api.trazadb.com/v1/runs/live/stream -H "Authorization: Bearer $TRAZA_API_KEY"

Nudges

A nudge is delivered once, in the nudges field of the run’s next pre-call check that names a step ("next": {...}; the Claude Code hook pack and both SDKs always send it). advice leaves the verdict to the guard; 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. A block trips nothing: after the hold the run is judged as usual. A check that names no step is a verdict read, and never takes a nudge.

Queue nudges from Mission Control, a push notification or Slack, or from your own automation with a full key. A message is 1 to 4,096 bytes, waits at most 7 days (an hour by default), and a run holds at most 32 pending nudges. Keep personal data out of them, as you would out of a kill switch reason.

# Queue one (kind: advice or block; ttl_seconds optional, default 3600)
curl -s https://api.trazadb.com/v1/runs/sess-42/nudges \
  -H "Authorization: Bearer $TRAZA_API_KEY" \
  -d '{"message": "Hold refunds over $500 for a human.", "kind": "block", "ttl_seconds": 600}'

# A run's nudges, each pending, delivered or expired
curl -s https://api.trazadb.com/v1/runs/sess-42/nudges -H "Authorization: Bearer $TRAZA_API_KEY"

Both POST /v1/runs/{run}/nudges and GET /v1/runs/{run}/nudges take a full key; ingest and read keys reach neither (403). A nudge is text an agent will act on, so give full keys only to automation you would let instruct your agents. A nudge queued with a key is that key’s act: the agent gets the text as written, and only nudges queued from the console, a notification or Slack are in your organization’s audit log, with the member who sent them. The list takes a full key too, because a read key is what an agent or an MCP client usually holds, and an agent hears its nudges through its check, not by reading the queue.

Your agent hears nudges only if it checks before its steps. In Python:

import os, httpx

def before_step(run_id: str, tool: str | None = None) -> None:
    r = httpx.post(
        "https://api.trazadb.com/v1/fuses/check",
        headers={"Authorization": f"Bearer {os.environ['TRAZA_API_KEY']}"},
        json={"run": run_id, "next": {"tool": tool} if tool else {}},
        timeout=5,
    )
    r.raise_for_status()
    verdict = r.json()
    for nudge in verdict.get("nudges", []):
        print(f"queued in Traza ({nudge['kind']}): {nudge['message']}")  # hand it to your agent
    if verdict["verdict"] == "stop":
        raise RuntimeError("; ".join(verdict["reasons"]))

Any key can ask the check. The key that receives nudges should be the agent’s alone: whoever sends next for a run takes its nudges.

On your phone

The console installs as an app (a web app; no app store): use your browser’s Install or Add to Home Screen. Under Alerts, add a push destination on each device you want to reach, and the browser asks once for permission. Rules can then send a run stopped by a fuse, a run whose foresight reaches likely_failure, and quota events to it.

A notification carries Approve, Kill and Open. Each button holds a one-time token bound to you, the run and the action, which expires after 15 minutes and works once. A press that never reached the run’s cell can be tried again; once the cell may have acted, the button is spent even if its answer was lost (the notification then says so, and opening the run shows where it stands), so one press never acts twice. Nudge… opens the run in the app with the nudge box focused. Notifications go through your browser vendor’s push service with the payload encrypted for your device; the app caches no telemetry offline.

In Slack

Install the Traza app for your organization from Alerts → Slack. Fuse and foresight alerts then arrive as messages with Approve, Kill and Nudge… (which opens a box for the message). The first time you press one, Slack asks you to link your Slack account to your Traza account; after that, each press is checked against your role before anything reaches the engine, and the message is updated in place to say who did what. Slack alerts need a plan with Slack alerts (pricing).

Claude Code

The engine’s hook pack puts the pre-call check in front of every Claude Code tool call, delivering nudges and refusing calls on a stop; run the importer beside it so the session is a live run. See Claude Code and Codex.

Topology and ping-pong

GET /v1/runs/{run}/topology returns a run’s agents, who delegated to whom, the handoff sequence and its cycles. A policy’s max_handoff_cycles stops a run whose agents keep handing control straight back to each other:

curl -s https://api.trazadb.com/v1/fuses/policies \
  -H "Authorization: Bearer $TRAZA_API_KEY" \
  -d '{"name": "support", "match": {"service": "support-app"},
       "limits": {"max_handoff_cycles": 2, "max_cost_usd": 2.0}, "action": "stop"}'

Cycles count named agents only: set gen_ai.agent.name on your agents’ steps.