We know everything that happens in the exercise. A hosted machine knows almost none of it.
Forge builds the whole estate — the desktops, the servers, the appliances, the wire and the equipment behind it. That decision buys 12 things a rented virtual machine struggles to offer at any price, from a failing optic your team has to diagnose to a grading engine that knows the right answer before the learner does.
Physical and layer-1 faults as first-class content
Cable, optic, network-card, switch-port, power, cooling, disk, memory, firmware, peripheral and wireless faults are planted from a seed and behave consistently across counters, syslog, sensors and the wire.
Why that is hard elsewhere: A hosted virtual machine has no cable to degrade, no transceiver to run hot and no fan to fail. The hypervisor hides exactly the layer this content teaches.
16 fault definitions across 8 families
Where it stops: These are modeled faults with modeled readings. They teach diagnosis and escalation, not the feel of a real data-hall.
Pairs of faults are deliberately built to look alike, so the learner has to reach for a second reading rather than pattern-match the first symptom.
Why that is hard elsewhere: Producing a convincing near-miss on real equipment means breaking real equipment in a controlled way, repeatedly, for every cohort.
3 confusable pairs and 8 reading guides
Where it stops: Ambiguity is authored. A fault nobody wrote down will not appear.
A fault is only closed when it reaches the team that owns it, with the evidence that team needs; wrong-queue escalations are graded as wrong even when the diagnosis was right.
Why that is hard elsewhere: Ownership, service levels and hand-offs live in the customer's service desk, not in the machine being worked on.
8 owning departments with graded escalation
Where it stops: The service desk is simulated; it does not connect to a customer's real ITSM yet.
Management, routing, discovery, sign-in, voice, factory, patch and message-bus traffic are generated as packets, so a wrong rule or a sick interface is visible where a real analyst would see it.
Why that is hard elsewhere: Getting this breadth on real infrastructure means owning and licensing the appliances that speak each protocol.
11 protocol families on the estate wire
Where it stops: Traffic is generated from a model. It replays real captures but does not originate on real hardware.
The simulator knows what is actually true in the world it built, so grading compares the learner's conclusion against fact rather than against a marking key someone guessed at.
Why that is hard elsewhere: On a real machine the grader can only observe outcomes. It cannot know the learner reached the right answer for the wrong reason.
Hidden ground truth is declared on every agent-touching lab and shown only at debrief
Where it stops: Ground truth is only as good as the scenario author's intent.
What was inspected, in what order, how long the learner sat with it, where they backtracked and what they acted on without evidence are all recorded as the run happens.
Why that is hard elsewhere: A virtual machine can be recorded, but the recording is pixels and shell history; it does not know which alert the analyst read and rejected.
A published instrumentation schema with named events and a redaction policy
Where it stops: We record decisions inside the exercise. We do not keystroke-log the person, and the schema says what is dropped.
An attempt is a seed plus a transcript, so an instructor can replay exactly what a learner saw and a support case can be reproduced months later.
Why that is hard elsewhere: Replaying a live machine means keeping the machine, its images and its network alive, or accepting that the evidence is gone.
Every interruption point in a recorded attempt recovers exactly, computed live
Where it stops: Replay is faithful to the model, not to a wall-clock recording of the screen.
Every console, terminal and appliance screen is real markup, so screen readers, keyboard-only work, magnification, reduced motion and six languages reach the whole exercise.
Why that is hard elsewhere: A remote desktop is a video stream. Assistive technology on the learner's machine cannot see inside it.
Keyboard and announcement paths verified in the test suite on every change
Where it stops: We publish our own verification. An independent audit has not been done.
There is no hypervisor boundary, no outbound attack traffic and no customer machine image on our infrastructure, which removes an entire class of security review from the purchase.
Why that is hard elsewhere: Genuine execution buys fidelity and carries containment, egress and data-residency obligations with it.
No real execution anywhere in the product
Where it stops: This is also the honest cost: exploitation against a genuine target belongs on a native lane we have not shipped.
Framework coverage read from the content, not asserted
NIST CSF, the NICE work-role framework, DoD cyber workforce roles and MITRE ATT&CK and D3FEND are mapped onto labs, and the mapping is generated from the catalog so it cannot drift from what exists.
Why that is hard elsewhere: Mapping is possible anywhere; keeping it true as content changes is what fails, and that needs the content to be data.
Framework coverage rendered from the live catalog
Where it stops: This is our own mapping, offered for planning. It is not an accreditation and no authority has endorsed it.
An AI agent and a human analyst act on one world with one audit trail, so an agent's proposal, the human's decision and the effect on the estate sit on the same timeline.
Why that is hard elsewhere: Two separate environments — one for the agent, one for the learner — cannot produce a single defensible record of who decided what.
Agent proposals, approvals and refusals are scored on the learner's own card
Where it stops: A simulated score never certifies that an agent is safe in production.
CYBRARY