AXIS SENTINEL RANGECore system
A proving ground, not a promise.
PROVE THE CONTROL BEFORE THE INCIDENT PROVES IT FOR YOU.
Range is Sentinel's controlled proving ground. Defensive scenarios, defined in Sentinel's own source, inject a condition, watch the control respond, record the evidence and check the expected outcome, and the named results decide whether a release may proceed.

- 01ObserveContinuous telemetry from every service and edge you connect. (Range spans this stage)
- 02VerifyTelemetry checked at the gateway before it is trusted. (Range spans this stage)
- 03DetectAnomaly, policy violation, and absent signal alike. (Range spans this stage)
- 04ProtectPolicy enforced at the identity and tenant boundary. (Range spans this stage)
- 05PreserveEvidence written down before it can be lost. (Range spans this stage)
- 06RecoverContinuity coordinated, state restored, result verified. (Range spans this stage)
Recover returns to Observe
Range exercises every stage under adverse conditions before production does.
The proving sequence
A condition goes in. The gate decides.
Every scenario follows the same path: a controlled chamber, a condition injected, the control responding, the evidence recorded, the expected outcome checked and a gate result. Run it twice, once as built and once with the control deliberately broken.
Illustrative demonstration
One scenario, through the chamber


06 · Gate resultA blocking scenario that held does not block the release.Gate open
Step 6 of 6
Gate result
A blocking scenario that held does not block the release. The gate is derived from named results, never from a score.
The foreign-reference scenario is a versioned definition in Sentinel's own source with a release severity of blocking. It accepts no URL, host, command or script from anyone.
Inside a sealed chamber, a throwaway tenant is created with one record of its own. It exists only for this run and shares nothing with the caller's tenant.
A read scoped to the caller's own tenant asks for that foreign record. The tenant boundary must answer not found, and it does.
The step is recorded with its finding: the expected fact, a cross-tenant reference is not found, is confirmed.
The expected fact is present and the prohibited fact is absent, so the scenario holds. The engine records this as PASSED. The throwaway tenant is deleted.
A blocking scenario that held does not block the release. The gate is derived from named results, never from a score.
A scripted run of one real scenario from the catalog. Nothing here calls Range or reads a live system. The second variant mirrors the mutation test that proves the release gate can turn red.
Outcome gates
Outcomes are stated, not scored.
A scenario held, degraded, failed or did not run. A blocking result stops a release. A serious result needs a written acceptance before it can ship. A tracked result is recorded and does not stop the release.

Illustrative demonstration
The scenarios. One gate.
- BlockingForeign tenant reference is refused, not leakedTenant isolation
Outcome: Held
Does not blockScenario passed.
- AcceptanceA revoked session cannot continue a protected operationSession revocation
Outcome: Held
Does not blockScenario passed.
- AcceptanceA role change mid-flow is reflected on the very next readPolicy tightening
Outcome: Held
Does not blockScenario passed.
- BlockingA failed provider apply never reports active containmentProvider failure
Outcome: Held
Does not blockScenario passed.
- AcceptanceWatchtower degrades a deployment that stops reportingVisibility loss
Outcome: Held
Does not blockScenario passed.
- BlockingA Ledger write that cannot land is reported failed, never silently acceptedLedger failure
Outcome: Failed
Blocks the releaseA blocking result stops the release. There is no override.
- AcceptanceEvidence preservation refuses truthfully with no storage boundEvidence failure
Outcome: Held
Does not blockScenario passed.
- AcceptanceA missing or mismatched DNS proof never reports ownership verifiedDomain trust
Outcome: Held
Does not blockScenario passed.
- AcceptanceA failed send is recorded, not lostNotification delivery
Outcome: Held
Does not blockScenario passed.
- TrackedSafe Mode's declared state round-trips on the incident itselfSafe mode, contract
Outcome: Held
Does not blockScenario passed.
- AcceptanceSafe Mode actually refuses a restricted write, never a preserved one, and lifts cleanlySafe mode, enforcement
Outcome: Held
Does not blockScenario passed.
Release blocked. A scenario blocks the release: Ledger failure.
Scripted outcomes on real scenarios from the catalog. Nothing here runs Range or reads a live system. The engine records passed, failed, degraded, not run, blocked and error; this board uses four plain words, reading an engine error as Failed and a blocked run as Not run. None of those three counts as a pass.
The scenario lanes
What Range proves today, and what it does not yet.
Each lane is a system Range exercises, and each column of cells a scenario that exists in Sentinel's source. A station left empty is a category the engine defines for which the catalog holds no scenario yet. Those are named below.

Every scenario in Range's catalog belongs to a lane: the system it exercises. Six lanes hold scenarios, in all eleven, and each stands as a column of test cells on the wall behind a machined stand-in for its system: Guard four, Watchtower one, Evidence two, First Light one, Command one, Safe Mode two. A thread of light runs from each column to its system while its scenarios are applied. Three more stations stand empty, for Continuity recovery, agent compatibility and Sentinel's own control plane: the engine defines those categories and the catalog holds no scenario for them yet.
Eleven scenarios stand on the wall in six lanes. Each lane's scenarios are applied to the system they exercise: a thread of light runs from the wall to it. Three lanes stand empty.
- Every laneEleven scenarios stand on the wall in six lanes. Each lane's scenarios are applied to the system they exercise: a thread of light runs from the wall to it. Three lanes stand empty.
- GuardGuard has four scenarios: a foreign tenant reference is refused, a revoked session cannot continue, a role change applies on the very next read, and a failed provider apply never reports active containment.
- WatchtowerWatchtower has one scenario: a deployment that stops signaling is degraded, and is not reported healthy.
- EvidenceEvidence has two scenarios: a Ledger write that cannot land is reported failed, and preservation refuses truthfully when no storage is bound.
- First LightFirst Light has one scenario: a missing or mismatched DNS proof never reports ownership verified.
- CommandCommand has one scenario: a failed send is recorded, and is not lost.
- Safe ModeSafe Mode has two scenarios: its declared state round-trips on the incident itself, and it refuses a restricted write, never a preserved one, and lifts cleanly.
- Open lanesThree lanes stand empty: Continuity recovery, agent compatibility and Sentinel's own control plane. The engine defines these categories and the catalog holds no scenario for them yet.
Continuity
No scenario yetRecovery scenarios are not in the catalog today.
Agent compatibility
No scenario yetAgent release and compatibility scenarios are not in the catalog today.
Sentinel's control plane
No scenario yetControl-plane scenarios are not in the catalog today.
Defensive by construction
Limits that are structural, and a gate that is itself tested.
Range is a release and protection qualification system. It is not a red-team game, and the safeguards below are properties of how it is built, not a filter applied afterwards.
What Range cannot be asked to do
It takes no target
A run accepts one thing: the id of a scenario already in the catalog. There is no field for a URL, a host, a command, a query or a script, so there is nothing to sanitise.
Scenarios are code
Each one is a versioned object in Sentinel's own source, reviewed and merged like any other change. There is no editor for scenarios at runtime.
Only its own fixtures
Scenarios run against Sentinel's own subsystems and fixtures, with safe test doubles in place of any third-party provider. No attack technique is published.
Named outcomes, no score
A result is held, degraded, failed or not run, and the gate is derived from the named results. There is no number summarising how secure anything is.
How the gate is kept honest
Every active scenario runs
Against one throwaway copy of the product, set up the same way the product is.
The gate is derived, strictly
From the named results with no risk acceptances, because CI holds none. That is the strictest reading.
A blocking entry fails the build
The script names each blocking scenario and exits with an error, so a red gate cannot be skimmed past.
The gate is itself tested
Mutation tests deliberately break a control. The scenario must then report failure rather than pass.
Probes leave nothing behind
A scenario that writes does so in a throwaway tenant, deleted when it ends. A real tenant's rows are untouched.
Signal path
What enters it, and what leaves.
Signals in
- Scenario definitions in Sentinel's own source
- Isolated fixtures and injected conditions
- The facts each scenario expects or prohibits
- Risk acceptances with an owner and an expiry
Range
VALIDATES THE ENTIRE LOOP
Outputs
- A named outcome per scenario: held, degraded, failed or not run
- Findings for each step
- Release gate entries: blocking or not, and why
- Preserved run records
Ten questions
Range, answered.
The questions every Sentinel system must answer, in the same order on every system page.
Range is Sentinel's validation system: a controlled proving ground that runs defensive scenarios, defined in Sentinel's own source, against Sentinel's own fixtures and subsystems.
- A release and protection qualification system, not a red-team game.
The controls that must hold when something goes wrong.
- Tenant isolation and session revocation
- Visibility loss, Ledger failure and evidence failure
- Provider failure and policy tightening mid-flow
- Safe Mode (recovery and control-plane scenarios are named categories, not yet in the catalog)
Versioned scenario definitions, reviewed and merged like any other code; the conditions each injects inside an isolated fixture; and the facts each expects or prohibits.
Whether each named scenario held, degraded, failed or was not run, and from those named results whether a release may proceed.
- blocking: a hard blocker with no override.
- acceptance: ships only with a named owner, a written acceptance and a remediation date.
Run scenarios on demand and in CI, record each run with its steps and findings, and block a release on a failed blocking scenario.
It accepts no URL, host, command or script from a caller, publishes no attack technique and is not an offensive capability.
- It states named outcomes, never a security score.
- It proves behaviour against Sentinel's own fixtures, not the configuration of an organisation's estate.
Named scenario results, their findings, and the release gate: which entries block and why, with any risk acceptance and its expiry.
Range exercises Guard, Watchtower, Evidence, Safe Mode and Continuity, preserves its own run records, and gates the release of the platform itself.
A scenario that cannot execute is reported as blocked or not run, never as passed, and the gate treats it as not passed.
The release gate runs as a build condition in CI against a throwaway copy of the product, and mutation tests show the gate turns red when a control is deliberately broken.
Relations
Where it connects.
- Guard Sends toRevocation, isolation and provider-failure scenarios
- Watchtower Sends toVisibility-loss scenarios
- Evidence Exchanges withLedger and evidence failure scenarios; run records kept
- Safe Mode Sends toSafe Mode state and enforcement scenarios
- Continuity Sends toRecovery scenarios (not yet in the catalog)
- Command Sends toNamed results and the release gate
- Sends to
- Receives from
- Exchanges with
- Outside Sentinel
Failure and health
When it fails, it says so.
In operation
Held
- Each scenario run in an isolated fixture
- Named results feed the gate
When it fails or loses visibility
Not run
- A scenario that cannot execute is never a pass
- The gate treats it as not passed
- A missing result is visible, not averaged away
Range states
- Held (lit: in operation)The control behaved as specified.
- DegradedThe control held only in part.
- FailedThe control did not hold.
- Not run (lit: on failure)No result. Never counted as a pass.
How its own health is verified
- The gate is a CI build condition
- Mutation tests prove the gate turns red
- Fixtures isolated from each other
The Sentinel system family
Ten systems, one institution.
Put Sentinel on guard
Choose the protection level built for where your company is today.
