Infrastructure

The carrier itself. What's actually read, passed, and forwarded

If you're bringing your own stack, this is the one page you need. Systems and Process explain why the whole thing holds together and who gets to move when — useful context, but not what a distributed operation actually needs to trust before it plugs in. This page is about the layer underneath both of those: what has to persist so movement can happen at all.

The Traffic Isn't the Infrastructure

Look at a city street and it's easy to think the traffic is the system — cars, buses, the visible motion. It isn't. Underneath the surface: cable runs, junction boxes, signal wiring, a rail tunnel that was there before today's traffic and will still be there tomorrow. The traffic is what moves. The infrastructure is what stays, so that movement keeps being possible.

The same distinction holds here: the reasoning output isn't the continuity infrastructure. A conclusion, a decision, an answer — all of that is traffic. PIFR, PSS, and the Ledger are the road, the cables, and the maintenance record underneath it.

Traffic Vocabulary, Infrastructure Vocabulary

The Carrier Chain

Continuity depends on preserving enough structure for the next participant to continue the journey — not restart it. Here's the same chain, told twice:

   DRIVER
     │
     ▼
 VEHICLE / CARGO
     │
     ▼
 ROAD NETWORK
     │
     ▼
 ROUTE + SIGNS + HISTORY
     │
     ▼
 NEXT DRIVER / DESTINATION

 PERSON / AGENT A
     │  creates reasoning
     ▼
    PIFR
     │  carried through
     ▼
    PSS ──────────► LEDGER
     │              how this state became this state
     ▼
 NEXT CONTEXT
     │
     ▼
 PERSON / AGENT B
     │  can continue rather than reconstruct
     ▼
 NEW REASONING

Nothing here is exotic. A next driver following a route doesn't need to relearn the city from scratch — the road, the signage, and the maintenance history already did that work. A next agent inheriting a PIFR doesn't need to reconstruct the reasoning behind it — PSS and the Ledger already did that work. This is what "carrier" actually means: not moving something once, but making it possible for whoever comes next to keep moving it.

Output Isn't the Same Thing as the PIFR

The chain above shows the simplest possible case — one relay, one handoff, A to B — for the sake of a clear first picture. It's worth being precise about what it's simplifying, because two different things are easy to blur together.

An output — an answer, a decision, a finished piece of writing — is like a package that's arrived. It can carry a trace back to where it came from: a backlink to the PIFR that produced it, the way cargo carries a manifest. That trace is what Traceable State actually is.

The PIFR itself is a different kind of thing entirely. It isn't a single package moving down a single line from one point to another. It's a node connected to many other PIFRs at once — closer to a neuron inside a brain than a parcel on a truck. In practice, PIFRs interconnect densely, forming what this site calls a Reasoning Network — and it's that network, not any one delivery, that actually holds continuity together.

The Four Pillars

Everything on this page so far has described infrastructure as a chain — a sequence, one thing carried through to the next. There's a second, equally real way to see the same structure: not as a sequence, but as a set of interdependent pillars, where losing any one of them collapses the whole thing, regardless of the order anything happened in.

• Memory — what was done
• Reasoning — why it was done
• Structure — how it connects
• Responsibility — who owns it

Map these onto the carrier chain above and the correspondence is exact: Memory is what a PIFR preserves, Reasoning is why Feedforward exists at all, Structure is what PSS and the Reasoning Network hold together, and Responsibility is what Promotion Gate exists to anchor. Same infrastructure, two honest ways of drawing it — one for how it moves, one for what happens if any part of it goes missing.

What This Means for Your Stack

An on-ramp doesn't ask your vehicle to explain how its engine works. It asks for exactly one thing: merge under the same rules everyone else merges under. Interfacing with this infrastructure works the same way — your own stack stays yours. What has to be admissible is the PIFR you hand across the boundary: identifiable, structured, and built to be carried forward rather than silently dropped the moment it changes hands.

But an on-ramp isn't accessible to just anyone, either. A driver who doesn't recognize a red light isn't merely unwelcome — they're a hazard to themselves and to everyone merging around them. The same holds here: agent-agnostic doesn't mean assumption-free. It means any agent that shares the protocol may participate — not any agent, regardless of whether it does.

None of this requires new hardware or new cabling, either. PKOS doesn't propose a physical layer of its own — it's a protocol, typically carried as NDJSON (newline-delimited JSON), riding on infrastructure that already exists. The wiring in the image above was already there before this page was written. What's new is the shared format traveling through it, not the conduit itself.

This completes the three perspectives. For the felt version of why any of this needed a name at all, see Philosophy. For precise definitions, the Lexicon.

Related Concepts

• PIFR
• Persistent Semantic Scaffold
• Feedforward
• Audit & Repair
• Traceable State
• Reasoning Network