Repository navigation
Extending Agent Governance Beyond Authorization: SCQOS Consequence Verification and Continuity #3729
Replies: 2 comments 5 replies
|
You have identified the central gap clearly: "authorization proves that an action was admissible at decision time" but says nothing about whether the resulting state matches what was authorised. This is the exact boundary where most governance frameworks go quiet, and the falsification test you propose (stale evidence, semantic drift, executor failure after authorisation) is the right way to stress it. The compositional question between pre-execution policy evaluation and post-execution consequence confirmation is harder than it looks, because the two boundaries share implicit state that neither side fully owns. An authorisation decision captures a frozen snapshot of evidence, policy, and identity at decision time. A consequence verifier must confirm that the external state produced by execution is the state that snapshot described, not merely that execution occurred. The binding between those two checkpoints is where most designs leak: if the consequence verifier re-evaluates evidence independently rather than confirming against the original authorised snapshot, it introduces a second decision point that can diverge silently from the first. Your "frozen contract-universe hash" addresses this in principle, but the implementation question is whether the hash covers the full causal chain or only the inputs the governor saw. The fail-closed property you describe (governor component failure produces an attributable governed failure state, not a silent PERMIT) is the single most important design constraint, and also the hardest to test end to end. A governor that fails loudly when its own verifier is unreachable is straightforward. A governor that detects when its verifier returns a stale or semantically drifted confirmation, one that would have been correct five seconds earlier but no longer matches the live external state, requires the consequence confirmation itself to carry a freshness proof. Without that, the receipt is durable but potentially describes a state that no longer holds. How does your reference implementation handle the window between consequence confirmation and receipt generation, specifically when the external state can change during that interval? |
|
Consequence verification after the fact is valuable and different. We exist for the pre-effect gate: no host-registered tool runs without a signed unspent token. Outcome assurance can sit after; it cannot replace that. Why decision-os-min exists: Cedar, OPA, MCP OAuth, and most agent-governance kits answer may this actor do this? Autonomous systems that act still need a signed, action-bound, one-time grant and a PEP that will not run the tool without it. Prompt rules do not preserve human ownership of the effect. Cedar/OPA stay replaceable PDPs; they cannot mint. The agent never holds the key. Not a Cedar competitor; not an AGI-safety proof. https://github.com/Aliipou/decision-os-min/blob/main/docs/WHY.md |
Uh oh!
There was an error while loading. Please reload this page.
Microsoft’s Agent Governance Toolkit already establishes a strong pre-execution boundary: intercept the action, evaluate policy, verify authority, and preserve an auditable decision before execution.
SCQOS has been independently developing and executing the next boundary I believe is worth testing together: proving that the authorized transition remains continuous from evidence → authorization → execution → confirmed consequence → durable receipt.
The distinction matters because authorization proves that an action was admissible at decision time. It does not necessarily prove that the resulting external state is the state that was authorized.
SCQOS treats a transition as incomplete until the consequence is confirmed against the governing state. If evidence, authority, reference, policy, execution, verification, or receipt generation fails, the transition does not silently inherit PERMIT. It becomes an attributable governed failure state and must requalify.
Current implementation work includes:
• deterministic PERMIT / HOLD / REJECT boundaries
• immutable transition identity
• proposition / evidence / admissibility separation
• explicit authority binding
• causal execution stages
• confirmed-consequence verification
• durable cryptographic receipts
• fail-closed governor-component failure handling
• transition identity bound to a frozen contract-universe hash so both identity continuity and semantic continuity can be tested
I’m not proposing this as a replacement for AGT. I’m putting forward an executable architecture for the boundary after authorization and asking whether the two models expose a useful compositional layer.
The strongest falsification test would be simple: authorize a transition correctly, then introduce stale evidence, an incorrect reference, semantic-state drift, executor failure, verifier failure, or an unconfirmed consequence after authorization. Does the governance chain still prove that the final state belongs to the state that was actually authorized?
SCQOS reference implementation:
https://github.com/KnowledgeeKZA3224/scqos-reference-implementation
I’d welcome maintainers attacking the implementation, identifying overlap with AGT, or showing where this consequence/continuity boundary is already solved more completely inside the toolkit.
All reactions