GOVENANT governs substrates, not frameworks — the durable record of what agents did and whether it verifiably delivered. Any stack whose actions can be recorded and verified can be governed. Find yours below: the value, the pattern, and the public issue where the integration is built in the open.
Wrap the loop. Ledger every act. Prove delivery.
LangGraph's checkpointer and node/edge graph give natural interception points; callbacks already carry run IDs, token usage, and tool I/O — everything an action row needs.
The pattern →The SDK's guardrails and handoffs map to ownership gates, and its tracing hooks carry tool-call inputs and outputs for the ledger.
The pattern →PreToolUse and PostToolUse hooks are a ready-made chokepoint: check ownership before the call executes, write the action row after it returns.
The pattern →The conversable-agent message loop is a typed event bus waiting for named consumers; registered reply functions are the chokepoint where the gate and ledger live.
The pattern →Kernel function-invocation filters intercept every skill call — the ownership gate and the ledger write fit in a single filter.
The pattern →Crews, roles, and tasks map one-to-one onto GOVENANT roles and duties; step and task callbacks provide the ledger writes. A crew definition is a duty roster waiting to be made accountable.
The pattern →Workflow steps and instrumentation spans give the interception points; tool outputs become verified outcome rows instead of trusted return values.
The pattern →Pipelines are explicit DAGs — wrap components at the pipeline boundary and every run is ledgered with its inputs, outputs, and cost.
The pattern →Typed, validated outputs are half of the deterministic validation gate already; result validators and tool wrappers supply the ownership gate and the ledger.
The pattern →The workflow engine's steps and retries map to duties and breakers, and its storage layer can host the substrate tables directly.
The pattern →Tool-call middleware and onStepFinish callbacks are the chokepoint; the ledger ships to any SQL store your app already uses.
The pattern →Step callbacks and the tool abstraction give the hooks. Small agents deserve real records too — a governed smolagent outranks an ungoverned fleet.
The pattern →Before- and after-tool callbacks plus session state give the gate and ledger points; on Vertex, the substrate lives in Cloud SQL and the sweep is read-only SQL.
The pattern →“Done” lives in the database, not in the model’s mouth.
Hooks make ownership gates enforceable per tool call, and the hosted GOVENANT Audit connects to Claude Code today as an MCP server — this is the shortest path in the whole catalog.
The pattern →Cursor speaks MCP, so the hosted GOVENANT Audit connects today; rules plus a governed substrate turn agent-written code into outcome-keyed, verified delivery.
The pattern →Copilot's pull requests are verifiable terminal outcomes. Govern the repo, not the model: branch protections act as ownership gates, and merged-plus-green is the outcome row.
The pattern →Devin's sessions end in pull requests — auditable terminal outcomes. Wrap its task dispatch in a duty roster so every assigned task has an owner and a verified completion.
The pattern →Codex tasks end in diffs and pull requests, so outcome-keyed completion is native; the Codex CLI also connects to the hosted GOVENANT Audit as an MCP client today.
The pattern →Windsurf's Cascade speaks MCP, so the hosted GOVENANT Audit connects today; governed substrate tables turn agentic flows into verified, ledgered delivery.
The pattern →Priiism operates as a governed tenant of the standard's reference implementation — the live existence proof for this entire class. Its definition of done lives in the database, not in the model's mouth.
The pattern →Your platform already keeps the record. We make it prove things.
Agentforce actions and flows already log to Salesforce objects; a schema mapping over those objects lets the sweep read what the platform already records — the org's own data becomes the substrate of record.
The pattern →Topics and actions log to Dataverse; map those tables once and the battery runs read-only over what Power Platform already captures.
The pattern →The platform's workflow audit trail is substrate-shaped out of the box; map the tables, run the sweep, and put conformance verdicts next to the dashboards operators already trust.
The pattern →Trace events plus CloudWatch and CloudTrail records map to the action ledger; action groups are levers, with IAM as the ownership gate's enforcement arm.
The pattern →Agent traces and BigQuery logging make the schema mapping a SQL view; the sweep runs as read-only BigQuery, and verdicts land where your analysts already work.
The pattern →Zap runs and task history are an action ledger already; a mapping plus a duty roster over scheduled Zaps yields the coverage tests — including the misses.
The pattern →The execution log in Postgres is directly sweepable: workflows become duties, executions become duty-runs, and error workflows become the independent watchdog.
The pattern →Scenario execution logs map to duty-runs, and incomplete executions become the honest miss log — the number most automation dashboards quietly omit.
The pattern →Agent runs and tool logs map to the ledger; the multi-agent workforce framing is a duty roster asking to be made accountable, role by role.
The pattern →Assistant run logs map to action rows, and spaces with access controls align naturally with ownership gates.
The pattern →Each Lindy is a role with a charter; make the charter map to duties, key completion to verified outcomes, and the sweep tells you which Lindies actually deliver.
The pattern →Flow runs map to duty-runs and the node I/O record is the action ledger; governance is a mapping away, not a rebuild.
The pattern →Every call verified. Misses included.
Every call is a duty-run with a transcript, an end reason, and an outcome. Map call records to outcome rows and the coverage math runs on real conversations — misses included.
The pattern →Call analytics and post-call webhooks feed the outcome rows; missed and failed calls become the honest miss log that earns customer trust.
The pattern →Session events and egress give the record; the standard upgrades "the call happened" to "the caller's need was verifiably handled."
The pattern →Conversation history and evaluation criteria map to outcome rows and validation gates; every conversation gets graded against the record, not the vibe.
The pattern →Outcome-based pricing already prices exactly what GOVENANT measures — verified resolution. A conformance record makes that claim inspectable by every buyer.
The pattern →Resolution metrics become sweepable outcome rows, and the independent watchdog writes down what a dashboard would rather smooth over.
The pattern →Fin's resolutions feed outcome rows; the delta between "answered" and "resolved, verified against the record" is precisely the performed-autonomy gap the audit measures.
The pattern →From bot logs to proof of delivery.
Orchestrator is substrate-shaped: queues are duty rosters, job results are duty-runs, exceptions are the miss log. Agentic automation inherits a governance record RPA teams already half-keep.
The pattern →Control Room audit logs map to the action ledger, and bot schedules are duties with outcome-keyed completion.
The pattern →Temporal's event history IS an append-only action ledger — likely the cheapest path to Tier-1 conformance in this catalog. Workflows are duties; activities are levers.
The pattern →Function runs, steps, and flow control give the record; cron functions are duties and the failure path is the miss log, kept honestly.
The pattern →Govern the pipes once. Govern every client.
A governing MCP gateway ledgers every tool call and enforces ownership gates for any MCP-speaking agent, regardless of framework — govern the pipes once, govern every client.
The pattern →A2A tasks and artifacts are typed events with named consumers — the standard's event-bus requirement expressed as an interop protocol. Ledger at the task boundary and inter-agent work becomes provable.
The pattern →Every integration here is built in the open, and every shipped one gets co-marketed: a maintained page on this site, a listing path into the public registry, and inbound “govern my agents” demand for your stack routed to the people who built its integration. If your platform’s users need to prove their agents deliver — and they will — the fastest way to own that answer is to build it with us.