A pattern reference · v0.1
Consent patterns for AI agents
Machines act for you now: they open accounts, send messages, spend money. Every team building one is carving its own asking-screens from nothing. This is the shared book: named ways to hand over keys, say yes to a move, set standing rules, and read the trail left behind.Agents act on your behalf: they connect to your accounts, send your messages, spend your money. The consent UX for that delegation is being improvised from scratch by every team that ships an agent. This is the reference: a taxonomy of named patterns for permissions, approval, standing authority, and auditability, each with rationale and a production-quality React implementation.Agents exercise delegated authority: they connect to accounts, send messages, and spend money on a principal’s behalf. The consent UX for that delegation is being independently re-derived by every team shipping one. This is the reference: a pattern language for permissions, approval, standing authority, and auditability, each pattern with its rationale, its anti-patterns, and a production-quality headless React implementation.
What’s here
Three things, one problem
A book of the patterns, real working parts for each one, and a teaching for the machines that write your code.A documented taxonomy, a working implementation of every pattern, and a skill that teaches coding agents to apply them.A documented pattern language, a reference implementation of each pattern, and a distilled skill that carries the same guidance to coding agents.
- 01 · Read
The pattern taxonomy
Twelve patterns, four piles. Each names a recurring trouble and shows the fix: parts, when to use it, screen reader talk, wrong turns, code.Twelve patterns across four categories. Each documents a recurring consent problem: anatomy, when (not) to use it, real-world examples, accessibility, anti-patterns, and code.Twelve patterns across four categories, each documenting a recurring problem and its resolution: anatomy, applicability, accessibility semantics, anti-patterns, and a reference implementation.
Browse the patterns → - 02 · Build
A React library
Every pattern gets a working piece in @agentconsent/react: plain bones, a swappable skin, screen reader friendly, free to take.A working implementation of every pattern in @agentconsent/react: headless primitives plus a themeable default. WCAG 2.2 AA, axe-clean, MIT.A reference implementation of every pattern in @agentconsent/react: headless primitives with a themeable default skin, WCAG 2.2 AA, MIT. The premise: a pattern without a runnable artifact is an opinion.
npm install @agentconsent/react - 03 · Delegate
A skill for coding agents
Hand this teaching to your code-writing machine, and it builds asking-screens right the first time.Install the best-practices skill into Claude Code and your agent applies these patterns when it builds consent flows.A distilled best-practices skill for coding agents: installed into Claude Code, it applies this guidance when generating consent flows.
Claude Code & Codex
View the skill source →/plugin marketplace add mrchaarlie/agent-consent-patterns /plugin install consent-ux@agent-consent-patterns
The taxonomy at a glance
All 12 patterns →Four piles, from first handing over a key to reading the mark left behind.Four categories, tracing the arc from first granting access to reviewing what the agent did.Four categories tracing the delegation lifecycle: conferral, per-action authorization, standing policy, and accountability.
Granting access3
How you hand the machine a key: which key, when, and where you can see what it's already holding.How a user first hands an agent access: at what granularity, when in the task, and where to review it later.The initial conferral of authority: it decomposes scope, defers escalation until need is demonstrated, and keeps granted connections legible.
Approving actions3
Saying yes to one act before it happens: you see the real thing, and acts you can't take back get a heavier gate.Deciding on individual actions before they run: showing the exact act, and matching friction to how reversible it is.Per-action authorization: rendering verbatim parameters, scaling confirmation to recovery cost, and triaging queues without rubber-stamping.
Standing authority3
Yeses that keep working after today: where they live, what limits them, and when they run out.Permissions that persist beyond the current task: how they're set, kept in view, bounded, and ended.Durable delegation: consequence-labeled durability at grant time, an aggregated policy surface, and quantitative limits that reset.
Trust & transparency3
Knowing whose words the machine acts on, what it did after, and never letting it hold your secret.Knowing where a request came from, what the agent did afterward, and keeping secrets out of its reach.Provenance and accountability: surfacing untrusted-instruction origin, recording each exercise, and excluding the agent from credential paths.
New here? Start with Action Preview, the pattern the rest build on.
Reading as an agent? llms.txt