Back to Logistics & Freight

Live Demo · Agent 02 · Logistics

This time, you run the agent.

The Exception Scout watches every load on a freight desk and speaks up before the customer asks. This console opens it up, layer by layer. Every checkpoint is a click, and nothing moves until you do.

Click advances the run 3 calls are yours to fire 1 decision only you can make
briefing · state persisted from tick #2,846
47

active loads on the board. The last tick ran at 17:27Z and alerted once. Tick #2,847 is due. Six layers sit between the raw feed and one alert worth a person’s attention. You advance every one of them.

layer 01 · ingestion · read-only pull · 17:42Z
17:42:01Z LD-2214 33.447,-112.074 61 mph IN_TRANSIT src: eld 17:42:01Z LD-5120 45.601,-122.640 54 mph IN_TRANSIT src: api 17:42:02Z LD-3302 41.129,-104.812 0 mph IN_TRANSIT src: api 17:42:02Z LD-1893 33.010,-96.700 58 mph IN_TRANSIT src: edi 17:42:02Z LD-4917 41.523,-90.577 0 mph AT_PICKUP src: api 17:42:03Z LD-2731 39.740,-104.990 arrived DELIVERED src: edi 17:42:03Z LD-4088 no ping for 51m last seen 16:51Z src: api 17:42:04Z ...40 more loads · 214 events this tick

For the engineer: webhooks where a carrier offers them, polling where they do not. Every source speaks a different dialect, so the first job is normalizing to one canonical event. This layer interprets nothing. Shape only.

layer 02 · state · the shipment model between ticks
LoadLaneLast pingDwellPromisedDrift
LD-2214LAX → PHX17:42:01Z0m19:45Z-0h20m
LD-3302CHI → DEN17:42:02Z74m stopped18:30Z+3h10m
LD-4088ATL → BNA16:51:44Zsilent 51m20:15Zunknown
LD-4917DAV → MSP17:42:02Z82m at pickup22:00Z+0h45m
LD-5120SEA → PDX17:42:01Z0m21:15Z+0h06m
LD-1893DFW → OKC17:42:02Z0m20:40Z-0h05m

+ 41 more, all inside their windows

For the engineer: a small store keyed by load carries what a single ping cannot: computed dwell, the promised window from the order record, and what was already alerted on. Ticks are stateless runs over durable state. A crashed run loses nothing, a restarted one double-alerts nothing.

layer 03 · detection · deterministic rules, zero tokens
if dwell_at_stop > 45m → LD-3302 (74m) · LD-4917 (82m)
if projected_eta - promised > buffer(45m) → LD-3302 (+3h10m)
if missed_pings >= 3 → LD-4088 (51m dark)
4747candidates for the model

For the engineer: this is the cost gate. Three thresholds in ordinary code drop 44 healthy loads at zero tokens, which is why watching every load costs almost nothing. On a typical tick roughly 95 percent of the board stops here.

layer 04 · reasoning · schema-enforced json · 0 of 3 run
LD-3302
route planlast 6 pingsorder windowroad status
context package → model route: CHI → DEN via I-80, 996 mi, 741 mi run pings: 6 · stationary 74m at MM 268, I-80 WY window: promised 18:30Z, buffer 45m road: I-80 closed at MM 268, incident 16:28Z order: retail DC delivery, dock closes 23:00 local
{ "exception": true, "severity": "high", "cause": "I-80 closed at MM 268, rerouted via US-30", "new_eta": "21:40Z (+3h10m)", "draft": "Your Denver delivery now lands 3:40 pm local..." }
EXCEPTION · HIGH
LD-4917
dwell logorder termsfacility notes
context package → model dwell: 82m at pickup, free time 120m terms: detention billable after 2h, $65/h facility: shipper avg load time 96m (last 30 days) window: promised 22:00Z, slack 45m
{ "exception": true, "severity": "medium", "cause": "detention building at pickup, 82m of 120m free", "new_eta": "22:45Z (+0h45m)", "draft": "Pickup is running long at the shipper..." }
EXCEPTION · MEDIUM
LD-4088
ping gapdriver notesorder window
context package → model pings: last 16:51Z, 51m dark, 3 missed notes: driver check-call 17:31Z, "fuel queue" window: promised 20:15Z, buffer 45m projection: drift 12m if rolling by 18:00Z
{ "exception": false, "note": "tracker dark 51m, but a driver check-call at 17:31Z says fuel queue. Projected drift 12m, inside the 45m buffer.", "action": "recheck next tick" }
NOT AN EXCEPTION

For the engineer: only candidates ever reach the model, one call each, full context attached. The contract is schema-enforced JSON: exception or not, severity, cause, new ETA, and a customer-safe draft. The model judges and writes. It does not fetch, post, or decide policy.

fire all three calls first
layer 05 · guardrails · check every gate · 0 of 4 checked

For the engineer: none of this is language. Read-only credentials in the runner, a hard spend cap in the request path, an idempotency key, an append-only audit log. The model never sees these controls and cannot talk its way past them.

check all four gates first
layer 06 · delivery · #load-exceptions · wired to the ops desk
#load-exceptions17:42Z
Exception ScoutAPP17:42Z
⚠ HIGH · NEW EXCEPTION LD-3302 · Chicago → Denver · Carrier 114 · 34,880 lb Promised 18:30Z → new ETA 21:40Z (+3h10m) Cause: I-80 closed at MM 268. Rerouted via US-30, moving at 58 mph. Draft for the customer: “Your Denver delivery now lands at 3:40 pm local. Interstate closure; the driver is rerouted and moving. We will confirm on arrival.” last 6 pingsroute snapshotorder windowrun log #2,847
The alert is on your desk. What do you do?

For the engineer: one structured message, evidence attached, then the agent stops. The customer call, the carrier escalation, the judgment: human. The agent’s job ends at “you knew first.”

make the call first
debrief · tick #2,847 complete

That was one tick of ninety-six today.

You clicked this one through. The other ninety-five run themselves, exactly this way, while the desk does the work only people can do.

loads read 47 escalated 3 model calls 3 exceptions 2 alerts 1 spend $0.014 the decision yours

Simulated loads, real anatomy. The freight is invented for the demo; the layer boundaries, the cost gate, and where the guardrails sit are exactly how the production build is wired.

The Spec

Six layers, no magic.

The anatomy transfers to any stack: swap the feed, the order system, and the channel, and the boundaries hold. What matters is what each layer is allowed to do.

Layer 01

Ingestion

A read-only poll of the track-and-trace feed on a 15 minute cron. Webhooks where a carrier offers them, polling where they do not. Every source speaks a different dialect, so the first job is normalizing to one canonical event: load, timestamp, position, speed, status, source. This layer interprets nothing.

Layer 02

State

A small store keyed by load: latest ping, computed dwell, the promised window from the order record, and every alert already sent. Ticks are stateless runs over durable state, so a crashed run loses nothing and a restarted one double-alerts nothing.

Layer 03

Detection

Deterministic thresholds in ordinary code: dwell at a stop, projected ETA drift against the window buffer, trackers gone silent. This is the cost gate. A healthy load never reaches the model, and on a typical tick that is roughly 95 percent of the board.

Layer 04

Reasoning

Candidates go to the model one at a time, each call carrying the load’s full context: route plan, recent pings, dwell history, order terms, road status. The contract is schema-enforced JSON: exception or not, severity, cause, new ETA, and a customer-safe draft. The model judges and writes. It does not act.

Layer 05

Guardrails

Enforced by the harness, never the prompt: read-only credentials in the runner, a hard per-run spend cap in the request path, an idempotency key so one exception alerts exactly once, and an append-only audit log of every input, call, and post.

Layer 06

Delivery

One structured message to the ops channel with the evidence attached: pings, route, window. A named human owns everything outward, the customer call and the carrier escalation. The agent’s job ends at “you knew first.”