Trajectory enforcement across agents
Two layers of safety already exist. The agent-harness governs a single model-or-tool call — approvals, sandbox, guardrails, evaluation. Mission Runtime governs a single mission — risk-scored approval, saga rollback, a replayable ledger. Neither can see the failure that lives between agents.
A fleet where every agent follows the rules can still cause a disaster — the pattern Anthropic's multi-agent research catalogues: conformity collapse (many agents converge on one wrong choice), resource flooding (recursive spawning, each locally allowed), collusion (agents settling into a price floor), turf wars (one agent undoing another's action), and epistemic brittleness (weak consensus overruling stronger evidence). Every step is individually permitted; only the trajectory is the violation. The Governance Plane sits over permissions and Mission Runtime and reasons about that trajectory.
The plane is defined by one contract, which decouples every producer and consumer from the enforcement implementation:
RuntimeEvent[] → Governance Plane → GovernanceFinding → Mission enforcement
in: immutable, content-addressed events (id = sha256 of type|actor|ts|…|payload)
out: a normalized finding — decision · effect · severity · cited event ids
· correlation · and, critically, its own **enforceability**Everything entering is an immutable RuntimeEvent from the shared ledger; everything leaving is a normalized GovernanceFinding. A finding carries whether it is actually enforceable on the surface it lands on — so a declared rule can never be reported as enforced unless the execution path proves it reachable.
Behind that boundary sit two separate engines that share the ledger, policy, findings contract, gate and coverage matrix — kept apart on purpose rather than fused into one:
REQUIRE_REVIEW, citing the two series separately (evidence_event_ids / action_event_ids). This is the S1–S2 foundation (v0.2.0) plus the v0.2.x cross-series extension.runtime-contracts (see §8) — and cross-series correlation lives in the trajectory engine. The authority-weighting mechanism (provisional/confirmed claim semantics) is still to come.The gate returns ALLOW · DENY · NO_OVERRIDE · REQUIRE_REVIEW · UNABLE_TO_DECIDE. The rule that makes the plane trustworthy is what it will not claim:
DENY is reported only where a synchronous pre-action gate provably exists on that surface. Detect something dangerous on a surface with no such gate and the finding is NO_OVERRIDE — detected, cannot block, routed to investigation — never a block it cannot make.Enforcement maturity (v0.2.x): OBSERVE vs ENFORCE. Detection is separate from disposition. The same rule runs in OBSERVE (shadow — the finding is recorded, metrics emitted, the decision stays ALLOW) or ENFORCE (identical finding, the configured effect applied). Only the disposition differs: finding(OBSERVE) == finding(ENFORCE) for rule id/version, matched evidence/action events, correlation and window — and each finding records the rule_version and enforcement_mode it was decided under. So a control can be observed in shadow (author → measure false positives → promote) before it ever blocks, without changing what it detects.
The per-host coverage matrix is where this is auditable: enforceable(surface) is derived from whether that surface has a pre-action gate, never assumed. An internal error yields UNABLE_TO_DECIDE, never a fake ALLOW. The full gate specification — its clean-decision preconditions, the operator/control-channel separation, the stricter enforcement parser — lives in the security model.
The trajectory engine, DecisionGate and coverage matrix originated in Go (go/events). v0.2.0 ports them to Python and holds the two to a byte-identical standard: the same events through either engine produce the same findings citing the same content-addressed event ids. A live conformance harness (governance/conformance.py ≡ go/cmd/govconf) checks it on every run — covering both the single-series and the v0.2.x cross-series path (evidence-id and action-id citations byte-identical across languages). Cross-language parity is a property, not a promise.
The plane is exercised on a synthetic GPU data center with a real dependency graph, so "isolate one node" has a computed blast radius. The four scenarios walk the whole honest range:
| scenario | outcome | what it proves |
|---|---|---|
| A safe remediation | ALLOW | migrate → verify → isolate; no rule over-fires — coverage cuts both ways |
| B cascading isolate | REQUIRE_REVIEW | a locally-benign isolate that would drop a critical quorum, held at a gate |
| C turf war | REQUIRE_REVIEW | isolate → restore → isolate, correlated across two agents |
| D fragmented exfiltration | NO_OVERRIDE | harmless reads reconstruct a secret; detected on a gate-less surface → investigate |
Beyond the twin, the plane is scored on 460 real recorded GPT-4o agent trajectories from τ-bench retail (MIT) — customer-service returns, exchanges and cancellations — with its findings checked against the domain's shipped policy by an independent oracle. It recovers every policy violation the oracle finds, and the results that matter are the ones a permission check cannot reach: 38 multi-event violations (the "called once" rule) a per-action gate catches 0 of, zero cross-order false alarms, and the same cross-user rule resolving to 6 DENY (writes, gated) versus 12 NO_OVERRIDE (reads, gate-less). Method and honesty notes: the governance benchmark →.
v0.2.0 is deliberately bounded to S0–S2: correct the public claims, unify the event ledger, and run a live trajectory evaluator with Python↔Go conformance and a fail-closed gate. The exit gate is met — including at least one genuinely cross-agent trajectory detected and replayed end to end.
Shipped in v0.2.x: cross-series (evidence-aware) rules — correlating an evidence-change series against an action series → REQUIRE_REVIEW, Python↔Go conformant — and OBSERVE/ENFORCE enforcement maturity (the same rule shadowed then promoted without changing detection).
Still held: population mechanics (spawn/rate caps, diversity-dedup, a coordination registry, collusion rules, inter-agent capability boundaries) and epistemic governance (authority-weighting). Resource flooding, conformity collapse and epistemic conflict need aggregation, diversity and authority semantics the ordered-step engine does not yet have — simulating them on it would be exactly the dishonesty this plane exists to prevent.
Landed in v0.3.0 — the epistemic screening half. The rule evidence may influence belief but may never grant itself authority now has canonical adversarial validators in the open runtime-contracts layer (prompt/instruction injection, self-granted authority, hidden embedded instructions, source spoofing, poisoned tool metadata, classification escalation, cross-source contradiction — deny-wins, conservative). This is the screening the stub was a placeholder for; the broader authority-weighting registry (provisional/confirmed claim semantics) remains held. v0.3.0 also canonicalizes the disposition/telemetry substrate this plane runs on — RuntimeSecurityEvent (boundary-emitted, hashes not payloads, not agent-reported), correlate() into a GovernanceDisposition, and a Containment state machine — with Python↔Go conformance. Security model §10 →
RuntimeEvent contract ships in Python (agentic_os/mission/events.py); the trajectory engine · DecisionGate · coverage matrix ship in Python with byte-identical Go parity. Companion to the security & enforcement model, the governance benchmark, and the roadmap. Walk it live at gov.redevops.io.