No framework required. If it writes to a record, it can answer for it.
The agent you built yourself — raw Python, a bespoke loop, your own orchestration — is the purest case for the standard. GOVENANT doesn’t need your framework, your prompts, or your model. It needs an observable substrate. If your agent’s actions land in a database or an API you can read, it can be measured today.
GOVENANT does not govern “Claude agents” or “OpenAI agents.” It governs the evidence trail of autonomous work. Keep the runner (the tool you audit from) separate from the system under audit (your agents):
An AI client you already use reads the open instrument and drives the read-only sweep. This is the runner — not the thing being judged.
Any agent system with an observable record of actions and outcomes — whatever built it. The agent never has to "support GOVENANT."
Ground truth: the database + actions + outcomes + duties + gates — the substrate, never the logs’ self-report.
You don’t adopt a runtime; you adopt shapes. The open schema (Parts 0–16) tells you what an action row, a duty, and a verified outcome look like — write those from your own code and you conform.
Because GOVENANT governs the substrate, your agent doesn’t integrate with a vendor. It writes an append-only record and keys completion to verified outcomes. The audit reads that record — no SDK lock-in, ever.
The developer integration operates at the action boundary and needs no access to your reasoning loop, prompts, framework, or models. That architectural property is what makes it universal.
A startup built its own agent in raw Python — no framework — running core operations against its own Postgres database.
It works, but there’s no governance story for the enterprise deals in the pipeline: no ledger, no ownership gates, no way to prove to a buyer that the agent delivers what it claims. And no vendor SDK to “adopt.”
They adopt shapes, not a runtime: an append-only action row at the tool boundary, duties keyed to verified outcomes — straight from the open schema. The free audit reads their own Postgres and returns a Delivered-rung record they attach to the next security questionnaire. No framework, no lock-in.
The substrate: Whatever your agent writes to: your database, your queue, your APIs — the durable record of actions and their verified outcomes, in shapes the standard defines and your code already emits.
The path — Instrumented boundary: Add a thin hook at the action boundary — no access to prompts, reasoning, or models — so every action and its outcome is recorded.
The full requirements live in the open standard (CC BY 4.0) — the substrate shapes, the acceptance tests, and the conformance ladder your record is measured against.
From day one of a real integration you can wear the Built-on GOVENANT badge under its four rules. The ladder — Logged → Gated → Delivered → Earned — is self-assessed against the open standard and published to the registry with probe logs, open to anyone’s challenge. No authority hands out stamps; a reproducible record is the point.
Per-stack integration patterns for common ways to build custom & in-house agents — each with its own natural hook into the substrate:
Building it a different way? Browse all integrations — or run the free audit from any MCP-capable tool.