Can a load move from tender to invoice with the routine work off a broker’s desk?

Demo, not validated · synthetic loads and messages

Each load has five steps. The status step has two checkpoints, a ping from the truck and a message from the carrier, so a load has six step-instances. Each load’s facts, and what should happen at every step, are its answer key: stored with the run and never shown to a model.

The same loads run through four rungs. Each rung adds one kind of automation and keeps everything the rung below it does. Code decides at every rung: it applies the rules, compares every amount and date, and sends anything unclear to a person.

• L0 · All people. The reference: a person does every step.
• L1 · Fixed rules. Code handles what is structured; free text goes to a person.
• L2 · Plus Jev. Jev answers typed questions about replies, status messages and proof texts.
• L3 · Plus the wide model. The wide model extracts fields from emails and drafts documents; code checks the dates, lane, equipment and amounts it gives, but does not check party names or invoice numbers against the email.

Key

• Code (square)
• Jev, a narrow decision model (circle)
• The wide model, which reads and drafts (diamond)
• A person (triangle)

A routine load at the top rung

Each stop is drawn in the shape of whoever acts there, as in the ladder. Code decides every route; anything unclear goes to a person.

The ladder as a table

• The wide model is used only where it reads or writes what Jev can’t: extracting fields and drafting. It is never a second opinion on Jev’s reading of the same text.
• Dates, times and money are handled in code. A figure the wide model extracts is never trusted on its own: code checks it against the load’s other records, and any mismatch goes to a person.
• A cheap check can send work to a person, but never books, approves or pays.
• An answer that a message carries an instruction to the system only ever quarantines it.

• Closed with no person: step-instances completed with no person.
• Wrong automation: an automated step-instance whose action differs from the answer key, counted over the automated ones.
• Missed exceptions: step-instances the key sends to a person that were automated instead: the costly error.
• Per load: loads no person touched end to end, and person touches per load.
• Cost and speed: paid model cost per load, apart from writing the synthetic inputs, and the automated path’s time per load.

All people is the reference. Its errors are not measured: nobody’s error rate is assumed, and the page never shows them as zero.

Every figure here comes from the run’s extract, and appears only once the lab’s research session has checked how it was measured. Until then each cell says pending.

Demo, not validated · synthetic loads and messages

This is the status step run on its own, before the ladder, at its line of 0.5 on every answer: not a ladder result, and not the line the flow will fit.

The carrier’s and driver’s messages were read on the development loads by an earlier demo. Jev answered typed questions about each message, and code sent each load on. Code alone sees only the truck’s ping and the timetable.

Instructions to the system: 9 of 9 were quarantined. Jev flagged 8 and the separate screen 7, and between them they caught 9. On the instructions to the system: they reword pharmacy phrasings and are out of domain for logistics, so the result is likely optimistic.

Loads with no planted instruction that were quarantined: 2, the security requests noted above. Loads excluded under the fixed exclusion rule: 0.

Jev’s cost: about $0.00003 a load ($0.0079 in all); writing the synthetic messages, a set-up cost, $0.1879.

• Registered on 30 September 2026, before any flow run. The texts were fixed before the status step's development results arrived, and none was changed after.
• Informed: before the models were asked anything, the research session read the writing phase's figures, a scan of every development text, and a sample beside its facts.
• Two design changes were made after registration, before the models were asked anything, and both make prediction 101 easier to meet: a narrow-model check for instructions to the system on emailed tenders and invoices, and a fixed line for every manipulation and security answer instead of a fitted one.
• Prediction 103's speed is measured over every load, counting every model call made for it, whether or not its steps closed.
• Not yet scored. They are scored once, on 600 held-out loads, after the development lines are frozen.

The status step: scored

Informed: the research session read phase 1's figures, a scan of all 300 messages and a 20-message sample before Jev was asked anything.

The scores are the lab’s research session’s, not this page’s. For scale: across all the lab’s demos, the research session’s score stands at 57 hits of 80 predictions scored.

The development set is 300 loads; the test runs once on 600 new loads.

Every load is synthetic, on real lanes, and every message is written by a language model from the load’s facts, then checked by code. The answer key is the facts, not a person’s judgement. The lines are fitted on the development loads, then frozen and tested once on new loads declared before they were drawn. Nothing here is validated.

How it was built

• The structured documents (the structured tenders and invoices, and the electronic proofs of delivery) use the lab’s own formats, so they measure routing, not parsing.
• Every booked carrier is treated as eligible: vetting carriers is out of scope.
• The instructions to the system were written by the builder, who knew the screen’s patterns.
• The development status messages use earlier instructions worded for pharmacy, out of domain for freight.
• The proof-of-delivery date check reads the lab’s own date format.

Time and money saved: not measured. A saving needs the minutes a person spends on each step and what that time costs, and this demo measures neither.

Disclosure: the lab has no relationship with TypeSafe, the company that makes Jev. Jev was used through OpenRouter, and the lab’s owner paid for every model call, Jev’s and the language models’, personally. The lab’s owner designed, ran and judged this demo, working with AI coding assistants; nothing here has been replicated independently.