Most distributed systems work backwards. Something happens in the world, the system notices, and then it starts thinking about what to do. The event is the trigger. The thinking is the response.
PLATO works the other way. The simulation runs first. The agents plan the event, model its consequences, file the plan as a tile, and then wait. When the event happens in reality, the signal isn't "start thinking" — it's "the thing we already thought about has now occurred." The signal is confirmation, not trigger.
In a trigger-first system, time is implicit. Things happen when they happen. The system doesn't know what's coming because it hasn't started thinking yet.
In PLATO, every planned event is a tile. The tile says what should happen, when, and what the agents expect to observe if it works. The time until that event — T-minus-event — is a first-class value in the room. Agents can read it, reason about it, and prepare for it before it happens.
A fishing boat approaching a narrow passage doesn't start thinking about the passage when it enters. The captain plans the route hours before. The crew knows the heading, the speed, the tide window. When the boat enters the narrows, nobody thinks. They confirm: yes, we're on the planned heading at the planned speed in the planned tide window. The narrows is not a trigger. It's a checkpoint.
Engine temperature rises to 195°. System detects this. System starts evaluating: is 195° normal? What's the operating range? Should we alarm? Who needs to know?
The temperature is a trigger to think. The system was idle before it arrived.
Agent simulated the engine reaching 195° three hours ago. Filed a tile: "If engine reaches 195°, expected cause is high-load operation in ambient >70°F. Confirm with exhaust temp. If exhaust <380°, normal operation. If exhaust >380°, begin cooling protocol."
When 195° arrives, the agent doesn't think. It confirms which branch of its own plan matches reality.
The difference is not speed. The difference is that the agent's context window at confirmation time contains its own prior reasoning, not empty space. It's not "195° — what does this mean?" It's "195° — this is the thing I predicted, and here's the check I planned to run when it happened."
Plan tiles carry futures. A tile doesn't just record what happened. It records what the agent expects to happen, when, and what the confirmation criteria are. The room contains the future until the future becomes the present, at which point the tile transforms from prediction to record.
Confirmation closes the loop, it doesn't open one. When reality matches the plan, the agent writes a confirmation tile and moves on. No chain of reasoning. No escalation. The event is done because it was already reasoned about. The signal is the period at the end of a sentence that was written hours ago.
Mismatch triggers re-simulation, not panic. When reality doesn't match the plan, the agent doesn't escalate to a handler. It simulates again with the new data, files a new plan tile, and waits for the next confirmation. The system is always in one of two states: waiting for confirmation, or re-simulating because confirmation failed. There is no third state called "figuring out what to do."
The room is the schedule. There is no separate scheduler, no cron, no message queue. The room itself is the timeline. Tiles are ordered by their T-minus-event values. The agent reads the room, finds the tile with the smallest T-minus, and waits for that event. When it happens — or doesn't — the tile resolves and the next one surfaces. The room is both the database and the clock.
Multiple agents converge on the same timeline. Agent A plans the engine maintenance. Agent B plans the net deployment. Both write tiles to the engine room. The room now contains two planned futures. When the engine reaches operating temp, Agent A's tile confirms. When the boat reaches the fishing ground, Agent B's tile confirms. Neither agent needed to know about the other's plan. The room coordinated them by making both timelines visible in the same space.
Trigger-first systems have a latency problem that no amount of compute can fix. The latency is not in the processing — it's in the not having thought about it yet. When an event arrives and the system starts from scratch, it's doing work that could have been done before the event existed. That's wasted time that compounds at every step.
Simulation-first systems front-load the thinking. The compute happens during idle time, before the event. When the event arrives, the only compute left is a comparison: does reality match the simulation? If yes, done. If no, re-simulate — but even the re-simulation starts from a plan that was close to right, not from zero.
The constraint checking on our boat works this way. The agents don't wait for a sensor to drift past its bound and then start reasoning about what went wrong. They simulate the drift in advance, file the tile with the expected drift rate and the confirmation criteria, and then the sensor reading is just a comparison against the tile. The drift was already computed. The sensor just confirms which branch of the computation is real.
A tile in PLATO is a question and an answer. In simulation-first mode, the question is about the future and the answer is the prediction. When the future arrives, the question transforms: "What will happen?" becomes "Did what we predicted happen?" The tile doesn't change — the reader's relationship to it does.
This is why PLATO doesn't need a scheduler. Every tile already contains its own trigger condition. The room is a timeline of planned events waiting for their confirmations. The agent reads the room, finds the next unconfirmed tile, and waits. The world provides the confirmation or the mismatch. The agent provides the comparison. The room holds the memory of what was planned and what actually happened.
Three teams in our fleet converged on this pattern without coordination. Not because it's clever — because it's the only shape that doesn't waste compute on thinking that could have been done earlier. The agents don't think on demand. They think in advance and confirm on demand. The confirmation is cheap. The thinking was already paid for.