THEPROTOCOL

FOUNDRY LINE

#9 of 21Tier II · full anatomy5/5 primitives live in production
Manufacturing and Robotics Fleets

Robot cells that buy tooling, sell capacity, and hold authority one shift at a time.

Open the live chamber in the app
The animated flow, the attack replays and the deep architecture run there; this page is the reference text.

Who this serves

The problem

A production line already negotiates: cells trade capacity, tooling moves between stations, maintenance is bought from whoever is free. All of it runs on a scheduler that pretends to be a market and a permissions model that pretends not to exist.

The system

FOUNDRY LINE runs a contract manufacturer’s 60 cells as economic actors. A milling cell that finishes early sells the slack to the neighbouring line; a tool changer buys inserts against a parts budget that dies at shift end; every machine identity is a workload certificate that renews itself and revokes in under a second. Authority is per cell, per shift, and the night shift’s tokens cannot spend the morning’s budget by construction.

Because a robot cannot eyeball whether the payment rail is healthy before committing a job, the network proves it continuously: synthetic canary transactions run the same paths real money takes and are judged end to end, so a degraded rail is a red light on a board, not a surprise in a settlement.

And when something is wrong, the response is wired for machines. One action freezes settlement plant-wide while the cells keep machining, because the kill switch here stops the money, not the motion. The safety interlocks that stop motion never meet this network at all; the emergency stop stays exactly where machine safety law put it.

The cast and their ceilings

AgentRoleCeiling
mill-cell-12Machines parts, sells slack capacityOne shift token: a parts budget that dies at shift end.
tooling-supplierConsignment stock, bills per insertPaid exactly once per use. Cannot touch the capacity market.
maintenance-svcSells repairs to whoever is downQuotes and settles within the buying cell’s ceiling, never its own.
canary-runnerProves the rails continuouslySpends synthetic units on real paths. Can never hold a shift budget.

The flow, step by step

  1. The cell’s authority is a capability token: one cell, one shift, a parts budget that dies at shift end.
  2. Mill-cell-12 finishes early and sells the slack to the neighbouring line, inside the clamp.
  3. The tool changer buys inserts against the shift budget. Consignment stock bills itself.
  4. Every trade lands on the ledger, append-only.
  5. Canaries run the same paths real money takes, judged end to end. A degraded rail is a red light, not a surprise.
  6. And one action freezes the money plant-wide. The safety systems that stop motion never met this network.

Each need, mapped to a live primitive

The needThe protocol primitiveStatus
A machine is a workloadSPIFFE identity, short-lived SVIDs, mTLS peer to peerLIVE
A shift is a tokenIRONKEY L4: one cell, one shift, a parts budgetLIVE
The rails are proven, not assumedCanary transactions on live paths, judged end to endLIVE
Emergency stop for moneyREADONLY_MODE freeze + coordinated suspensionLIVE
Inter-cell settlementA2A payment with exactly-once idempotencyLIVE

The attack this chamber refuses: The expired shift

The attack. A compromised cell holds on to its shift token and tries to keep buying inserts an hour after shift end, against the morning’s budget.

Why it fails. The token is an L4 capability: its caveats are intersected with the issuer’s current authority at the moment of use, and at shift end both the token and the budget it named are gone. There is nothing left to spend and no authority left to spend it with, so the attempt dies before any escrow exists to unwind.

Rail S03 · Capability attenuation. A capability token conveys its caveats intersected with the issuer’s current authority, nothing more.

What actually happens. The morning budget opens untouched. The denied attempts sit on the ledger timestamped an hour past shift end, which is how the plant finds the compromised cell.

Deep architecture

FOUNDRY LINE deployed: the plant’s frame runs the capacity market, the shift authority and the kill switch; tooling and maintenance suppliers settle from their own registries; the MES keeps scheduling, and the safety systems stay air-gapped on their own island of this drawing, connected to nothing here on purpose. The trace replays one shift, slack sold to money frozen.

The deployment, traced

  1. Jobs arrive from the MES. The scheduler still schedules; it just stops pretending to be a market.
  2. The cell’s authority is a capability token: one cell, one shift, a parts budget that dies at shift end.
  3. Mill-cell-12 finishes early and sells the slack to the neighbouring line.
  4. The trade lands on the ledger, append-only.
  5. The tool changer buys inserts against the shift budget. Consignment stock bills itself.
  6. The supplier’s frame credits exactly once, across any number of retries.
  7. A repair is bought from whoever is free, inside declared ceilings.
  8. Their ledgers write the same settlements.
  9. A robot cannot eyeball a payment rail, so canaries run the same paths real money takes.
  10. Judged end to end. A degraded rail is a red light on a board, not a surprise in a settlement.
  11. And when something is wrong: one action freezes the money plant-wide. The safety systems, air-gapped below, never met this network.

Adoption, phase by phase

Discover: The line as a market, on paper.

Pilot: Six cells, one market, pocket budgets.

Production: Sixty cells, suppliers settling, kill switch armed.

Federation: Plants trade capacity like cells do.

Sizing

LevelWhatContainers
L1Suppliers join with accounts and agents only0 of theirs
L2The plant runs cell agents against a hosted registry seatagents only
L3A sovereign frame per plant, cells enrolled through the fabric~9 per plant

One insert, consignment to credit

sequenceDiagram
  participant Cell as mill-cell-12
  participant Gate as shift authority (L4)
  participant TEG as plant TEG
  participant XT as cross-registry pay
  participant Sup as tooling supplier (their frame)
  participant ES as event ledger
  Cell->>Gate: buy inserts (token: one cell, one shift)
  Gate-->>Cell: clamped approval, budget debits
  Cell->>TEG: A2A payment, per insert
  TEG-->>ES: settlement, append-only
  TEG->>XT: pay supplier (idempotency key)
  XT->>Sup: their TEG credits, exactly once
  Note over Gate: at shift end the token dies; the budget dies with it
  Note over TEG: canaries run this same path continuously and are judged

Topology, as declared

flowchart LR
  MES["MES / scheduler"] -.->|"jobs in"| C["mill-cell-12<br/>SPIFFE workload"]
  C -->|"shift token: one cell, one shift"| G{"shift authority"}
  G -->|"clamped"| M["capacity market<br/>A2A, exactly-once"]
  M -->|"inserts, per use"| Sup["tooling-supplier"]
  M --> L[("event ledger")]
  K["canary-runner"] -.->|"synthetic, same rails"| M
  Op["line operator"] -.->|"freeze, one action"| G

Standing it up

What this does not claim