Skip to content
Agentic Control Plane
AgentGovBench · open benchmark

ACP's score, out of all 48.

AgentGovBench tests what governance happens when an agent makes a tool call: identity, policy, delegation, rate limits, audit, tenant isolation, failure behaviour, scope. A scheduled job runs it against production daily (13:17 UTC); the number below is from the latest run. We publish the number with every scenario that did not pass.

46/48 as of 8 October 2026 · that day's run

Not passed: scope_inheritance.04 (task-scoped narrowing for sub-agents isn't built yet) and fail_mode_discipline.05 (when ACP is unreachable, the plugin's offline record of the call doesn't name the user). Both count as failures.

Method

How the number is counted.

Live production, daily
A CI job on a daily schedule runs the scenarios against api.agenticcontrolplane.com using keys on two dedicated benchmark workspaces. It cannot touch a real workspace. Each run is public. Calls made as a particular user go through a benchmark-only impersonation endpoint on the production gateway, with the user named in the request; that is how one key can act as many users. The two benchmark workspaces are both ACP's own, so “cross-tenant” means two separate workspaces, not two customers.
Out of 48, no exclusions
The denominator is every scenario in the repo. A scenario ACP declines counts as a failure. A scenario nobody measured counts against the score too. There is no “not applicable” in the published number.
Runner-neutral scoring
The scorer does not know which product it is scoring. Evidence the test harness wrote itself is stripped before any check runs; only what the product recorded or decided counts.
Deterministic
No model in the loop. Tool calls are scripted, so anyone gets the same inputs. Each scenario cites the NIST AI RMF control it exercises.

Which runner measures which scenarios

Each scenario is scored by the runner that can truly exercise it, and the daily scorecard labels which one that was.

Categories Scenarios Measured by
Identity propagation, per-user policy, delegation provenance, rate-limit cascade, scope inheritance, audit completeness36acp_api: HTTP runner, live against production
Cross-tenant isolation6acp_api with two real benchmark workspaces, one key each
Fail-mode discipline6claude_code_hook: the real Claude Code hook, with ACP unreachable

How we test outages: we make ACP unreachable and watch what the real hook does. The hook is the file we ship, untouched. We point it at a dead address using the plugin's own test setting. If someone's at the keyboard, it fails open. If nobody's watching, it fails closed. That's how the plugin works today; there's no per-workspace setting for it yet. When ACP "comes back" in these tests, a simple local stand-in answers, because we're testing the hook here, not our policy engine.

Counted as a failure

Two scenarios ACP does not pass yet.

scope_inheritance.04, task narrowing. A parent agent hands a sub-agent a narrower task, for example “summarise this one file”. The sub-agent should then be held to that task, not to everything the parent was allowed to do. ACP does not do this yet: a sub-agent gets its parent's permissions. It is on the roadmap, not built, and it counts as a failure in the score.

Any other scenario that does not pass on a given day is named in that day's run summary with the check that failed. One is known today: fail_mode_discipline.05 asks the audit record of a call that ran while ACP was unreachable to name the user, and the client has no way to know the user at that moment, so the record carries none. We count it against the score rather than adjust the check.

Reproduce it

Reproduce it with one command (about 15 minutes).

  1. Sign in to the ACP console, open API Keys, and click Create benchmark workspaces. It makes two throwaway workspaces (the second is needed for the cross-tenant scenarios). Workspace B is administered by a synthetic admin account the card creates, so the cross-tenant scenarios run between two workspaces with different admins. The card shows a 24-hour key for each, once. Your real workspace's policy is never read or changed.
  2. Copy the command the card prints and run it (needs Python 3.10+, Node 18+, git):
git clone https://github.com/agentic-control-plane/agentgovbench && cd agentgovbench
export ACP_API_KEY=gsk_...            # workspace A, from the card
export ACP_TENANT_SLUG=yourslug-agb
export ACP_API_KEY_B=gsk_...          # workspace B, from the card
export ACP_TENANT_SLUG_B=yourslug-agb-b
./scripts/reproduce.sh

One script runs all 48: the live run against both workspaces, the real shipped Claude Code hook with ACP unreachable (no account needed for that part), then a merged scorecard that prints ACP X/48 and records which hook commit was measured. You get your own number; every non-pass is named. Details are in the README. Got a different number? Either your ACP version differs or you found a gap we have not seen; file an issue.

Earlier per-framework results (CrewAI, LangGraph, Claude Code, OpenAI and Anthropic Agent SDKs, Cursor, Codex) came from the first release in April 2026, before runner-neutral scoring and the daily run. They have not been re-measured, so they are not shown here. The write-up is still available as history; do not compare it with the score above. Method: how we test agent governance and METHODOLOGY.md.