# Human approval gates for AI agents that fail closed

> An approval gate blocks an agent's outward action until a human approves that exact content. Here are the patterns that fail closed, and how pendpost runs them.

Author: Dominic Frei. Published 2026-11-10, updated 2026-11-10.
Canonical: https://pendpost.com/blog/human-approval-gate-ai-agents

## Key takeaways

- A human approval gate blocks an agent's outward action, such as publishing or sending, until a person approves that exact content.
- Fail closed means a missing, stale or unclear approval stops the action; the default answer is no.
- The agent that drafted something should never be the one that approves it, and only the owner should be able to grant an agent autonomy.
- Bind the approval to a content fingerprint, so an edit after approval sends the item back for review.
- Circuit breakers and a signed audit trail cover what the gate cannot: platform blocks, runaway volume and later disputes.

A human approval gate for AI agents is a check between the agent's decision and any outward action, such as publishing a post or sending a message. The action waits until a person approves that exact content. A good gate fails closed: a missing, stale or self-granted approval stops the action. In practice that takes six rules. Agents create drafts only. The drafting agent cannot approve its own work. An approval covers a content fingerprint, so edits reset it. Only the owner can grant autonomy. Circuit breakers stop volume a platform pushes back on. A signed audit trail records who approved what.

## Why does an approval gate have to fail closed?

A gate has to fail closed because the failures you worry about are the quiet ones. Nobody needs a gate for the case where everything works. You need it for the draft nobody looked at, the edit made after sign-off, or the config flag an agent flipped on itself. If any of those defaults to "publish", the gate only works on good days.

The primary sources agree on the direction. The MCP specification says there should always be a human in the loop with the ability to deny tool invocations, and that clients should prompt for confirmation on sensitive operations ([MCP tools spec](https://modelcontextprotocol.io/specification/2025-06-18/server/tools)). OWASP lists excessive autonomy as a root cause of LLM06 Excessive Agency and recommends a human approving high-impact actions before they are taken. It also recommends doing the authorization in downstream systems "rather than relying on an LLM" to decide ([OWASP LLM06:2025](https://genai.owasp.org/llmrisk/llm062025-excessive-agency/)). That last point is easy to skip. A confirmation prompt in the chat client is a good first layer. The decisive check belongs in the system that actually publishes.

## Which approval gate patterns work, and how do they fail closed?

Each pattern blocks one specific way an agent can get something out the door. The table compares them, with what pendpost ships for each as of November 2026.

| Pattern | What it blocks | Fails closed because | In pendpost |
|---|---|---|---|
| Draft by default | An agent publishing directly | No approval on record means no publish | Every created post is a draft; the publish sweep skips drafts |
| Separate approval authority | An agent approving its own work | Creator equals approver is refused | The actor that created a post cannot approve or reject it; the owner is exempt |
| Content-bound approval | An edit slipping in after sign-off | A fingerprint mismatch means re-approval | Edits flag `editedSinceApproval`; the publish fence refuses the post |
| Owner-only autonomy | An agent granting itself auto-approve | A non-owner change to the policy is refused | Auto-approve is off by default and only the owner can set it |
| Approval expiry | A weeks-old approval firing on a changed world | An aged approval reverts to draft | Owner-only setting, off by default |
| Circuit breaker | Repeated actions into a platform that is blocking you | A recorded block halts the lane until cleared | Meta action-block breaker, cadence cap that defers, three-attempt failure cap |
| Second reviewer | An operator approving on a client's behalf | Without the reviewer's sign-off the post waits | Optional client review link |
| Signed receipt | Later disputes about what went out | Not a gate by itself; proves what passed it | Ed25519 receipt per platform since 2.6.0 |

The receipt row needs a caveat. A receipt proves what happened; it does not decide anything. In pendpost a missing signing key never blocks a publish. The one exception is a mismatch between the saved content and what was approved, which stops the post.

## How does pendpost enforce the gate in code?

pendpost enforces the gate twice: once when someone approves, and again when the publish job is built. I ran the loop over MCP in mock mode to confirm what an agent actually sees. This is the sequence, with the real responses from pendpost 2.8.0.

1. The agent calls `plan_create_post` as `agent:claude`. The post comes back with `approval: "draft"` and `createdBy: "agent:claude"`. There is no argument that creates an approved post.
2. The agent calls `publish_due_run`. It returns an empty list. The draft is due, but it is not approved, so nothing fires.
3. The agent calls `approve_post` as `agent:claude`. It gets `invalid_input`: "agent:claude created this post and cannot approve it (no self-approval)".
4. The owner approves. The approval stores who approved, when, and a hash of the content that was approved.
5. The agent edits the caption. The post now carries `editedSinceApproval: true`, and the next publish run skips it again.
6. The agent tries to switch on auto-approve through `config_set`. It gets "only the owner can change autoApprove (autonomy and publish policy are owner-authorized)".

The second fence lives in the function that builds every publish job ([`lib/publish-job.mjs`](https://github.com/pendpost/pendpost/blob/develop/lib/publish-job.mjs)). It refuses a post that is not approved, one edited after approval, and one whose approver equals its creator, each with its own error code. The scheduler already filters these out. The fence exists for whatever caller comes next, including the cloud runtime, which reuses the same predicate. The [approval docs](https://docs.pendpost.com/approval-and-circuit-breakers) describe the full stack.

Two details are easy to miss. The owner is exempt from the no-self-approval rule, because otherwise a post you wrote yourself in the dashboard could never be approved. And auto-approve does not hand the agent anything. When the owner's policy matches a post, the approval is recorded under a separate actor, `policy:auto-approve`, so the activity feed shows the owner's rule approved it and not the agent. An owner-only `autonomy_revoke` sends every not-yet-published auto-approved post back to review.

## Where does an approval gate stop protecting you?

An approval gate stops protecting you at the edge of identity. In pendpost the actor is a name the caller passes in, such as `agent:claude` or `owner`. The no-self-approval rule reliably stops an agent from approving its own draft under its own name. It does not prove who is behind the name "owner".

That is why the layers matter. pendpost binds to 127.0.0.1, so only processes on your machine reach it. Your MCP client can ask before each tool call (Claude Desktop does by default), which is the confirmation the MCP spec asks clients for. And the `approve_post` tool description tells the agent to call it only on the owner's explicit instruction. Keep the client's prompt on for `approve_post` and `config_set`; an "always allow" on those two collapses the gate into trust.

Separation of duties is an old control for the same reason. NIST SP 800-53 control AC-5 defines access authorizations that keep one party from holding every critical role ([NIST SP 800-53 Rev. 5](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-53r5.pdf)). The agent drafts. Someone else approves. Nothing about that rule is new. What changed is who sits in the drafting seat.

## What do circuit breakers and receipts add to the gate?

They cover the two things a per-item approval cannot see: what the platform is doing right now, and what happened after the fact.

A breaker watches the platform's response. When Meta returns error 368, an action block, pendpost halts the Meta lane, sends no Graph traffic while it is blocked, and never resumes by itself, because 368 carries no machine-readable clear time. A cadence cap defers extra posts in a burst instead of dropping them. A post that keeps failing stops after three attempts. Each one fails closed: the uncertain state is "do not send".

A receipt answers the dispute that comes weeks later: "did it go out the way I approved it?" Since 2.6.0 ([changelog](https://github.com/pendpost/pendpost/blob/develop/CHANGELOG.md)), pendpost signs a receipt per platform with an Ed25519 key that stays on your machine. The receipt binds the approved content hash to the platform's post id. In my mock run, the verify command checked the signature, the chain and the content, and reported all of them as true. Anyone you give the public key to can repeat that check.

## How do you test an approval gate before trusting it?

Try to break it on purpose, in a sandbox, and read the refusals. The [MCP setup guide](https://pendpost.com/blog/connect-claude-to-social-media-mcp) has the mock-mode config. Then ask the agent to do what it should not be able to:

- publish a draft, and expect nothing to fire,
- approve its own draft, and expect a refusal that names the rule,
- edit an approved post and publish, and expect the post to wait,
- enable auto-approve, and expect an owner-only refusal.

If any of those succeed, the gate is a suggestion. The [security page](https://pendpost.com/security) covers what pendpost keeps local, and the [MCP server page](https://pendpost.com/mcp) shows the tools an agent gets. For the shorter, non-technical version of this argument, see [how to let an AI agent post to social media safely](https://pendpost.com/blog/let-an-ai-agent-post-to-social-media-safely).

## Frequently asked questions

### What is the difference between human-in-the-loop and an approval gate?

Human-in-the-loop is the principle that a person can stop an agent's action. An approval gate is one concrete way to build it: the action is held as a draft and only proceeds after an explicit approval. A confirmation prompt in a chat client is a lighter version that relies on the person reading each prompt.

### Can an AI agent approve its own work if the human is busy?

It should not. Let the owner set an auto-approve policy instead, scoped to platforms or campaigns, and record those approvals under the policy's name rather than the agent's. The agent still never approves its own draft, and the owner can switch the policy off and send the backlog back to review.

### Does an approval gate slow publishing down?

It adds one human step per item, which is the point. Batching helps: an agent can draft a week of posts in one session and you approve them in one pass. For low-risk, repetitive items, an owner-set auto-approve rule removes the wait without giving the agent the authority itself.

### What should be logged for an AI agent's outward actions?

At minimum: who created the item, who approved it and when, what content the approval covered, and what the platform returned. pendpost records each step in an activity feed with the actor's name and, since version 2.6.0, signs a receipt per platform that binds the approved content to the platform's post id.


## Sources

- [MCP specification 2025-06-18: Tools (user interaction model and security considerations)](https://modelcontextprotocol.io/specification/2025-06-18/server/tools)
- [OWASP Gen AI Security Project: LLM06:2025 Excessive Agency](https://genai.owasp.org/llmrisk/llm062025-excessive-agency/)
- [NIST SP 800-53 Rev. 5, control AC-5 Separation of Duties](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-53r5.pdf)
- [pendpost CHANGELOG, 2.6.0 signed publish receipts](https://github.com/pendpost/pendpost/blob/develop/CHANGELOG.md)
- [pendpost publish fence source (lib/publish-job.mjs)](https://github.com/pendpost/pendpost/blob/develop/lib/publish-job.mjs)
