Explainers

Three audiences. Three framings. One protocol. Whether you're evaluating liability exposure, designing a trust boundary, or shipping an SDK integration — start here.

---

The Liability Shield

For CEOs, CFOs, CLOs, and board members evaluating AI governance posture. How AGP converts agent accountability from assertion to cryptographic proof — and shields the organisation from regulatory exposure.

The Liability Shield — 60-Second Script

Hook

Your AI agents are making decisions right now. High-stakes decisions. And there is nothing structurally preventing them from acting on a dangerous instruction.

The Problem

Every AI agent that can take action is a liability — not because the AI is malicious, but because there is no protocol-layer enforcement preventing it from acting outside its mandate. When something goes wrong, you have no audit trail, no proof of authority, and no clear accountability chain. That is a regulatory and legal exposure you cannot afford.

The Solution

AGP is the governance protocol that puts a verifiable, deterministic boundary between every agent action and the real world. Before an agent can execute anything consequential — a payment, a communication, a data change — it must declare intent, prove authority, and pass a policy check. Every step is logged immutably. Every denial is evidence. Every approval is a signed artifact.

The Urgency

Regulators are watching. The EU AI Act, emerging US federal frameworks, and your auditors will demand demonstrable AI governance. AGP lets you demonstrate governance — not just assert it. It is the difference between "we have AI policies" and "here is the signed, timestamped, cryptographically verifiable record of every agent action we have ever taken."

Close

AGP. The Purple Line between your agents and liability. Open specification. Production-ready today.

• Immutable, tamper-evident audit trail for every agent action — approval and denial alike
• Accountability chain maps every action to a named human principal via signed Capability Tokens
• Human-in-the-loop controls are protocol-enforced, not convention-based — agents structurally cannot bypass them
• EU AI Act & regulatory alignment built in — OPA policy engine, evidence bundles, and audit ledger are compliance primitives
• Token revocation is instant — an agent's authority can be terminated in a single API call

---

The Governance Ledger

For solution architects, platform engineers, and security architects evaluating AGP's trust model, fail-closed domain boundaries, and integration surface. How a hash-chained ledger becomes the authoritative record of every agent decision ever made.

The Governance Ledger — 60-Second Script

Hook

Every architecture problem you have with AI agents comes down to one thing: there's no protocol-layer enforcement boundary between an agent's intent and its side effects.

Separation of Concerns

AGP enforces a clean separation across three independent trust domains. Registry handles identity and authority — tasks, capability tokens, liability bindings, delegations, revocations. Decision handles risk and policy — OPA-based evaluation, evidence bundles, impact assessment, human approvals, escalations. Execution is the gate — it validates all prerequisite artifacts before permitting any consequential action. No domain has visibility into the others' internals. Each has its own API surface and authorization scope.

Fail-Closed Design

The execution layer is fail-closed by design. There is no default-permit path. If a capability token is revoked, if policy returns deny, if the approval artifact is missing — the action envelope is rejected with a 403. This is a structural guarantee encoded in the protocol, not a configuration choice that can drift.

MCP Interoperability

AGP is protocol-neutral. The first-class MCP binding maps Model Context Protocol tool calls directly to AGP capability scopes. Every tool call becomes an auditable action envelope. Your existing MCP servers get governance without re-architecture.

Close

Three domains. One protocol. Zero implicit trust. Open specification, open source.

• Three independently deployable trust domains: Registry (identity/authority), Decision (risk/policy), Execution (action/audit)
• Each domain has its own OpenAPI 3.1 spec, OAuth 2.0 scope set, and durability guarantees
• Fail-closed execution layer — no default-permit, no bypass path from outside the server
• OPA/Rego policy engine — bring your own policies or use the included EU AI Act suite
• First-class MCP binding — map tool calls to capability scopes with zero MCP server refactoring
• Delegation chains support multi-agent hierarchies with sub-token scoping and cascade revocation
• JSON Schema 2020-12 for all objects — deterministic validation, no runtime ambiguity

---

Code that Whistleblows

For backend engineers, ML engineers, and AI agent developers who want governance in their stack without rebuilding their agent architecture. How the AGP Escalation Notice turns a dangerous mandate into a protocol-layer whistleblowing event — automatically.

Code that Whistleblows — 60-Second Script

Hook

You're building agents. You're calling APIs. You need governance. Here's how fast you can add it.

Install

Two commands: pip install agp-sdk or npm install @agp-protocol/sdk. Both SDKs handle OAuth 2.0 client credentials automatically — pass a client ID and secret, the SDK manages token refresh. No auth boilerplate.

The Action Envelope Pattern

The core primitive is the Action Envelope. Before any consequential action executes, your agent assembles an envelope: task ID, capability token, policy decision, and — if required — a human approval artifact. Submit it to the execution layer. If all artifacts are valid, you get a 201 with a signed receipt and an immutable ledger entry. If anything is missing or revoked, you get a 403 and a clear, structured error.

Four Calls. Ten Lines.

The full governance flow is four API calls: create a task, attach a capability, run a policy evaluation, submit the envelope. The SDK wraps all of this. The whole flow is ten lines of Python.

MCP

Using MCP tools? The AGP MCP server binding intercepts tool calls and wraps them in the governance pipeline automatically. Zero refactoring of your existing tool definitions required.

Close

Governance that works the way your code already does. Install. Declare. Prove. Execute.

• pip install agp-sdk or npm install @agp-protocol/sdk — OAuth 2.0 handled automatically
• Four API calls for the full governance lifecycle: task → capability → policy → envelope
• Action Envelopes: signed, self-describing bundles that contain all prerequisite artifacts in one object
• 201 on success with signed receipt + ledger entry; 403 on missing/revoked artifacts with structured error payload
• MCP binding: wraps every tool call in the governance pipeline — no refactoring of existing tool definitions
• FastAPI reference server available — run locally or deploy to any cloud provider
• 200+ conformance tests included — verify your implementation against the full spec