Operational AI governance

Independent runtime authority · online

Run AI under law, not whim.

Aegis puts signed policy in the execution path of your AI agents—independently checking every action before it touches a tool, API, workflow, or record. Start with one workflow. Leave with regulator-ready proofs.

Book the 20-minute executive brief See the four-week proof

One workflow · four weeks Regulator-ready evidence pack Fails closed by default

tenant/acme · agent/sales-copilot
Runtime active
This action, right now
Allowedmapped · in bounds
31 msdecision overhead
Verifiedsigned authority
head: 0x7f3a…a91f · bundle: sha256:4c9e…d21b · verified ✓
ClauseCOMMS-4.2 · approved customer contact
Signeracme-kms/policy-authority-01
OutcomeAction executed · receipt written
Proofs, not promises.
SOC 2 Type IIControls independently examined
ISO/IEC 27001Certified information security management
ISO/IEC 42001Certified AI management system

Our mission

Make every consequential AI action answerable to law.

AI is crossing the line from recommendation to action. SPQR exists to ensure no consequential agent action executes without independently verified authority—and every decision leaves evidence a regulator, auditor, or board can inspect.

Policy before executionControl acts before the API, workflow, or record is touched.
Authority outside the modelThe system proposing the action cannot approve itself.
Proof after every actionEach verdict produces a signed, inspectable receipt.

The problem

AI systems are becoming action engines.

The system proposing an action should not be the only system deciding whether it is allowed. Context can inform. Logs can report. Neither can independently stop the action.

Not restraint

Prompts ask nicely.

Guardrails instruct the model. Aegis does not depend on the model's good behaviour—it verifies before execution.

Not retrieval

Context is not control.

RAG gives the model governed reading material. It still holds the pen. Aegis holds the authority to act.

Not after the fact

Logs cannot prevent.

Monitoring reports the breach. Runtime control decides before the API, workflow, or record is touched.

A field note from the future

The governance stack is prehistoric. The agents are not.

Documents, prompts, and after-the-fact logs were built for systems that waited for humans. Agentic AI does not wait. Governance has to move at runtime.Legacy era → operational authority

The four-week proof

One workflow. Four weeks. A decision your board can trust.

Not an open-ended transformation program. A fixed-scope proof that turns one consequential workflow into a governed, inspectable control pattern.

Week 01

Scope

Choose one consequential workflow. Map its operations, policy boundaries, owners, and failure conditions.

Week 02

Construct

Turn approved policy into a deterministic governance bundle, signed with your authority and scoped to the workflow.

Week 03

Enforce

Connect Aegis and run allow, deny, escalate, stale-policy, and fail-closed scenarios in the live execution path.

Week 04

Prove

Inspect the receipts, deliver the evidence pack, and make a clear decision on the next workflow and rollout path.

What you leave with

Defined outcome · no theatre
  • Signed governance bundle
  • Runtime integration pattern
  • Allow / deny / escalate receipts
  • Fail-closed evidence
  • Regulator-ready evidence pack
  • Pilot-to-rollout recommendation
Book the 20-minute executive brief

How it connects

Between intent and effect.

You do not rebuild your agents. Put Aegis at whichever seam you already control. Most teams begin with the SDK on one workflow.

01

Inline SDK

Wrap the tool call. Your agent asks Aegis can_i() before it acts and only proceeds on allow. Lowest latency, most precise scope.

02

Action gateway

Route tool and API traffic through the Aegis gateway. Actions are mapped and verified in transit with no agent code change.

03

Native connectors

Drop in to Copilot, Agentforce, and ServiceNow action hooks. Aegis registers as the authorisation step in the platform flow.

app.py · one guarded actionruntime verified ✓
# The agent proposes. Aegis decides before any effect.
from aegis import Runtime

aegis = Runtime(scope="org/acme/dept/sales/agent/copilot")
decision = aegis.check(action="send_email", target="customer")

if decision.verdict == "allow":
    tools.send_email(...)          # executes only here
elif decision.verdict == "escalate":
    approvals.request(decision.ticket)
else:
    raise BlockedByPolicy(decision.reason)  # fail closed

Scoped authority

A policy stack, not one flat file.

Each layer narrows the operating envelope for the one beneath it. Internal policy can add stricter local rules—it cannot silently weaken the baseline floor.

Platform baselineRegulation, standards, industry packsFLOOR
Organisation overlayCompany policies, controls, proceduresL2
Department overlayLocal rules, approvals, exceptionsL3
Agent / workflow scopeAllowed operations, trust region, runtime HEADL4
Aegis runtime authorityActive signed composition of the full stackHEAD ✓

Before runtime

Authority has to come from somewhere.

Praxis assesses and remediates organisational policy against the assigned regulatory baseline. Aegis verifies and enforces the approved authority at runtime.

Aegis should enforce authority the organisation has actually established and approved. It should never need to invent it.

PraxisEstablish and agree authority
→
AegisVerify and enforce authority
Explore Praxis Policy Assurance

Why it is different

Policy, where it can actually intervene.

Most platforms put policy around AI. Aegis puts policy in the execution path.

ApproachWhat it doesWhat Aegis does
Document repositoryStores policy textConstructs signed runtime authority
RAGRetrieves policy contextBuilds verified governance objects
GRC platformTracks controlsEnforces at the action boundary
Prompt guardrailsInstruct the modelVerifies before execution
LoggingRecords after the factControls before the action
Human approval flowDoes not scale aloneRoutes decisions by trust region

What you can prove later

Every governed action leaves a verifiable chain.

The claim is not “the AI was right.” It is that the system followed a reviewed, signed, active policy state—and you can inspect the receipt for any single action.

01

Policy in

Approved clause set, source-span mapped and digested.

sha256:4c9e…d21b
02

Signed

Deterministic bundle, hashed and signed with your key.

sig:0x7f3a…a91f
03

Verified

Runtime pointer checked live before any decision runs.

head@a91f ✓
04

Verdict

Allow, escalate, or deny with the mapped operation.

allow · 31ms
05

Receipt

What was touched, tied back to the signed state.

rcpt:9b2c…f04e

The proof artefact

Not a dashboard claim. A receipt.

Every governed action can be traced back to the exact authority active at the moment of execution.

  • Mapped operation and target
  • Applicable policy clause
  • Signing authority and active HEAD
  • Verdict, latency, and effect
AEGIS / DECISION RECEIPT / RCPT-9B2C-F04ESIGNATURE VERIFIED ✓
Decision at 14:07:31.204 AEDT

Action allowed.

Operationsend_email → customer
Decision time31 ms
Policy clauseCOMMS-4.2
Scopeorg/acme/dept/sales
Signing authorityacme-kms/policy-01
Effectexecuted · receipt written
head: 0x7f3a…a91f · bundle: sha256:4c9e…d21b · receipt: sha256:9b2c…f04e

Built for the whole decision

One control plane. Four reasons to care.

Aegis gives every member of the buying committee an answer in the language of their responsibility.

For Legal

Defensible authority—not another assurance promise.

Show which approved policy governed the action, which authority signed it, and what the system did before execution.

TraceableClause-to-action mapping
IndependentAuthority outside the model
DefensibleSigned decision receipts

Trust model

Who holds the keys—and what the signature actually protects.

A security product should not hand-wave its own security. Here is the threat model in plain terms.

SOC 2 Type II ISO/IEC 27001 ISO/IEC 42001 Your VPC or ours Zero action data retained by default

Custody

You hold the signing keys.

Governance bundles are signed with keys in your HSM or KMS. Aegis verifies signatures; it cannot forge authority it was not given.

What it stops

Tampered or stale policy.

A modified bundle, expired HEAD, or mismatched scope fails verification. The action cannot execute.

Failure mode

Fails closed. Always.

No valid signature, mapped operation, or trust region means no execution. Downtime blocks actions; it never opens them.

From proof to standard

Prove the control pattern once. Then scale it.

The four-week proof is not pilot theatre. It creates a reusable governance pattern for the next workflow, business unit, and enterprise rollout.

01

One workflow

Prove enforcement and evidence on a consequential action path with named owners and policy.

02

One business unit

Reuse the integration and governance pattern across adjacent agents, tools, and operational teams.

03

Enterprise standard

Establish Aegis as the independent runtime authority across agentic systems.

Who is accountable

Built by people who have owned enterprise control planes.

SPQR builds independent control infrastructure for agentic AI. We are a focused team out of Melbourne with backgrounds in policy compilation, distributed systems, and enterprise security engineering.

We do not sell another AI assistant. We sell the layer that decides what your assistants are allowed to do—and the evidence to prove it held.

  • Enforcement over persuasion—the model asks, Aegis decides.
  • Prove it or it did not happen—every decision leaves a receipt.
  • Fail closed, hold your own keys, retain nothing you do not need.

The next step

Prove one governed workflow end to end.

Choose a workflow. Upload the policies. Activate runtime authority, then run allow, deny, escalate, and fail-closed live. Inspect the chain.

Book the 20-minute executive brief

20-minute technical brief · bring one governed workflow · we show the chain