How CAE Governance Works: Seven Concepts, One Control Loop
A visual, in-depth guide to how Contextual Agentic Enterprise governance works. Seven concepts (Context Contract, Evidence Bundle, Deterministic Shell, Policy and Invariants, Delegated Authority and Escalation, Evidence Ledger, CAE Ops), what each one is for, who owns it, what it prevents, and how they combine into a single control loop around every agent decision.
Written as at 24 September 2026.
caeai-governancecontext-contractevidence-bundledeterministic-shelldelegated-authorityaudit-ledgercae-opspolicy-as-codeagent-governance
About this article
This article explains how governance works in the Contextual Agentic Enterprise (CAE). It takes seven concepts, shows what each one is for, who owns it and what it prevents, and then follows one decision through all of them. The companion formal paper defines the parts precisely. This article is the working picture: the poster below is the one-page version, and the rest of the article is the explanation behind it.
The scenario used throughout is fictional: a turbine on an industrial site raises a vibration alarm at 01:40. Every figure in it is a reference parameter chosen for illustration, and the real limits, windows and approvals belong to each enterprise.
Summary for busy readers
An AI agent is good at reading a messy situation and proposing a sensible action. It is not a safe place to keep authority, because its output varies, it can be wrong with confidence, and it can be steered by what it reads. CAE therefore splits every consequential decision in two. The agent thinks and proposes. A small, non-AI shell checks the proposal against signed facts and written rules, and is the only thing allowed to write to the system of record. Seven concepts make that split work.
| # | Concept | One-line meaning | Question it answers |
|---|---|---|---|
| 1 | Context Contract | A signed, time-bound snapshot of the facts a decision depends on | What may the agent know, and how fresh is it? |
| 2 | Evidence Bundle (MAEB) | The package an agent submits instead of an action | What must the agent prove? |
| 3 | Deterministic Shell | A non-AI function that commits or escalates, and alone holds write credentials | Where does authority live? |
| 4 | Policy and Invariants | The conditions that must hold before any change commits | What is the shell enforcing? |
| 5 | Delegated Authority and Escalation | Limits on what agents may do alone, and a routed path above them | Who may decide what? |
| 6 | Evidence Ledger | A hash-chained record of every decision | What can the auditor replay? |
| 7 | CAE Ops | The operating model that keeps the loop dependable | How does it stay reliable over time? |
Together they give an enterprise five things it can state and test: facts that are grounded, authority that is bounded, decisions that are explainable, an audit trail that can be replayed when the inputs, policy and versions are retained, and controls that stay in place whichever model is running (the quality of its proposals still has to be evaluated). They do not make an agent’s diagnosis correct. They make an incorrect or manipulated proposal unable to commit outside the limits the enterprise has set.
Part 1: Why trace is not enough
Most AI governance today is observability: log the prompts, log the tool calls, keep the trace. That is useful and it is not governance. A trace tells you afterwards what an agent did. It does not stop the action, it does not say who had the authority to take it, and it does not show whether the facts the agent used were true at the time.
Governance asks different questions, and they are the seven in the table above. Was the agent working from authoritative, current facts? Did it show its reasoning in a form someone can check? Was the action within what it was allowed to do alone? Who approved it when it was not? Can we re-derive the decision later, and can we show the record has not been changed? A trace answers none of these reliably, because the trace is produced by the same system whose behaviour is in question.
CAE answers them structurally rather than by inspection. The facts are signed before the agent sees them. The agent’s proposal is a data package the shell can test. The shell is ordinary deterministic code that can be tested like any financial control. The record is chained and anchored outside the system. The design principle is old: Saltzer and Schroeder named it complete mediation, every access checked against authority, with fail-safe defaults and least privilege (Saltzer and Schroeder, 1975). CAE applies it to agents.
Part 2: The seven concepts
2.1 Context Contract: what the agent may know
What it is. A Context Contract is a signed snapshot of the facts a decision depends on. In the formal model it has four parts: a state projection S (the facts, drawn from systems of record), a snapshot time T with a freshness bound, a hash H computed over canonical JSON, and a signature by a contract compiler. Canonicalisation follows RFC 8785 so that the same facts always produce the same hash.
Why it exists. Agents otherwise reason from whatever they retrieved: a cached document, a stale dashboard, a value pasted by a user. The contract replaces “whatever the agent found” with “the context the enterprise has authorised, as at this moment, signed”. A signature establishes where the context came from and that it has not changed; it does not prove the source data is accurate, so source quality stays with the data owner. The contract is also read-only for the agent. The agent can read the contract; it cannot alter it, and it cannot replace it with facts of its own.
How it works. A separate contract compiler pulls the needed state from authoritative sources, stamps the time, hashes it and signs it. The shell later checks the signature, the hash, that the time is not in the future, and that the contract is inside the freshness window (15 minutes in the reference model).
Example (fictional). At 01:41 the compiler snapshots turbine telemetry (vibration 7.2 mm/s, having crossed its threshold at 01:40), spare-part stock (three bearings), and the supervisor’s autonomous limit (25,000). The contract is signed and is six minutes old when the shell sees the proposal, inside its 15-minute window.
2.2 Evidence Bundle: what the agent must prove
What it is. The Minimum Action-Evidence Bundle (MAEB) is what an agent submits instead of performing an action. In the formal model it has five parts: an idempotency key ι, lineage Λ (the contract hash it was built on and which agents and models took part), evidence E (cited metrics and references), the proposed change Δ, and a justification Φ (cost, avoided loss, effect on safety stock). A bundle compiler signs it.
Why it exists. It turns “the agent wants to do something” into a structured, checkable claim. Because it is data, not an action, nothing happens when it is created. Because it names its contract, it cannot be reused against different facts. Because its evidence must re-derive from the contract, a claim the contract does not support cannot pass.
How it works. Two checks tie it to the contract, shown below. Binding requires that the bundle’s recorded contract hash equals the contract’s hash. Groundedness requires that every value the bundle cites can be re-derived from the contract’s state. A fluent but unsupported claim, such as a reading the agent made up, fails groundedness.
Example (fictional). The agent proposes: reduce speed to 85 percent, reserve one bearing, schedule replacement at 06:00. Cost 12,400 against an avoided loss of 180,000. Every number it cites is in the contract.
2.3 Deterministic Shell: where authority lives
What it is. The shell is a non-AI function that takes a contract and a bundle and returns one of two outcomes: Commit or Escalate. It is the only component with write credentials to the system of record. In the formal paper it is total (it always returns an outcome), fail-closed (an unforeseen error yields Escalate, never Commit), and reason-complete (every Escalate says why).
Why it exists. If the agent can write, the system is only as safe as the model on its worst day. If only the shell can write, the safety of every write rests on the shell, its policy and its inputs, which are small, testable and do not vary with the model. This is also why the guarantees do not depend on which model runs: the shell never asks the model whether it is right.
How it works. The shell runs five ordered stages, shown below. V1 checks the schema. V2 checks contract validity: hash, signatures, not future-dated, within the freshness window. V3 checks binding and groundedness. V4 checks the invariants and the delegated authority limit. V5 performs the idempotent atomic commit. Any failure ends in Escalate with a reason code. The reason code separates two cases: an invalid or prohibited request, which writes nothing and is returned with its reasons, and a request that needs authority, which is routed with its evidence to an accountable person. Both are recorded.
Example (fictional). Contract fresh, bundle bound and grounded, cost inside the limit, stock intact, speed in band: V1 to V4 pass and V5 commits in one transaction.
Reference reason codes. The reference shell in the companion materials uses codes such as V1:schema, V2:stale, V2:contract-hash, V2:bundle-signature, V3:binding, V3:ungrounded:
Relation to existing practice. The shell is a policy enforcement point in the sense used in zero-trust architecture (NIST SP 800-207): never trust the requester by default, decide at a single enforced point. What CAE adds is the signed context, the evidence requirement and the replay property.
2.4 Policy and Invariants: the rules the shell enforces
What it is. Policy is the set of conditions that must hold before any change commits. Invariants are the ones that may never be broken by any authority level. In the turbine scenario there are five: φ_tel (the excursion is real and current), φ_doa (cost is within the delegation limit and below the avoided loss), φ_inv (safety stock is not breached: reserving one of three bearings leaves two, the safety stock), φ_op (operating speed stays in the 80 to 100 percent band) and φ_bom (the parts and bill of materials are valid for the asset).
Why it exists. Risk appetite is usually written in documents and applied by judgement. Policy as code makes it explicit and testable: the same rule gives the same answer every time, and a change to it is visible. General-purpose policy languages such as Open Policy Agent’s Rego and the Cedar language can express such rules, and the provider-neutral mapping paper discusses where each fits.
How it works. Policy is versioned, tested and approved like any other controlled change. The version in force is recorded on every ledger entry, so a later reviewer knows which rules a decision was made under. Changing an invariant is not something an agent or the shell does; it is a separate human process.
Example (fictional). The excursion is real; the 12,400 cost is within the limit and below the 180,000 avoided loss; reserving one bearing leaves two; 85 percent is inside 80 to 100. All five invariants hold.
2.5 Delegated Authority and Escalation: who may decide what
What it is. Delegated authority is the limit on what an agent may commit alone. Escalation is the routed path to an accountable person for everything above it. The limit is a property of the workflow and the owner who set it, not of the agent.
Why it exists. The hardest governance question about agents is not “is it accurate” but “who is accountable when it acts”. Delegation answers it by making the limit explicit and by naming the person above it. Escalation answers the matching question: what happens when the proposal is above the limit? It is not an error. The shell routes it, with its evidence and reasons, to the person who holds that authority.
How it works. The ladder below shows it. Within the agent’s limit and with every invariant holding, the shell commits. Above the limit, the shell escalates upward to the supervisor, the plant lead or higher, with the bundle attached. No tier, including the highest, commits a change that breaks an invariant through the shell. Changing an invariant is a policy change.
Example (fictional). A 45,000 spare-parts order exceeds the 25,000 limit. The shell escalates to the plant lead with the reasons. The plant lead approves or rejects, and the decision is recorded.
Autonomy is earned, not assumed. The formal paper pairs delegation with two practices. CSI admission (a threshold of 0.85 in the reference model) decides whether a workflow’s context is good enough to admit it to autonomy at all. Agentic Flow Mining examines recorded decisions to see where autonomy is justified, and withholds it where decisions depend on judgement that is not recorded anywhere. Limits widen per workflow, from evidence.
2.6 Evidence Ledger: what the auditor can replay
What it is. The ledger is an append-only, hash-chained record of every decision, whether commit or escalation. Each entry stores the bundle, the contract hash, the policy version, the outcome and the previous entry’s hash.
Why it exists. An auditor needs more than “the agent did this”. They need what it saw, what it proposed, which rules applied, who approved, and confidence that none of it has been changed since.
How it works. Entries are chained, so altering any one changes every later hash. The latest hash is periodically anchored outside the system’s administrative control, in the style of transparency logs (RFC 6962) and the tamper-evident logging designs in the literature (Crosby and Wallach, 2009). Replay means re-running the recorded bundle, contract and policy version through the same shell and checking the outcome matches.
What it does and does not claim. It is tamper-evident, not tamper-proof and not Byzantine fault tolerant. It shows that a record was altered; it does not prevent an operator with enough access from trying. What is reproducible is the decision, meaning the shell’s outcome on the recorded inputs, not the language model’s wording, which may differ on a re-run. The guarantee does not rest on the model repeating itself.
2.7 CAE Ops: how it stays dependable
What it is. CAE Ops is the operating model that runs the loop in production. It has six disciplines: contract ops, policy ops, agent ops, escalation ops, evaluation ops and evidence ops.
Why it exists. The loop is only as reliable as the routines around it. Sources drift, keys expire, policies go stale, models are swapped, approver queues back up, and nobody notices because each part still “works”. CAE Ops gives those routines owners and measures.
How it works. The six disciplines are shown below. Contract ops keeps sources, freshness and signing keys healthy. Policy ops versions, tests and approves limits and invariants. Agent ops keeps the register of agents, their least privilege and their model changes. Escalation ops watches queues, response times and approver capacity. Evaluation ops runs shadow comparisons and tracks the escalation rate and the ungrounded-fact rate. Evidence ops anchors the ledger, samples replays and handles audit requests.
Example (fictional). After a model swap, CAE Ops runs the new model in shadow alongside the old one, compares escalation and ungrounded-fact rates over a period the owner sets, and only then extends the new model’s authority. Because the shell’s guarantees do not depend on the model, the swap does not require redesigning the controls; it requires evidence that the new model is useful within them.
Part 3: How they work together
The concepts are not a menu. They are one loop, and each is incomplete without the others. A contract with no shell is a signed document nobody enforces. A shell with no policy has nothing to enforce. Policy with no authority model cannot say who may approve. A ledger with no contract records decisions without the facts behind them. CAE Ops with nothing to operate is an organisation chart.
3.1 One decision, end to end
The timeline below follows the turbine decision through all seven concepts.
- 01:40 to 01:41, contract. The alarm fires. The contract compiler snapshots and signs the facts.
- 01:42, bundle. The agent reads only the contract and builds the bundle: 85 percent speed, reserve one bearing, replace at 06:00, cost 12,400.
- 01:42, shell. V1 to V3 confirm the bundle is well formed, the contract is valid and fresh, and every cited value is grounded in it.
- 01:42, policy and authority. V4 confirms the invariants hold and the cost is inside the 25,000 limit.
- 01:42, commit and record. V5 commits atomically. The ledger appends the bundle, the contract hash, the policy version and the outcome.
- Ongoing, CAE Ops. Rates are tracked, a sample is replayed, and any limit change goes to the owner as a policy change.
3.2 Same loop, different inputs
The strength of the design is what happens when the inputs are worse. Four variations show it.
The cost is 45,000. V4 passes the invariants but the authority test fails. The outcome is Escalate to the plant lead, with the bundle and reasons. A person decides, and the decision is recorded. Nothing commits automatically.
The contract is 20 minutes old. V2 fails because the contract is past the 15-minute window. The outcome is Escalate with reason V2:stale. The agent must request a fresh contract. Nothing commits on old facts.
The agent asserts a value it invented. V3 fails because a cited reading cannot be re-derived from the contract. The outcome is Escalate with reason V3:ungrounded. A plausible, confident claim with no support cannot commit. This is the control that matters most against hallucinated or injected values.
An auditor asks why. The recorded bundle, contract and policy version are replayed through the same shell, and the outcome is compared with the ledger entry. This works when the contract, bundle, policy version and reference data were retained; external state and side effects are not reproduced. The hash chain and the external anchor show whether any record changed.
3.3 The same loop in other workflows
The pattern is not specific to turbines. The table shows three other workflows through the same seven concepts. All values are illustrative.
| Concept | Customer refund | Privileged access request | Production change |
|---|---|---|---|
| Context Contract | Order, payment and refund-policy state at T | Requester role, resource classification, approver chain | Current configuration hash, change window, dependency health |
| Evidence Bundle | Amount, reason code, cited order lines | Role requested, duration, justification ticket | Diff, rollback plan, test evidence |
| Policy and Invariants | Refund no greater than the amount paid; one refund per order | Requester is not the approver; no standing admin | No change inside a freeze window; rollback tested |
| Delegated Authority | Agent up to 100, team lead up to 1,000, above that finance | Agent grants read; manager approves write; CISO approves admin | Agent for low-risk configuration; change board for the rest |
| Evidence Ledger | Decision with order snapshot hash | Grant with approver and expiry | Change with diff hash and result |
| CAE Ops measure | Escalation rate, reversed refunds | Grants never used, expired-grant clean-up | Change failure rate, rollbacks |
Part 4: Who owns what
Each concept has an accountable owner. The assignment below is illustrative; the point is that none of the seven is left as “everyone’s job”.
| Concept | Typical accountable owners | What they answer for |
|---|---|---|
| Context Contract | Data owner and platform team | Source authority, freshness bound, signing keys |
| Evidence Bundle | Agent and model owner | What the agent must cite; how lineage is recorded |
| Deterministic Shell | Platform engineering and security | Correctness, testing and write-credential custody |
| Policy and Invariants | Risk and business owner | Rules, thresholds, version approval |
| Delegated Authority and Escalation | Business owner and board | Limits, named approvers, escalation response |
| Evidence Ledger | Audit and the CISO | Retention, anchoring, replay sampling |
| CAE Ops | CAE Ops lead | Routines, measures, change control across all of the above |
Two separations are worth stating plainly. The person who sets a limit should not be the agent’s operator. And the team that runs the shell should not be able to alter the ledger’s anchor.
Part 5: What each concept prevents
The matrix below maps common failure modes to the concept that stops them. A filled circle is the primary control and an open circle a supporting one. It is an editorial judgement, not a measurement.
Three readings are useful. Stale data and invented values are stopped mainly by the contract and the bundle, with the shell as the enforcer. Over-limit and unsafe changes are stopped by policy and authority, with the ledger as the witness. Drift, whether of models, policies or autonomy itself, is mainly a CAE Ops problem, which is why that concept exists.
Part 6: What this does and does not guarantee
The formal paper states the guarantees as results under stated assumptions. In plain terms:
- Invariant preservation (Theorem 1). Any change committed through the shell satisfies the invariants, assuming the shell is the only writer.
- Agent-independence (Proposition 2). The shell’s outcome on a given contract and bundle does not depend on which agent or model produced the bundle.
- Replay determinism (Proposition 3). Re-running a recorded decision with its recorded inputs, policy and versions yields the recorded outcome. External state and side effects are not reproduced.
- Tamper evidence (Theorem 4). Altering a recorded entry is detectable by chain verification, given the anchor.
These rest on three assumptions the enterprise has to earn. A1, capability confinement: no agent has any other path to write. A2, cryptographic soundness: signatures and hashes hold and keys are protected. A3, policy correctness: the written rules are the rules the enterprise actually wants.
What is not guaranteed. A signature shows provenance and integrity, not accuracy, so inaccurate source data still produces an inaccurate contract. The guarantees also depend on complete mediation (A1) and a correct implementation. The diagnosis may be wrong: if the agent proposes a sensible-looking but unnecessary repair that fits within every rule, the shell will commit it. The guarantee is that the damage is bounded by the limits, not that the choice is optimal. Policy errors (A3) pass through the shell faithfully. Escalation load is a real cost: too many escalations overwhelm approvers and push people to approve without reading. The design adds latency that makes it unsuitable for sub-second control loops. The ledger is tamper-evident, not Byzantine fault tolerant. The data in this article and the paper’s results are constructed for illustration, and the parameters (a 15-minute window, a 0.85 admission threshold, a 25,000 limit) are reference values that each enterprise must tailor.
Part 7: The data-governance foundation underneath
Readers who know data governance will recognise the older layers CAE sits on: the business glossary, the ontology, the data dictionary, the data model, the catalog and lineage. They are not replaced. They are what feeds the Context Contract. The state projection S is only as good as the authoritative sources, definitions and lineage behind it. If the enterprise has two definitions of “active customer” or “safety stock”, the contract inherits the disagreement and the shell will enforce whichever one the policy happens to encode.
Put differently, data governance decides what a fact means and where it comes from. CAE governance decides what an agent may do with the facts. Neither substitutes for the other, and a CAE programme that skips the first will find the second brittle.
Part 8: How to start
- Pick one workflow where the system of record is clear, the action is reversible or bounded, and an accountable owner exists. Avoid starting where decisions depend on unrecorded judgement.
- Define the contract. List the facts the decision needs, their authoritative sources and the freshness the decision tolerates.
- Write the invariants and the limit in plain language with the owner, then as code, with tests.
- Build the shell first, in shadow. Let agents propose and let the shell decide, but do not yet commit. Compare its outcomes with what people actually did.
- Turn on the ledger and anchoring before any live commit.
- Commit inside a small limit. Widen it per workflow only when the recorded evidence supports it.
- Stand up CAE Ops from day one: an owner for each of the six disciplines, with a short list of measures, such as the escalation rate, the ungrounded-fact rate, contract staleness at decision time and approver response time.
Part 9: Technical reference
This part gives the mechanics in enough detail to build a prototype. The field layouts, code and policy below are illustrative sketches written for this article, not the normative schema of the formal paper; the guarantees they support are the paper’s. The poster summarises the same material.
9.1 Artefact layouts (illustrative)
// Context Contract C = <S, T, H, sigma>
{
"state": { "telemetry": {"vibration_mm_s": 7.2}, "stock": {"bearings": 3, "safety": 2},
"limits": {"autonomous_usd": 25000}, "speed_pct": 100 },
"t": "2026-11-06T01:41:00Z",
"tau_s": 900,
"hash": "sha256:<hex of SHA-256(JCS({state,t}))>",
"sig": { "kid": "contract-compiler-2026-11", "alg": "ES256", "value": "<base64url>" }
}
// Evidence Bundle M = <iota, Lambda, E, Delta, Phi>
{
"iota": "0192f3a0-7c1e-7b2a-9d4f-5e6a1b2c3d4e",
"lineage": { "contract_hash": "sha256:<same as C.hash>", "agents": ["diagnose-v4"], "model": "<id>", "prompt_hash": "sha256:<hex>" },
"evidence":[ {"metric": "vibration_mm_s", "value": 7.2, "ref": "state.telemetry.vibration_mm_s"} ],
"delta": { "cmd": "set_speed", "speed_pct": 85, "reserve_bearings": 1, "work_order_at": "06:00", "cost_usd": 12400 },
"phi": { "avoided_loss_usd": 180000 },
"sig": { "kid": "bundle-compiler-2026-11", "alg": "ES256", "value": "<base64url>" }
}
Two details matter. The bundle’s evidence[].ref is a path into the contract, which is what lets the shell re-derive each cited value mechanically (groundedness). And delta is a typed command from a closed set, so the shell evaluates a structure rather than interpreting prose.
9.2 The shell as a function
def f_shell(C, M, P, D, now, store):
try:
v1_schema(C, M) # V1:schema
v2_contract(C, M, now) # V2:contract-hash, signature, future-dated, stale, bundle-signature
v3_binding_and_grounding(C, M) # V3:binding, V3:ungrounded:<metric>, V3:bad-reference
violated = P.invariants(C.state, M.delta) # V4: every phi evaluated, none skipped
if violated:
return Escalate(reasons=sorted(violated)) # phi_tel, phi_doa, phi_inv, phi_op, phi_bom
if P.psi(M, D): # V4: authority trigger
return Escalate(reasons=["psi:cost-above-limit"])
return store.commit_once(M.iota, M.delta, entry(C, M, P)) # V5: one transaction
except StageFailure as f:
return Escalate(reasons=[f.code])
except Exception as e: # fail-closed
return Escalate(reasons=[f"fail-closed:{type(e).__name__}"])
commit_once writes the change and the ledger entry in a single serialisable transaction under a unique constraint on iota. A second submission of the same bundle hits the constraint and returns the recorded outcome (reason code V5:replay), so retries cannot double-apply. Because the function returns only Commit or Escalate, and every path through it either completes V1 to V5 or returns Escalate, the property that no write happens outside it rests on credentials (assumption A1), not on the code being careful.
9.3 A policy fragment (illustrative Rego)
package cae.turbine
import rego.v1
violations contains "phi_inv" if {
input.contract.state.stock.bearings - input.bundle.delta.reserve_bearings < input.contract.state.stock.safety
}
violations contains "phi_op" if { input.bundle.delta.speed_pct < 80 }
violations contains "phi_op" if { input.bundle.delta.speed_pct > 100 }
psi contains "psi:cost-above-limit" if {
input.bundle.delta.cost_usd > input.contract.state.limits.autonomous_usd
}
With the example values, 3 - 1 = 2 is not below the safety stock of 2, 85 is inside the band, and 12400 is not above 25000, so both sets are empty and the shell proceeds to V5. The same rules in the Cedar language, or as database constraints, would behave identically; what matters is that they are versioned, unit-tested against fixtures and signed when deployed.
9.4 The ledger and its verification
Each entry carries n, iota, the contract hash, a digest of the bundle, the policy version, the outcome and reasons, and a timestamp. The chain is h_n = SHA-256(h_(n-1) || JCS(entry_n)). Verification and replay are short procedures:
def verify_chain(entries, anchors):
h = GENESIS
for e in entries:
h = sha256(h + jcs(e.body))
if h != e.hash: return Fail("chain-broken", e.n)
for a in anchors: # published outside the system's admin domain
if entries[a.n].hash != a.hash: return Fail("anchor-mismatch", a.n)
return Ok()
def replay(e, store):
C, M, P_v = store.load(e.contract_hash), store.load(e.bundle_digest), policy_at(e.policy_version)
return f_shell(C, M, P_v, D_at(e.t), e.t, dry_run_store(e)) == e.outcome
Altering entry k changes every hash from k onwards, so the chain breaks unless the attacker also rewrites every later entry and every anchor; anchoring outside the operator’s domain is what makes that second step hard. As the formal paper states, this gives tamper evidence, not prevention, and the ledger is not Byzantine fault tolerant.
9.5 Operating measures and example thresholds
| Measure | What it detects | Example action on breach (reference) |
|---|---|---|
| Contract age at decision, p95 | Slow sources or a stalled compiler | Alert at half the freshness bound; page at the bound |
| Ungrounded-fact rate | Agent or prompt regression, injected values | Freeze the agent’s autonomy; revert to escalate-all |
| Escalation rate and approver response time | Limit set too low, queue overload, rubber-stamping | Review the limit; add approver capacity |
Shell exception rate (fail-closed:*) |
Bugs, bad inputs, dependency failures | Investigate before widening limits |
| Anchor lag and chain verification result | Missed anchors, tampering | Incident |
| Replay-sample pass rate | Drift between shell, policy and records | Stop policy activation; investigate |
The thresholds are examples. Each enterprise sets its own from baseline data collected in shadow mode.
Glossary
| Term | Meaning |
|---|---|
| Context Contract | Signed, time-bound snapshot of the facts a decision depends on |
| MAEB | Minimum Action-Evidence Bundle: the signed package an agent submits instead of an action |
| Binding | The bundle’s recorded contract hash equals the contract’s hash |
| Groundedness | Every value the bundle cites re-derives from the contract |
| Deterministic shell | Non-AI function that returns Commit or Escalate and alone holds write credentials |
| Invariant | A condition no authority level may break through the shell |
| Delegated authority | The limit on what an agent may commit alone |
| Escalation | Routing a proposal above the limit, with evidence and reasons, to an accountable person |
| Evidence ledger | Append-only, hash-chained, externally anchored record of decisions |
| Replay | Re-running a recorded decision through the shell to check the outcome |
| CAE Ops | The operating model that runs CAE: contract, policy, agent, escalation, evaluation and evidence ops |
| CSI | Context Stability Index: the entropy-normalised criterion used to admit a workflow to autonomy (reference threshold 0.85) |
Frequently asked questions
What is the difference between a Context Contract and an Evidence Bundle?
The Context Contract is the signed, time-bound snapshot of the facts a decision depends on. The Evidence Bundle (the Minimum Action-Evidence Bundle, or MAEB) is the signed package an agent submits instead of an action, citing values that must re-derive from the contract.
Who is allowed to change a system of record?
Only the deterministic shell. Agents propose; the shell commits or escalates, and it is the only holder of write credentials.
What is delegated authority?
The limit on what an agent may commit alone. Anything above the limit is escalated, with its evidence and reasons, to an accountable person.
What is CAE Ops?
The operating model that runs CAE day to day: contract, policy, agent, escalation, evaluation and evidence operations.
Sources
The numbered references in the front matter are the sources for this article. The turbine scenario, its numbers, the ownership table and the failure-mode matrix are constructed or editorial and are not drawn from any deployment.
Disclosure: The Contextual Agentic Enterprise is a vendor- and platform-agnostic architecture framework from Contextual Agentic, and CAE Ops is the operating model that runs it. Any adoption or use in a production setting should be undertaken in consultation with Contextual Agentic or an authorised advisory partner, who will tailor the delegated limits, policies and approvals to the organisation. Product, standard and company names are used to identify categories and remain the property of their owners. The scenario, its figures and the cross-domain examples are constructed for illustration, and the ownership and failure-mode tables are editorial judgements. This article is general information, not legal, compliance or financial advice. The companion book, The Contextual Agentic Enterprise (Polymath Signal Press, 2026), develops the architecture further.
Related
The Contextual Agentic Enterprise: A Formally Governed Architecture for Bounded Multi-Agent Systems in Mission-Critical Systems of Record
A formal account of how CAE separates probabilistic deliberation from deterministic commitment: definitions of the Context Contract, the Minimum Action-Evidence Bundle and the Deterministic Shell, the properties that hold under stated assumptions, an entropy-based admission criterion for autonomy, and a 14-case conformance run of a reference policy.
Beyond the Autonomous Sandbox: The Contextual Agentic Enterprise (CAE) and the Future of Corporate AI Governance
An autonomous agent demo has a token trace. A production security review needs evidence. This article sets out how CAE separates thinking from committing, using a fictional gas-turbine incident, and what an executive roadmap for governed agency could look like.
One Architecture, Any Provider: Mapping the Contextual Agentic Enterprise onto the AI Tool Ecosystem
CAE does not depend on any one model, framework, vector store or cloud. This paper places eleven layers of the AI tool ecosystem on either side of CAE's commit boundary, states when a provider can be swapped without touching the safety guarantees, and reports a portable test suite run on a provider-neutral reference shell.
From DevSecOps to AI-Native DevOps: A Practical Guide to Every Pillar, with CAE and CAE Ops, for the United States and Australia
How an enterprise moves from today's DevSecOps to AI-native DevOps without losing control. Ten pillars, what AI changes in each, where CAE and CAE Ops put the commit boundary, which US and Australian approvals matter, which tools hold them, and what published real-world results actually show.
Why Enterprise AI Needs a Deterministic Shell
Don't try to make the model deterministic or simply trust it. Let it propose, and put identity, authority, schema, state and commitment in a shell that decides at the Commit Boundary.
Frontier AI Models for Vulnerability Discovery: What Works, What It Costs, and How to Govern It (US and Australia)
What frontier AI models have demonstrably done in vulnerability discovery by November 2026, which results are vendor-reported and which were checked by others, what still fails or costs too much, and where an enterprise should point them first, including cryptographic misuse, certificate and PKI handling, and post-quantum inventory. Includes a CAE-governed architecture in which agents propose and a deterministic shell verifies, a fictional worked example, measures and a 90-day starter plan.
AI Maturity and CAE: Match the Level of AI Responsibility to Your Readiness to Govern It
A six-level AI maturity model, from manual work to AI-led operations, with what Contextual Agentic Enterprise (CAE) governance and Contextual Trust security each add at every level. It shows how to rate a workflow rather than a whole organisation, why autonomy should never run ahead of readiness, five ceiling questions for a quick self-assessment, and how to promote or demote a workflow one level at a time.