Field Note · Architecture

The three-piece loop for control rooms

23 June 2026 · Risto Anton Paarni · Helsinki, Finland

A control room is mostly people watching screens, waiting for an alarm, then reaching for a pre-written fix. The Lifetime World Model V1 is a design for the next shape of that work: perceive, imagine the next move, propose the fix — and keep a human in command.

This is a target architecture, not a shipped product and not a signed partnership. The named systems below are technology archetypes we design toward, not vendors we have integrated.

Three roles, one loop. Each maps to a working part of the reference code.

1 · Perception — the anchor

Raw, multi-modal telemetry — temperature, vibration, wind, load — is normalized into one governed snapshot we call the State Vector. The math is deterministic and lives in code, so the snapshot is auditable rather than guessed. A Tesla-style end-to-end sensing stack is the archetype here: signal first, fewer brittle hand-built pipelines.

2 · Imagination — the sandbox

Before any move, a simulator projects what each candidate action would do to the State Vector — the benefit it could relieve against the risk it would add. An NVIDIA Cosmos-class world model is the archetype for a physics-aware version of this. The reference ships a deterministic stand-in, and it is honest about being a stand-in.

3 · Action — the loop engineer

When perception and simulation agree on an optimized path, an agentic layer — the Claude Code archetype — drafts the change. In our reference it runs on the same BaseAgent primitives the rest of the platform already uses. The top-ranked action comes back as a proposal:

// world-model-loop.agent.ts — the loop, deterministic and gated
const stateVector = buildStateVector(telemetry, { anomalyThreshold });
const rankedActions = this.rankCandidates(stateVector, candidates);
const selectedProposal = this.buildProposal(rankedActions, candidates);
// returns { stateVector, rankedActions, selectedProposal, rewardUpdates }

The proposal is never applied by the loop. A live mutation always carries a human gate, and the applied field is typed false so a proposal can never be mistaken for a deploy:

return {
  action,
  rankScore: top.rankScore,
  requiresHumanApproval: true,
  applied: false, // hard-typed — the loop proposes, a human commands
  rationale,
};

The honest part

"Pushes code to the live system" is the highest-risk sentence in this whole idea, so we designed it out from the start. Live mutation stays behind a human / KYA gate. Control-room automation in a physical environment is high-risk under the EU AI Act, which means documentation, logging, and human oversight are part of the build — not a later bolt-on. And no part of this is a Cosmos, Tesla, or Anthropic partnership; they are reference points.

Closed by reward

The loop learns from the operator. When a human overrides a proposed action, that override is recorded as a negative reward and the same action type ranks lower next time. It is a transparent preference weight, not a black box — which is the only kind of learning you can put in front of an auditor.

The short version

Perception anchors the loop in a governed, deterministic State Vector.
A simulator imagines each action's consequence before anything moves.
The agentic layer proposes the fix — never auto-applies it.
Operator overrides teach the loop, in the open.
Target architecture today. Honest about that.