AXIS SENTINEL GUARDCore system
Policy, enforced at the boundary.
NOTHING CROSSES THE BOUNDARY WITHOUT AUTHORITY.
Guard is Sentinel's governed authorization and containment system. Every request passes identity, scope, policy and authority before a decision is made, and the strength of what Sentinel actually witnessed sets a ceiling on how hard it may respond.

- 01ObserveContinuous telemetry from every service and edge you connect.
- 02VerifyTelemetry checked at the gateway before it is trusted.
- 03DetectAnomaly, policy violation, and absent signal alike.
- 04ProtectPolicy enforced at the identity and tenant boundary. (Guard operates here)
- 05PreserveEvidence written down before it can be lost.
- 06RecoverContinuity coordinated, state restored, result verified.
Recover returns to Observe
Guard is where the loop acts: policy enforced at the identity, tenant and workspace boundary.

Doctrine
Four sentences, each enforced at a station.
They are Guard's own words, and each one is a check a request must pass. A station can narrow a request, hold it for proof, or end it.
- 03 PolicySecurity is active, continuous and policy-driven.
- 01 IdentityNothing crosses without identity.
- 02 ScopeNothing acts without scope.
- 04 AuthorityNothing escalates without authority.
The decision
Every request passes the same five stations.
Identity, scope, policy, authority, then a decision. Choose a request to see the record Guard writes for it, and where its path narrows, waits or ends. There are six decisions and no two share a shape.
Illustrative demonstration
Choose a request
The request
Allowed: Operator session
Add a note to an open incident in its own tenant.
- IdentityWho is asking?Who is askingOperator, signed inPassedThe session resolves to an authenticated operator, once, when it is loaded.
- ScopeWithin which boundary?Tenant and siteOwn tenant, from membershipPassedThe tenant comes from the operator's membership, never from the request.
- PolicyIs it permitted?PolicyIncident note, within the rolePassedAn incident note is within the role, and stays available under Safe Mode.
- AuthorityWho stands behind it?How it is known, and who authorized itRole is sufficientPassedThe role is sufficient. No elevation is asked for.
- DecisionWhat happens?DecisionAllowedAllowedAdmitted as asked. The note is written together with its audit entry, in one batch.
AllowedIdentity, scope, policy and authority all held.
The request
Constrained: Commander
Contain one source address across three sites.
- IdentityWho is asking?Who is askingCommander, signed inPassedA named commander, signed in.
- ScopeWithin which boundary?Tenant and siteThree sites, one without a zone assignmentNarrowedEach site must belong to the organisation and have a zone assignment. A site without one is not enforced.
- PolicyIs it permitted?PolicyOne address, a temporary rulePassedA temporary rule on a single address is within policy. The allowlist was checked first.
- AuthorityWho stands behind it?How it is known, and who authorized itCommander is enoughPassedCommander is enough for one address with an expiry.
- DecisionWhat happens?DecisionConstrainedConstrainedEnforced where it can be. The rule reads partial and names the site that did not take it.
ConstrainedAdmitted with a narrower scope than requested.
Scope of the claimNetwork containment is optional per deployment and needs a connected provider. The adapter is tested against the provider's real request shapes and has not been exercised against a live account.
The request
Challenged: Visitor on a protected site
Keep browsing, with a site-reported signal of automation on record.
- IdentityWho is asking?Who is askingVisitor, not establishedHeld for proofNot established. A public registration identifies a deployment, never a person.
- ScopeWithin which boundary?Tenant and siteSite from the verified originPassedThe site is resolved from the verified origin, not from the request body.
- PolicyIs it permitted?PolicyA site-reported signalHeld for proofA signal is on record. Its basis is the page's own report.
- AuthorityWho stands behind it?How it is known, and who authorized itCeiling: a challengeNarrowedA site-reported signal may justify at most a challenge. Repetition does not raise it.
- DecisionWhat happens?DecisionChallengedChallengedAsked to prove itself once. Nothing is removed, and a real visitor carries on afterwards.
ChallengedAsked to prove itself before it may continue.
The request
Revoked: Commander
Revoke a signed-in console session.
- IdentityWho is asking?Who is askingCommander, signed inPassedA named commander, signed in. The console refuses to revoke the commander's own session.
- ScopeWithin which boundary?Tenant and siteA live session in the same tenantPassedThe target is a live session in the same tenant. Any other session is not found.
- PolicyIs it permitted?PolicyNarrows access onlyPassedRevocation only narrows access, so it stays available under Safe Mode.
- AuthorityWho stands behind it?How it is known, and who authorized itCommander is the minimumPassedCommander is the minimum role.
- DecisionWhat happens?DecisionRevokedRevokedThe session's token stops working at its next request. The decision records who decided and why.
RevokedA session or credential withdrawn.
Scope of the claimThis ends a Sentinel console session. A session on a protected site is out of reach: that needs an application integration that does not exist.
The request
Contained: Commander
Hold an affected site while an incident is worked.
- IdentityWho is asking?Who is askingCommander, signed inPassedA named commander, signed in.
- ScopeWithin which boundary?Tenant and siteOne sitePassedA site: the narrowest scope that contains the incident. A tenant-wide hold would need an owner.
- PolicyIs it permitted?PolicySafe Mode is the mechanismPassedEngaging Safe Mode is the mechanism itself, so the state it sets does not hold it back.
- AuthorityWho stands behind it?How it is known, and who authorized itCommander, with a reasonPassedCommander for a site, a deployment or an incident. A reason is required.
- DecisionWhat happens?DecisionContainedContainedHigh-risk operations at the site are held. Identity, reads, evidence capture and incident response carry on. Not resolved: lifting is a separate, recorded decision.
ContainedSpread halted at the boundary. Not yet resolved.
The request
Refused: Workspace credential
Read another tenant's record by its identifier.
- IdentityWho is asking?Who is askingWorkspace credentialPassedThe credential is valid and authenticated.
- ScopeWithin which boundary?Tenant and siteAnother tenant: not foundStoppedThe tenant predicate does not match. The record is answered as not found, never as forbidden.
- PolicyIs it permitted?PolicyNot reachedNot reachedNothing was admitted to evaluate.
- AuthorityWho stands behind it?How it is known, and who authorized itNot reachedNot reachedNot reached.
- DecisionWhat happens?DecisionRefusedRefusedNot admitted. Nothing about the other tenant is revealed, and a request that cannot be evaluated is refused rather than allowed pending review.
RefusedNot admitted. The refusal is recorded.
Simulated requests, written to show how Guard decides. Nothing here reads or changes a live system.
The authority ceiling
Guard's autonomy is bounded by what Sentinel can prove.
The strength of the evidence sets how hard Guard may respond without a person. Repetition never raises it: reports from a page are still one page's opinion.

The column is Guard's authority ladder. A ring of light, the ceiling, lies at the highest response Guard may take without a person for the evidence it holds. Plates at or below it are lit champagne; plates above it keep a cool platinum line, because only a named person may take them. Reported or inferred: the ceiling lies at challenge. Reported again and again: points of light rise toward the ceiling and are absorbed at it, and it does not move. Server observed: the ceiling rises one rung, to throttle. Edge observed: the ring is dashed and the plates are ghosts, because no edge attestation path exists.
Reported or inferred. A site's agent said so, or Sentinel inferred it. Guard may observe and challenge on its own; anything above the ceiling waits for a named person.
- Reported or inferredReported or inferred. A site's agent said so, or Sentinel inferred it. Guard may observe and challenge on its own; anything above the ceiling waits for a named person.
- Reported, repeatedReported again and again. Repetition never raises the ceiling: reports from a page are still one page's opinion.
- Server observedServer observed. Sentinel witnessed it itself, so the ceiling rises one rung, to throttle. Throttle is in policy, but no provider can enact it today.
- Edge observedEdge observed. An edge could prove it cryptographically and the ceiling would reach block. No edge attestation path exists, so this level is not built.
- ObserveBuiltRecording what was seen. Always available.
- ChallengeBuiltAsks a source to prove itself once. Recoverable, and bounds who may pass.
- ThrottleBuilt, limitedIn policy, but no provider can enact a true throttle today. The adapter refuses rather than substitute a challenge.
- RestrictNot builtNo application integration exists to act through.
- Revoke sessionBuilt, limitedBy a named commander, on a Sentinel console session. A session on a protected site is out of reach.
- BlockBuilt, limitedAutonomous block needs edge attestation, which is not built. A commander may block one address for a limited time, through a provider.
Beyond the ceiling, a person
Guard
Within the ceiling
- Challenge a source on inferred or site-reported evidence.
- Throttle on server-observed evidence, in policy, where a provider can enact it.
- Refuse what cannot be evaluated.
Commander
A named person
- Revoke a Sentinel console session.
- Contain one address, with an expiry, through a provider.
- Engage Safe Mode at a site, a deployment or an incident.
Owner
A named owner
- A permanent rule, a range of addresses or a tenant-wide rule.
- Override the allowlist.
- Engage Safe Mode across the tenant, or rotate a provider credential.
The allowlist is checked before authority, so an owner's own monitoring is never contained. A request above a role's reach is refused before any provider is touched.
Every response at every strength of evidence
Governed containment
A path narrows. It does not snap shut.
One credential anomaly, followed from the first decision to the operator's view. Each step is marked with what the repository does today, because a demonstration must not imply more than exists.
Illustrative demonstration
Credential anomaly, contained



In the repository today
First Light admits and attests every observation, and Guard reads how strongly it is known. Automated credential-anomaly detection is not claimed: an operator declares the incident, and the credential-compromise playbook recommends the sequence.
Tenant isolation is enforced in every read and write. Holding one session short of revoking it, the Restrict rung, has no application integration today.
An owner lowers a member's role. Under Safe Mode that needs a fresh password confirmation, so a stolen owner session cannot strip the real administrators.
A commander revokes a Sentinel console session, effective at its next request. A session on a protected site is out of reach: that needs an application integration that does not exist.
A commander requests a rule through the provider. It reads pending until the provider confirms, and failed if it does not. Optional per deployment, tested against real request shapes, not yet exercised against a live account.
A decision and the action it authorised commit in one batch, so neither exists without the other. Preserving the surrounding evidence is a commander's action.
Watchtower runs every minute, whether or not anyone has Command open. Guard does not call it: the confirmation is Watchtower's own next pass. Silence would be raised as lost visibility, not read as calm.
Command reads the incident's status (active, contained, closed), the rule's state and the authority behind each action. This page is a demonstration, not a live console.
Step 8 of 8
Command shows containment
The incident reads contained, the rule reads confirmed, and each action names the authority it required. A person sees, understands, authorizes, acts and verifies.
A privileged credential is used from a source its session has never used. The observation is admitted with how it is known: site reported, server observed or inferred.
The affected session can reach only its own tenant. Guard does not widen it, and a request across the boundary is answered as not found.
The role is lowered. The session keeps read access to what it already held; write and privileged operations leave its reach.
The session's token is revoked and stops working at its next request. The decision is Revoked, and it records who decided and why.
The paths the session could use sideways close. Containment of the source is requested, and a path is shown closed only when it is confirmed.
Every decision so far is already in the Ledger, written in the same batch as the change, with its justification attached.
Containment must not blind Sentinel. Watchtower's next scheduled pass reads the reports again, and telemetry from the contained scope is still arriving.
The incident reads contained, the rule reads confirmed, and each action names the authority it required. A person sees, understands, authorizes, acts and verifies.
Simulated states, written to show how Guard contains. Nothing here reads or changes a live system. The order follows the story: the repository's credential-compromise playbook recommends preserving evidence before anything is rotated or revoked.
Each step against the repository
- Credential anomaly detectedPartly builtFirst Light admits and attests every observation, and Guard reads how strongly it is known. Automated credential-anomaly detection is not claimed: an operator declares the incident, and the credential-compromise playbook recommends the sequence.
- Session isolatedPartly builtTenant isolation is enforced in every read and write. Holding one session short of revoking it, the Restrict rung, has no application integration today.
- Privilege narrowedBuilt, by a personAn owner lowers a member's role. Under Safe Mode that needs a fresh password confirmation, so a stolen owner session cannot strip the real administrators.
- Token revokedBuilt, by a personA commander revokes a Sentinel console session, effective at its next request. A session on a protected site is out of reach: that needs an application integration that does not exist.
- Lateral path closesBuilt, provider confirmsA commander requests a rule through the provider. It reads pending until the provider confirms, and failed if it does not. Optional per deployment, tested against real request shapes, not yet exercised against a live account.
- Event preservedBuiltA decision and the action it authorised commit in one batch, so neither exists without the other. Preserving the surrounding evidence is a commander's action.
- Watchtower confirms telemetry remainsBuiltWatchtower runs every minute, whether or not anyone has Command open. Guard does not call it: the confirmation is Watchtower's own next pass. Silence would be raised as lost visibility, not read as calm.
- Command shows containmentBuiltCommand reads the incident's status (active, contained, closed), the rule's state and the authority behind each action. This page is a demonstration, not a live console.

Signal path
What enters it, and what leaves.
Signals in
- Attested observations admitted by First Light
- Operator sessions, roles and tenant membership
- Policy, the owner's allowlist and Safe Mode scope
- Provider confirmations of network rules
GuardPROTECT
Outputs
- A decision for each request: allowed, constrained, challenged, revoked, contained or refused
- Containment requests to a network provider
- A Ledger entry for every decision, written with the change
- Containment state for Command
Ten questions
Guard, answered.
The questions every Sentinel system must answer, in the same order on every system page.
Guard is Sentinel's enforcement system: it decides what an identity, a session or a workload may do at the boundary, and records each decision as it makes it.
- A governed authorization and containment system, not a firewall.
- Every decision carries its justification into the Ledger.
The boundaries an incident tries to cross.
- Identity boundaries and tenant and workspace isolation
- Privileged sessions and operator authority
- Execution limits and network containment rules
- Session revocation and anomalous behaviour
Observations First Light has admitted and attested, operator sessions and their roles, policy, the owner's allowlist and what a network provider confirms.
Whether a request is admitted, and how strongly Sentinel may respond. The strength of the evidence sets a ceiling: an inferred or site-reported signal may justify a challenge, a server-observed one a throttle, and anything stronger needs a named person.
- Repetition never converts a weak signal into a strong one.
- The allowlist is checked before authority, so an owner's own monitoring is not contained.
Refuse a cross-tenant request at the data path, revoke a Sentinel console session, hold an operator to their role, challenge a source within its ceiling, and request containment of an address through a provider.
It cannot act harder than its evidence allows, and it does not block traffic itself.
- A browser's report never justifies more than a challenge.
- A rule is active only once the provider confirms it.
- A CIDR range, a permanent rule or a tenant-wide rule always needs an owner.
- Autonomous blocking is not possible today: it would need edge attestation, which is not built.
Design directionNo provider supports a true throttle today, and a session on a protected site cannot be ended without an application integration that does not exist. Guard says so rather than substituting something weaker.
Each decision with its justification, the rule state as the provider reports it (pending, active, failed or still enforced) and the authority each action required.
Guard acts on what First Light admitted, writes every action to Evidence, holds high-risk operations while Safe Mode is engaged, and is exercised by Range. Watchtower confirms telemetry continues once containment holds.
Guard fails closed. A decision that cannot be evaluated is refused, not allowed pending review.
- An unreachable provider leaves a rule failed, never shown as active.
- A rule the provider will not release stays shown as still enforced.
Range runs session revocation, tenant isolation, policy tightening and provider failure scenarios against Sentinel's own fixtures, and a failed blocking scenario blocks the release.
- Provider state is read back from the provider, never assumed.
Relations
Where it connects.
- Receives fromFirst LightAttested observations; the attestation bounds the response
- Sends toEvidenceEvery decision and containment, recorded in the same write
- Receives fromWatchtowerConfirmation that telemetry continues after containment
- Exchanges withSafe ModeHigh-risk operations held within the engaged scope
- Receives fromRangeRevocation, isolation and provider-failure scenarios
- Sends toCommandDecisions, containment state and the authority each required
- Exchanges with, outside SentinelNetwork providerRule requests out; confirmation or refusal back
Failure and health
When it fails, it says so.
In operation
Enforcing
- Every request evaluated on the request path
- Rules active only on provider confirmation
When it fails or loses visibility
Fails closed
- A decision that cannot be evaluated is refused
- Unreachable provider: rule failed, never active
- A rule the provider keeps stays shown as enforced
Guard states
- AllowedIdentity, scope, policy and authority all held.
- ConstrainedAdmitted with a narrower scope than requested.
- ChallengedAsked to prove itself before it may continue.
- RevokedA session or credential withdrawn.
- ContainedSpread halted at the boundary. Not yet resolved.
- RefusedNot admitted. The refusal is recorded.
- Enforcing (lit: in operation)
- Fails closed (lit: on failure)
How its own health is verified
- Range: revocation, isolation, policy tightening, provider failure
- Provider state read back, not assumed
- A failed blocking scenario blocks the release
The Sentinel system family
Ten systems, one institution.
Put Sentinel on guard
Choose the protection level built for where your company is today.
