Overview

The layers before this one build the Mission as a governance object. It is approved with integrity (From a Request to an Approved Mission), bound to instances and delegated under a strict subset (Mission-Bound Authority), enforced per action (Mission-Bound Runtime Enforcement), and observed and revoked over its lifecycle (Mission Lifecycle and Change). Each of those guarantees is stated as a contract the Authorization Server, a Policy Decision Point, or a token holder upholds.

A running agent does not honor contracts for free. It is a harness that checkpoints state and resumes after restarts, an orchestrator that sequences many steps over hours, and a producer of signed records that, on their own, only its own auditor can fully trust. Each of those is a place where a stated guarantee can quietly stop holding: the session resumes after the Mission was revoked, the workflow is halfway through a wire transfer when the Mission is suspended, and a signed log can be backdated by whoever holds the signing key.

This part specifies the operational layer that closes those three gaps. It introduces no new authority object and makes the existing one survive a real, long-running, multi-step, possibly-compromised agent. Three drafts answer three questions:

  • Sessions are not authority. When an agent recovers a session, what stops it from acting on authority that has since been revoked?
  • Unwinding work in flight. A Mission can stop after some steps committed and before others run. What happens to the work already moving?
  • Evidence anyone can verify. The suite produces signed evidence at every step, but signed is not tamper-evident. How does a party in another trust domain confirm nothing was dropped or backdated?

All three are OPTIONAL companions to the issuance profile, at different maturity. Optional at the protocol layer does not mean optional for the assurance a deployment states. The harness belongs to the Governed Agent bundle, and orchestration and audit are required by the claims that use them. Orchestration is a newer, experimental profile the bundle grows into as needed. Audit layers onto any level. Together they carry the Mission’s guarantees into a running agent system.

The control at a glance
Minimum useful versionThe harness re-checks Mission state before any resume and stops work when the Mission is not active
What it preventsA recovered session, queue, or cached connection acting on authority that no longer exists
What it does not preventSide effects on paths the harness does not mediate, and a dishonest producer writing false records. Transparency makes records permanent and attributable, not true
Operational ownerThe agent platform team owns the harness and the orchestrator
Evidence emittedStop and resume decisions, unwind plans and outcomes, and SCITT registrations where audit transparency is adopted
MaturityThe harness is recommended for agents. Orchestration is experimental. Audit Transparency is advanced

Sessions are not authority

Session continuity is not authority.

The Mission Is the Missing Abstraction drew the line. A session can prove the runtime survived a restart. It cannot prove the Mission survived. The separate note Sessions Are Not Missions made the argument in full. The harness profile turns it into a requirement.

An agent harness exists to make work durable. It checkpoints conversation and planning state, persists a task graph, queues background jobs, caches tool connections and OAuth tokens, and tracks sub-agent handles, so the agent can survive a process restart, a device handoff, a scheduled wake-up, a retry, or an asynchronous tool response. Every one of those is a continuation point, a moment where the harness resumes work it saved earlier. And every one of them is a moment where the authority that justified the work may have ended while the runtime state that carries it did not. A task graph can survive a revoked Mission. A warm connection to a tool server can outlive the condition that authorized it. A child agent can keep running after its parent Mission is suspended. One continuation is sanctioned. When a Mission is terminated with reason superseded, the harness may rebind the running session to the successor its termination.successor names rather than restarting, deriving fresh credentials under the successor and discarding the predecessor’s, so governed growth keeps the runtime it already has.

The harness binds every governed session and task-graph node to a Mission binding: the Mission’s identifier and issuer, its authority_hash where Status discloses it to the harness, the last-known state with its source and freshness, and, for governed work, a required stop policy. The binding grants nothing. It is the pointer that tells the harness which Mission state it must re-establish before it continues. The rule that follows:

Before resuming governed work, the harness MUST establish that the Mission is active within the deployment’s staleness bound, even when the OAuth credentials in the session are still valid.

It establishes that state through one of the lifecycle surfaces from Mission Lifecycle and Change: a Mission Status query, an event-driven state cache fed by Lifecycle Signals, a runtime PDP decision that itself checks current state, or another deployment-defined source with equivalent freshness semantics. If it cannot establish active state, it does not resume. If the state is anything else (suspended, terminated with any termination.reason, or a state a newer profile added that this harness has never heard of), it stops. The harness inherits the suite’s forward-compatibility rules, treating any state other than active as non-active and a terminated Mission whose reason it does not recognize as terminated, so an unknown value fails safe rather than slipping through.

The harness picks from four stop behaviors based on the Mission state and the action class:

  • suppress: do not dispatch the queued or resumable work. Preserve it for audit or operator review.
  • pause: hold the work pending an authorized lifecycle transition such as a resume.
  • terminate: end the task graph and release its runtime resources.
  • handoff: escalate to a human or governance workflow without taking any further governed action.

A revoked or completed Mission means suppress or terminate. A suspended one means pause or suppress. An unknown or stale state means suppress or pause. For the class-guard classes, handoff or orchestration handling (the next section) is preferred over a blunt stop. And a handoff is not open-ended. The review outcome is approve, reject, or expire, a parked item carries a maximum age, and approved work re-enters the resume algorithm, because review approval is not itself a Mission-state check.

The same discipline extends to the things harnesses quietly reuse. A cached credential or tool connection is not evidence the Mission is still active. Before reusing one for governed work, the harness re-checks the Mission and the action. Connections are keyed by Mission, authority hash, audience, actor, and sender-constraint key, so a connection opened for one Mission never becomes ambient authority for another. (The one sanctioned reuse is a connection that carries no authority at all, where every consequential use is separately authorized under the target Mission.) One execution context serves one Mission at a time for consequential work. An instance may be reused and a context may not, because content read under one Mission steering actions under another is the flow-level residual running inside the model’s window. Where multiplexing is unavoidable, it is declared and caps the exposure classes the context may hold. And a sub-agent never inherits authority by descending from a parent session. It gets an explicit child-Mission or delegation binding (Mission-Bound Authority), and when the parent Mission goes non-active the harness propagates the stop to dependent children.

Each governed work item also gets a qualified identifier the harness assigns, a work_item_issuer and a work_item, bound to exactly one Mission and inherited by the children created from it under that Mission. Where the Enforcement Scope Statement names the harness as the attacher, a PEP takes the work item only from the harness’s attachment, never from a value the agent supplies, and carries it to the decision. A deployment that claims work-item attribution for an action class then requires the work item in the decision, binds it into the permit, and refuses a permit for another work item, with Decision and Execution Evidence carrying it. Attribution says which work item an action was requested for. It proves neither that the action serves that item’s purpose nor isolation between items in one process.

A concrete moment, on the handbook’s running example. An agent preparing the Q3 board packet runs as a long-running overnight job, so its session outlives the user’s attention. At 02:00 it resumes a queued task graph to run the final pass on the packet. The board meeting was cancelled and the Mission revoked at 23:00. The harness re-reads the Mission state from Mission Status before dispatching anything, finds it terminated with reason revoked, declines to dispatch, marks the cached docs.example.com connection unusable, and emits evidence:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
{
  "event_id": "hrn_7pQ4mN9s",
  "event_type": "resume_suppressed",
  "mission": {
    "id": "msn_Y89D4gqD9lDfw2cn6qqSO4C9j8o63Z2p",
    "issuer": "https://as.example.com",
    "authority_hash": "sha-256:4hRwrGkW9Jdjbkj1oHJ3opg9HRvmRe30k7TQmUfiIpY"
  },
  "session_id": "sess_agent_42",
  "work_item": "final_pass_board_packet",
  "state": "terminated",
  "termination": {
    "reason": "revoked",
    "terminated_at": "2026-09-30T23:00:00Z"
  },
  "state_source": "status",
  "decision": "suppress",
  "reason": "mission_not_active",
  "occurred_at": "2026-10-01T02:00:05Z"
}

The session was recoverable, but the authority behind it had ended, so the harness let the Mission state decide.

The mediated execution environment

The harness profile carries one requirement that does not look like continuity management but is the structural complement to Mission-Bound Runtime Enforcement. Its high-assurance level puts the sender-constraint key in the enforcement point’s custody, not the agent’s, so a compromised agent cannot act off the enforced path. That guarantee is empty if the agent has an off-path route to the resource in the first place (a debug shell, a direct socket, an unsanctioned egress, a connector that skips the gate).

Establishing the closed environment is the harness’s job. The draft names this Mission Mediation:

For the action classes a deployment mediates, the harness MUST run governed consequential work in an execution environment whose only path to those actions is through the mediating PEP, and MUST NOT leave an unmediated route to a mediated class.

The runtime layer holds the key, and the harness guarantees that no route to a mediated class bypasses the PEP. A deployment claiming compromise-resistant enforcement isolates the mediating PEP and its key custody from the agent-facing harness components, by process, host, or service separation, because a harness that both faces the agent and holds the sender-constraint key defeats mediated custody the moment it is compromised. The claim is also published, not implied. The harness publishes an execution-environment scope statement naming, for each mediated class, the isolation mechanism that confines governed work, the unmediated paths excluded from the claim, and the secondary egress channel classes the environment offers: DNS, log and error output, shared stores and long-term memory, spawned processes, provider-side model context, the inference API, and rendering surfaces that fetch remote references. Each is marked mediated, excluded by the isolation, or outside the claim, and the full enumeration is mandatory where the deployment claims trifecta containment or compromise-resistant enforcement. Verifying that no unmediated path exists is a deployment audit obligation, not a protocol property. A harness that cannot guarantee a closed environment for an action class MUST NOT represent work in that class as runtime-enforced, the same enforcement-scope rule the runtime profile applies.

The largest off-path route for agents is the code-execution tool. The moment a Mission grants an interpreter, a shell, or a notebook, the agent can write its own client, and a script-level database call does not pass the API-level PEP on its way out. Reading generated code does not make it safe, and a PDP that inspects the script before it runs would be the enforcement-time intent inference this handbook rejects. The control is the environment the generated code runs inside. Mediated custody keeps credentials out of the sandbox, so the script holds nothing a database would accept. The harness and the egress proxy own the environment’s exits, so effects leave only through mediated paths. And the execution-environment scope statement declares the sandbox and its exclusions, so the claim is checkable rather than assumed. Sandboxing is the price of the interpreter, the same boundary the OWASP part’s T11 verdict prices, and a deployment unwilling to pay it must exclude code execution from its enforcement scope in writing rather than let the API PEP imply coverage it does not have.

The harness profile adds one more control, taint tracking, that no per-action check can apply. The runtime PDP evaluates each action against the undertaking’s committed state, one decision at a time, and never sees the flow of content between calls. The harness mediates tool input and output, so it sees that flow and applies these rules:

  • What taints. Attacker-influenceable content, such as a fetched document, a tool result, or an inbound message, taints the governed session it enters. Content is not trusted merely because its source is the Subject.
  • What triggers the rule. Where the harness can trace a bound parameter to its source at the data plane, the rule applies to a consequential egress whose parameter derives from tainted content. Where it cannot trace provenance, the rule applies to every consequential egress in a tainted session.
  • What the harness does. Before such an egress, the harness should require a fresh action-bound approval or downgrade that authority by suppressing the action. This is plan-then-execute. Untrusted content may inform the agent’s planning, but it must not, on its own, drive an egress that no trusted direction gave.
  • Who gives a trusted direction. A trusted direction, for an egress or for a taint reset, comes from the delegating person, the Approver, or another principal the deployment authorizes. It arrives through a surface the agent cannot invoke from its tools or from any channel it drives. Being the Subject does not make a direction trusted, so an agent acting for itself under its own workload principal can neither give its own egress a trusted direction nor clear its own taint.
  • Paraphrase keeps taint. In a tainted session, the harness treats a bound parameter it cannot affirmatively trace to a trusted source as tainted. Content the agent paraphrases rather than copies therefore stays tainted.
  • Memory keeps taint. A store a governed session can write is not trusted by default. Content read back from a vouched, Mission-writable store inherits the taint of the session that wrote it.
  • Destinations the Approver named. A recipient or endpoint the Approver concretely named at approval is pre-consented egress. A tainted session’s send to exactly that destination needs no fresh approval on taint grounds alone. Parameter binding and the per-action permit still apply.
  • Routing through the PDP. A deployment may route the taint determination through the PDP where the decision binding carries it. Where the Enforcement Scope Statement declares PDP-enforced taint for an action class, the PDP denies a decision in that class whose taint context is missing.

The draft calls this a coarse control, not information-flow control. It cannot close within-scope data laundering. It does place a fresh approval or a suppression between injected input and an external side effect at any destination the Approver did not name. Least Exposure Is Broader Than Least Privilege makes the general case that a Mission should bound the exposure surface as well as the action surface.

A harness check never replaces the PEP at the last controllable boundary, and the two compose. The harness decides whether a unit of work may continue at all. The runtime layer still gates every consequential action.

Unwinding work in flight

Mission runtime enforcement can refuse the next action. It cannot un-send the last one.

The runtime layer is a gate in front of each action, so revoking a Mission stops every gated action that has not yet happened, within the published freshness bound. But a long-running workflow is a sequence, and a Mission can stop in the middle of it, after a journal entry posted and before the reviewer was notified, or after a payment was dispatched and before anyone can prove it cleared. Denying the next step does nothing about the steps already in motion. Mission termination therefore raises a question about execution state as well as access control, and the orchestration profile answers it.

The profile plans the unwinding before the work runs, in two pieces.

First, every consequential step is assigned a reversibility class before it executes:

  • read_only: observes data, no external effect. Suppression prevents future exposure, but prior disclosure cannot be undone.
  • reversible_write: changes state and has a known compensation that can restore or materially offset it.
  • irreversible_action: cannot be reliably undone once completed.
  • external_commitment: commits to an external party: a sent message, a started payment, a signature, a filing, an order.
  • privileged_administration: changes policy, access, configuration, or security posture.

The last three share their names with the action classes from Mission-Bound Runtime Enforcement. The two drafts file payments and sent messages differently, the runtime profile’s examples as irreversible actions and the orchestration profile’s definitions as external commitments. Until the drafts settle the overlap, this handbook recommends applying every requirement of each class an action fits, with the tighter bound where two requirements compare. A sent message is also an external-communication action under the runtime profile, so its egress rules (mediation, the taint rule, and egress metering) apply in either class. read_only and reversible_write are the finer distinction this profile adds for the sake of deciding what can be compensated. A step’s reversibility class must be consistent with, and no lower than, the runtime action class for the same operation, and the orchestrator MUST NOT lower it at runtime to dodge review. That is the same can’t-talk-yourself-down floor the runtime layer enforces, and for the same reason. The class comes from a trusted source (resource policy, an operation profile, a reviewed workflow definition). An agent’s plan, model output, or tool description may suggest a class, but it is never the sole authority for lowering one.

Second, before dispatching a consequential step, the orchestrator records an unwind plan for it. The plan states what happens to the step at each phase of trouble: what to do if the Mission is already non-active before the step starts, what to do if it stops while the step is in flight, and, for everything but a pure read, what to do after the step has completed. A worked plan for the riskiest kind of step:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
{
  "step_id": "notify_reviewer_audit_committee",
  "mission_id": "msn_Y89D4gqD9lDfw2cn6qqSO4C9j8o63Z2p",
  "reversibility": "external_commitment",
  "pre_start_behavior": "human_review",
  "in_flight_behavior": "wait_then_review",
  "post_completion_behavior": "human_review",
  "review_queue": "audit-committee-review",
  "evidence_policy": { "link_runtime_evidence": true, "retain_for": "mission_audit_horizon" }
}

The plan is also committed, not just recorded. The step’s first Orchestration Evidence record carries an unwind_plan_hash over the plan, so an auditor can detect any later alteration of the plan a step ran under. And every member of the plan (the compensation action, the review queue, the safe point) derives from a trusted source. Model output MUST NOT define them.

When the orchestrator learns a Mission is no longer active (from a status poll, a signal, a PDP denial, a harness stop, or an operator), it stops dispatching new steps, suppresses queued work, evaluates every in-flight step, and runs the post-completion behavior for completed steps whose plan requires it. Staleness alone, an active state the orchestrator cannot re-establish within the bound, gets the same stop but never the post-completion behavior, because compensation is itself consequential work and unwinding work nobody stopped is not fail-closed. A narrowing signal (authority_changed at an unchanged active state) is a third trigger: the orchestrator re-reads the Effective Authority Set and re-gates pending steps against it, and never compensates a committed step merely because authority narrowed after it committed. Unwind plans cover workflows built from a reviewed definition. A graph a model composes at runtime falls back to harness stop behavior and runtime gating. The in-flight step is the hard case, and the profile sorts it into four states:

  • not_dispatched: not yet at the PEP or external system. Suppress or pause it.
  • dispatched_not_committed: sent, but still cancellable. Attempt cancellation if the plan says so.
  • committed: evidence establishes that the effect occurred, such as Execution Evidence with outcome completed. Apply post-completion behavior.
  • unknown: no evidence yet establishes whether the effect occurred. Treat it as requiring human review, and never apply post-completion behavior to it. It leaves this class only when evidence establishes the outcome.

Distributed systems frequently cannot prove whether an in-flight action committed, and treating “I don’t know” as “it didn’t happen” is how audit gaps form. For an irreversible action, an external commitment, or a privileged change, an unknown outcome must not be quietly filed as success or as harmless suppression. It goes to review. Cancellation acceptance by an upstream queue is not proof the external action did not occur.

When a completed step does need to be walked back, that compensation is itself governed work. A refund, a reversing entry, or a cancellation message can be as consequential as the action it offsets, and each is tied through compensates_evaluation_id to that one committed step and carries the parameters retained from its effect. So the profile refuses to let Mission termination become a backdoor to unauthorized remedial action. Compensation under a Mission that has already gone non-active requires one of exactly two documented authority bases: the resource’s own policy (a remediation the resource authorizes for itself, such as a local rollback) or a narrow, pre-provisioned remedial Mission that is still active. An operator may gate either basis, but operator approval is not itself an authority basis. It does not create authority a PEP would enforce over a terminated Mission. If neither basis applies, the orchestrator does not compensate. It hands off to a human.

Like the harness, the orchestrator does not replace the PEP. A runtime permit obtained just before revocation might still arrive at the PEP afterward. The orchestrator stops dispatching such work, and the PEP still enforces its own permit freshness and Mission-state check. The harness decides whether a unit of work may continue. The orchestrator decides how in-flight workflow state is unwound. The runtime layer gates each action. None of the three checks subsumes the others.

The containment matrix

Unwinding assumed the stop signal was the Mission’s. In an incident it usually is not, and Mission termination is one control in a larger containment surface. Each kill has a different blast radius and a different owner, and an incident responder needs the whole matrix:

KillBlast radiusWho owns it
Capability killOne capability within one Mission and the Child Missions it justifies: new derivation stopped at once at commit by the issuer’s removal-only overlay while the Mission stays active, with credentials already materialized under it running to their own bound unless a containment-aware action-time gate reaches them firstThe Mission Issuer
Mission killOne body of work, across every resource and derived credential, cascading to Child MissionsThe Mission Issuer
Agent killAll work by one agent, across its MissionsThe deployment’s agent IAM
Agent Deployment killEvery instance running a compromised behavioral versionThe deployment’s change governance
Credential killCredentials already issued, where the substrate supports revocation, otherwise their expiryThe credential issuer
Workload killThe running compute itselfThe platform
Egress killThe communication pathGateway and network controls

The capability kill’s reach is set per action class and consumer, never by the deployment’s assurance level, and only where the deployment runs the experimental containment profile. A consumer that checks only a token’s signature and expiry gets the new-derivation kill, which also reaches Child Missions the contained entry justifies, while already-minted credentials live out their bounded lifetimes. A consumer gated by a fresh, containment-aware state source at the action (Mission Status, introspection, or a runtime PDP) also denies contained capability under pre-transition tokens, within the staleness, permit, and execution windows. A standalone Mission Authority Server path with no runtime gate gets neither. Mission termination participates in incident response without replacing it. Revoking the Mission stops issuance at once where the binding gates it and stops mediated actions within the staleness bound plus the permit window and the class’s execution bound, but it terminates no process and closes no network path. Conversely, killing a workload leaves the Mission active, its authority derivable to a replacement instance, unless the Mission is also revoked. A deployment’s incident runbook names which of these controls exist, who may pull each, and, per action class, which capability-kill reach its consumers obtain, and the Mission kill and agent kill rows belong to different objects with different owners, which is why the runbook has to name both.

Evidence anyone can verify

Every layer of this suite signs its evidence. Signed is not the same as tamper-evident.

By the time a Mission completes, the suite has produced a trail: the approval event, every lifecycle transition, the consent rendering the user saw (From a Request to an Approved Mission), the per-action decision and execution evidence (Mission-Bound Runtime Enforcement), and the harness and orchestration evidence from this part. Each record is signed, which makes it attributable and tamper-evident in isolation.

It does not make the record set trustworthy. Whoever holds the signing key can backdate a record, drop an inconvenient one, or show different histories to different auditors. And nothing a relying party holds detects it. A compliance auditor in another company is worse off still. They have only the issuer’s word that its own logs are complete. A bare signature over a narrowed token cannot give a cross-domain party offline confidence that nothing was reordered or omitted.

The audit profile closes that gap by registering Mission evidence into a SCITT Transparency Service. The SCITT architecture is published as RFC 9943, so this profile builds on a published standard. A producer (the Authorization Server, a PDP, a harness) registers a record as a Signed Statement. The service appends it to an append-only log and returns a Receipt that proves inclusion. The Signed Statement plus its Receipt is a Transparent Statement that any party can verify offline. Verification shows that the record was registered at a committed time and is included in a signed log tree head.

Two design choices make it practical.

The Mission is the statement subject. Every Signed Statement about a Mission uses the same sub, a fixed URI built from the Mission’s issuer and id (<issuer>/missions/<id>). Because the construction is fixed, independent producers in different domains all compute the same subject, and they share one feed when they register with the same Transparency Service, which cross-domain deployments should. The substrate defines no feed query, so an auditor retrieves the records through an enumeration the deployment supplies. The audit profile requires the deployment to document that mechanism: how an authorized auditor retrieves every record registered for the subject, in what order, with what completeness, and under what authentication. For the running example, under sub = https://as.example.com/missions/msn_Y89D4gqD9lDfw2cn6qqSO4C9j8o63Z2p, the enumeration returns these records:

#RecordIssuerTimeNote
1approval-eventas.example.comt0
2consent-evidenceas.example.comt0
3decision: permitpdp.example.comt0+1hFinancials read
4decision: denypdp.example.comt0+2hCRM read, out_of_authority, requestable
5expansion: declinedas.example.comt0+2hCRM access
6lifecycle: revokedas.example.comt0+6hBoard meeting cancelled at 23:00

Three limits remain, and Receipts close none of them. A failure to register is visible only against an expected schedule, because transparency proves what was registered, not that everything was. A deployment registers on a predictable cadence so an omission stands out as a gap. A failure to enumerate is separate. The log’s guarantees bind the log and its Receipts, not the listing the audited deployment assembles, so the deployment can withhold registered records from a listing or show different auditors different listings while every Receipt it presents stays valid. Against a single Transparency Service, the auditor also trusts that service not to drop or reorder a record later and not to show different auditors different histories. Detecting a split listing or a split log takes a standardized listing or registration with more than one independent service.

Statements commit by hash, never in the clear. The Signed Statement’s payload is the digest of the retained evidence record as issued, not the record itself. A transparency log is append-only and may be widely readable. Nothing in it can be redacted later. So the sensitive task data stays out of the log entirely, retained separately under access control, and a relying party retrieves it and checks it against the committed digest. (Low-entropy records are committed with a retained random salt, because a lifecycle transition is guessable and an unsalted digest of a guessable record can be confirmed by dictionary.) The log proves a specific record was registered at a time. The content is verified out of band. Even the committed metadata leaks, though. The sub construction is fixed and does not expose the Subject directly, but it is a durable per-Mission correlator whose existence and registration cadence are observable in a shared log, so a deployment should weigh whether a Mission’s mere existence and timing are sensitive before registering in a widely readable service, and what its issuer and id reveal.

The profile separates an integrity failure (a bad signature, a bad Receipt, a broken inclusion proof, or a hash that does not match the retrieved evidence) from an audit failure, where the evidence, or a producer or service trust anchor, cannot be retrieved or resolved in the access window. An integrity failure is rejected. Among its causes, only the hash mismatch means the retained record itself was altered. The others mean the statement or the log cannot be trusted. An audit failure means you have proven the record was registered at a committed time but cannot confirm its content, which is not proof of tampering, and must not be treated as such.

Every distributed estate already has correlation IDs, and a request ID and a Mission ID connect different things. A request ID connects one trace, the hops of a single call as it crosses services, and it dies with the request. The Mission ID connects the body of work: every session, retry, agent, resource server, Child Mission, and lifecycle change the approved task produced, across days and across domains. Tracing tells you what happened to a request. Evidence joined on the Mission tells you what happened to the work, and whether it was still authorized while it happened. That property is verifiable continuity: the approval, the decisions including denials, and the executions shown to belong to one undertaking, not merely threaded by a correlator.

Six questions recur about the evidence layer, and the whole suite answers them in one place:

QuestionThe answer
Where is evidence stored?At its producer: the Issuer’s records, the PDP’s evidence store, the harness’s session records. SCITT registration adds verifiable inclusion of registered records without moving anything
Who signs it?The producer: Consent Evidence by the Authorization Server, Decision Evidence by the PDP, Execution Evidence by the PEP or executor, session records by the harness, and unwind plans and outcomes (Orchestration Evidence) by the orchestrator, each a Signed Statement where registered
Can it be replayed?The committed disclosure can be re-rendered and checked against consent_rendering_hash, and a Transparent Statement verifies offline against the anchors
Can it be aggregated?Yes, deterministically: every record joins on mission.id and mission.issuer, one history per undertaking, which is what makes the continuity verifiable
Can it feed an approval?As input, yes: Shaping Evidence and interrogation answers inform the Approver, and Decision Evidence gives a requestable denial its context
Can it issue authority?Never. Evidence proves, it does not grant. Presenting evidence, including the portable Mandate, authorizes nothing

The audit profile layers onto any level without changing it. It defines no new evidence object. It registers the records the suite already produces. A separate sketch, Mission Evidence Envelope, which the handbook labels Evaluate only, proposes one generic envelope for future evidence kinds and migrates none of the existing records. A deployment that keeps its evidence without a Transparency Service is fully conformant and unaffected.

And it buys accountability, not prevention. Transparency makes alteration of a registered record detectable, and gives a cross-domain party offline verification of the record’s inclusion. It does not make a dishonest producer honest. A producer can still register a false record. Transparency only makes that false record permanent, attributable, and visible to every auditor. And it proves only that a record was registered, not that the action the record describes occurred or was authorized. That is the evidence’s own semantics, not something the log can vouch for.

Run the whole Q3 board-packet task through this operational layer and the three checks land in order: the harness finds the revoked Mission and stops the paused draft, orchestration unwinds the half-written doc under the resource’s own rollback policy or hands it to a human, and, where the deployment registers its evidence, each registered record’s inclusion is verifiable, with the packet’s contents never entering the log.

The six-layer architecture

This part closes the implementation chapter. The handbook specifies one durable object and follows it down a single spine (intent becomes a Mission, the Mission bounds authority, enforcement evaluates each action against it) across six layers:

flowchart TB P1["The Mission (architecture chapter)
issuance profile: approval event,
intent_hash / authority_hash,
mission claim, state-gated issuance"] P2["Part 1: Approval-time integrity
shaping, consent evidence,
deferred approval"] P3["Part 2: Sub-agents and delegation
strict-subset child Missions,
offline attenuation"] P4["Part 3: Runtime enforcement
per-action permit, mediated custody,
action-bound approval"] P5["Part 4: Lifecycle and change
status, signals, expansion, completion"] P6["Part 5: Runtime and audit
harness binding, safe unwinding,
tamper-evident evidence"] P2 -->|proposes| P1 P1 -->|derives| P3 P1 -->|bounds| P4 P5 -->|governs| P1 P2 --> P6 P3 --> P6 P4 --> P6 P5 --> P6

Read it as layers, not publication order. The issuance profile, the OAuth binding that The Mission Is the Missing Abstraction covers, is the only mandatory layer. Everything else is an OPTIONAL companion that layers on without changing it, optional to the issuance profile and required by the claim that uses it. Parts 1 through 4 each make the Mission trustworthy along one dimension: the approval that creates it, the delegation that fans it out, the action that draws on it, and the state that governs it. This part adds no guarantee of its own. It keeps the others from silently lapsing inside a running agent. The harness keeps a recovered session from acting on dead authority. The orchestrator unwinds work the kill switch caught mid-flight. The optional audit profile lets a party that does not trust the producers verify each registered record’s inclusion. They are why the architecture holds up against a long-running, multi-step, possibly-compromised agent rather than only an idealized one.

After the entry point is chosen, the handbook orders adoption by the Mission Assurance Levels, and under the OAuth binding they run:

LevelOne line
Baseline IssuanceState-gated issuance and a derivation kill switch, for consequential reads and writes outside the high-consequence classes whose bounds the receiving Resource Server enforces
Runtime-EnforcedPer-action enforcement plus state freshness, for parameter-bound writes and bounds finer than the Resource Server checks
Governed AgentConsent evidence, harness binding, and operational controls, for unattended operation and delegation
High-Assurance AgentMediated custody, action-bound approval, and no unmediated path, for the high-consequence classes

The Governed Agent level adds consent evidence (From a Request to an Approved Mission) and the harness (this part), growing with delegation, expansion, and orchestration as the use case arrives. Audit transparency layers onto any level. Compromise resistance is not a level of its own. It comes from meeting the four conditions of the high-assurance level with a declared and audited path scope and an attested Enforcement Scope Statement, and the adoption sheet carries the full what-you-get and what-you-do-not-get map for every level.

A deployment with no agentic surface and no cross-hop audit need does not need a Mission layer and should not pay its cost. This chapter is written for deployments where authorization governs a user-approved durable task that spans many tokens, calls, actors, and a long stretch of time. The Mission Is the Missing Abstraction argued that the Mission is the missing abstraction because OAuth had no first-class object for the approved task. In this part that object is what a recovered session must re-check, what an in-flight workflow unwinds against, and the subject that ties a Mission’s whole evidence feed together.

For the full wire-level detail, read the three drafts: Mission-Aware Agent Harnesses, Mission Orchestration and Unwinding, and Mission Audit Transparency. For the full spine applied end to end on a concrete deployment, Least-Privilege MCP Tool Calls Need a Mission walks an MCP server through it. The concluding chapter maps these layers onto the substrate-neutral framework, and Adopting Mission-Bound Authorization turns them into entry points and a staged build, and names the roadmap that needs iteration.