Contextual Agentic

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.

·22 min read

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.

Key CAE governance concepts and how they work together: seven panels, each with a definition, focus, fictional example and use in governance, a flow strip, and the result.
Figure 1. Key CAE governance concepts and how they work together: seven panels, each with a definition, focus, fictional example and use in governance, a flow strip, and the result.

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.

Simple five-step diagram of one CAE decision: current context, agent proposal and evidence, policy and authority check, commit or escalate with reasons, and record and monitor, with a fictional turbine example under each step
Figure 2. The simple version: one decision in five steps. Policy and delegated authority are checked inside the shell before anything is committed. Fictional scenario.

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.

Anatomy of the Context Contract and the Evidence Bundle, with the binding and groundedness checks between them.
Figure 3. Anatomy of the Context Contract and the Evidence Bundle, with the binding and groundedness checks between them.

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.

The five ordered shell checks V1 to V5, their failure reason codes, and the two outcomes.
Figure 4. The five ordered shell checks V1 to V5, their failure reason codes, and the two outcomes.

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:, the invariant codes (phi_doa, phi_inv, phi_op, phi_bom), psi:cost-above-limit, V5:replay and fail-closed:. They exist so that an escalation can be read by a person and counted by an operator.

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.

Delegated authority ladder with invariants as hard stops that no authority level can override.
Figure 5. Delegated authority ladder with invariants as hard stops that no authority level can override.

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.

The evidence ledger: hash-chained entries, external anchoring and replay.
Figure 6. The evidence ledger: hash-chained entries, external anchoring and replay.

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.

CAE Ops: six disciplines around the decision path.
Figure 7. CAE Ops: six disciplines around the decision path.

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.

Animated walkthrough of the seven CAE concepts in sequence, following the turbine decision for two cases: a decision that commits and a decision that escalates
Figure 8. The seven concepts in motion: the same turbine decision followed through contract, bundle, shell, policy, authority, ledger and CAE Ops, for one commit and one escalation. Fictional scenario.

3.1 One decision, end to end

The timeline below follows the turbine decision through all seven concepts.

One decision end to end: from signed contract to ledger entry, and four alternative paths through the same loop.
Figure 9. One decision end to end: from signed contract to ledger entry, and four alternative paths through the same loop.
  1. 01:40 to 01:41, contract. The alarm fires. The contract compiler snapshots and signs the facts.
  2. 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.
  3. 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.
  4. 01:42, policy and authority. V4 confirms the invariants hold and the cost is inside the 25,000 limit.
  5. 01:42, commit and record. V5 commits atomically. The ledger appends the bundle, the contract hash, the policy version and the outcome.
  6. 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.

Ownership by concept, and the failure modes each concept primarily or secondarily controls.
Figure 10. Ownership by concept, and the failure modes each concept primarily or secondarily controls.

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

  1. 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.
  2. Define the contract. List the facts the decision needs, their authoritative sources and the freshness the decision tolerates.
  3. Write the invariants and the limit in plain language with the owner, then as code, with tests.
  4. 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.
  5. Turn on the ledger and anchoring before any live commit.
  6. Commit inside a small limit. Widen it per workflow only when the recorded evidence supports it.
  7. 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.

Technical reference for the seven CAE governance concepts: artefacts, mechanism, guarantees, failure reason codes, operating metrics, reference technology, and the data flow across trust zones.
Figure 11. Technical reference for the seven CAE governance concepts: artefacts, mechanism, guarantees, failure reason codes, operating metrics, reference technology, and the data flow across trust zones.

9.1 Artefact layouts (illustrative)

jsonc
// 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>" }
}
jsonc
// 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

python
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)

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:

python
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.

← All articles

Related