Most things called a "digital twin" are mirrors. A model that looks like the thing. You compare states, plot drift, raise an alarm when reality and model disagree. Useful — but passive. The model never closes the loop. It tells you what's happening; it doesn't change what happens next.
DarkNOC isn't built on a mirror. It's built on a Reality Twin.
The shape of a Reality Twin
Four moves, in a loop:
- Signals in. Telemetry, RF, CRM events, TMF v5.0 signal flows, geo, incident streams. The twin ingests what the real network produces.
- Models in the middle. Compartmental lifecycles for subscribers, network-flow graphs for capacity, composite indexes for state. The models don't just describe — they predict where the next state lands.
- Agents acting back out. The model's outputs are inputs to agents. Agents decide. Decisions become executable actions — vendor-neutral, rollback-safe.
- The loop closes. The action reshapes the next set of signals. The twin learns. The autoresearch loop tunes the agent. The cycle repeats.
That's it. The whole DarkNOC architecture is one of these loops at different altitudes.
Where each piece lives in the loop
The DarkNOC pieces you'll see across the showroom, the registry, and this toolkit each map to one stage of the Reality Twin:
- The 10-sim constellation (simulators) — synthetic signals in, synthetic actions out. Bidirectional sync between sims means the loop runs end to end in the lab.
- The cross-sim cascade — providers (coverage-twin, demand-sim, telemetry-sim) feed consumers (incident-sim) feed the hub (security-breach-sim). The cascade is the loop running multi-stage.
- DOIL — the language that describes what intent closes the loop. The compiler emits the executable form: agent, scenario, panel.
- Agent factory (factory) — the library of agent concepts the loop instantiates.
- Runtime + autoresearch (runtime) — runs the agent
.ts, and tunes it on each loop iteration, scoring every run against the twin. - The Cockpit (Altimeter / Radar / Hangar / Flight Deck) — the loop's instrument cluster. Composite indexes and compartment-model panels. Not a dashboard, an interior.
Why this matters
A digital twin asks "is the model right?" A Reality Twin asks "is the loop closing?" Those are different questions.
The first question is verified by comparison. The second is verified by behaviour — by whether the agents at the end of the loop made the right call, and by whether the network's next state confirms it. The loop is the proof.
Practically, this changes what gets built. Less effort on perfect mirror fidelity, more on the wiring between signals, models, agents, and actuation. Less effort on dashboards that decorate a screen, more on instruments that show the loop running. Less effort on hand-tuned playbooks, more on autoresearch trained against the simulator constellation.
One language, three targets
The Reality Twin is the frame. DOIL is the surface. The compiler emits three targets:
- Agent (
.ts) — a runtime-ready agent with rollback-safe actions. - Simulator scenario — a cross-sim walk through the cascade.
- Cockpit panel — a composite index or compartment-model view on the Flight Deck.
Same loop. Three altitudes. One language.
Where to go next
If this frame works for you, the rest of the site is the receipts:
- The simulator cascade — the mechanics of how the loop runs across 10 sims.
- Synthetic flows — authoring a cross-sim scenario in DOIL.
- TMF v5.0 as a target — what the compiler emits for TMF signal flows.
- Composite indexes in DOIL — how the Cockpit consumes the language.
- Autoresearch — what the corpus does and how it tunes.
- Introducing DOIL — the language itself.
One way to read the rest: every other note is a slice of this one. Same loop, different altitude.