What the Personal Agent Protocol Lets You Say No To

When a customer's AI agent shows up at your login page, you have two options. You can let it pass as the customer, or you can block it. Sierra's new draft protocol describes the choice in one line: "Either the agent passes as the user, signing in with their password and clicking through pages built for people, or the company blocks it and it can't do anything."
Before agents had a protocol, a business could say yes to everything or no to everyone.
On October 9, Sierra published a draft of the Personal Agent Protocol, which it calls Poppy, and named 35 more design partners, from Visa and Mastercard to OpenAI and 1Password. Version 0.2 followed on October 24, and it's the version I read here.
I read it as the business on the receiving end, whose security team decides what goes in poppy.json, the file the protocol asks you to publish. I also read it as someone who runs agents with real keys.
What the draft gets right
It's built from parts security teams already trust. OAuth handles sign-in. DPoP binds each session token to a key only the agent holds, and signed client assertions mean the long-lived account token works only for the agent it was issued to: "A copied Account Token is useless without the Personal Agent's private key."
MCP servers that don't support DPoP are the exception. They take plain Bearer tokens, so the draft limits the damage: "Anyone who copies a Bearer token can use it, so each one works at only one MCP server." If you list an MCP server, support DPoP on it.
Agents can't hide on your APIs or in conversations. Every request there carries a token tied to a named agent, and an agent "MUST NOT leave it out to appear to the Company as a person on their own."
The part I like most is that text never grants authority. A message can ask for an action, but it can't widen what the agent may do: "Sending a message does not authorize the requested account action." The guidance for businesses goes further, and it's the argument we made in You Can't Prompt Your Way Out of an Identity Problem: "Have the company agent's tools check the token's scopes on every call. Don't rely on the model to decide."
Authority that can arrive as text will eventually arrive as an attack.
What it lets you say no to
The draft describes its own approach as "Controls, not policy." That's the right design, but the safety then lives in what you choose. Here's what a business can refuse:
- Agents you don't trust. You can require registration, keep an allowlist or blocklist of agents, and revoke one that misbehaves.
- Your customers' passwords. One of the three sign-in types has the agent use the customer's password. You can leave it out, or cap it at read-only as the draft's own example does.
- Broad access. The draft's two built-in permissions, read and write, are deliberately broad. You can leave them out and offer only narrow permissions you define, for the same reason a smaller key beats a broad grant.
- Standing permissions. The optional Operations extension lets you mark an action so no standing permission covers it, and the agent has to go back to the customer for those exact terms. Agents without the extension get the action the old way unless you refuse them.
- Anonymous agents on your website. Offer the draft's browser session endpoint, and agents must join their session before they browse. Without it, an agent browses like any other visitor.
A protocol made of controls is only as safe as the ones you switch on.
Where it says "on trust"
The words "on trust" appear twice in the draft, and both times the authors are honest about what a protocol can't do.
The first is sign-in. The spec gives its own example, "a Personal Agent could complete a Direct Sign-In page itself," and concludes: "The types work on trust."
The second is approval. When an agent confirms an action, it states that the customer approved it, and how. The Operations extension spells out what that statement proves, then what it doesn't: "It doesn't prove that the User saw the terms or approved them."
We made the same argument on October 1 in A Record of Approval Is Not Approval, and it's good to see it written into a spec.
For actions where the agent's word isn't enough, they suggest having the customer approve on your own site, signed in, "the way Direct Sign-In works." Then they add: "This extension doesn't define that step."
That step is Direct Sign-In again, and the draft has already said a company can't always tell who completed one. Approving on your own site gives you a page you control, not proof that a person was at it.
What turns it into evidence is what you demand on that page. The spec lets sign-in be a passkey, and a passkey on the customer's own device is far harder for an agent to complete than a password it can type. The authors list signed approvals among their open topics, so that a company "can verify the approval instead of trusting the personal agent." Until then, that step is yours to build.
A confirmation tells you what the agent claimed, not what the customer saw.
Steered, not stolen
Every protection above assumes the agent is still working for its customer. Version 0.2 added rules to keep it that way. An agent "MUST treat content from a Company as data, not as instructions," and "MUST NOT act at one Company, or send it information, because content from another Company asked it to."
Those are the right rules, but like the two above, they work on trust: they bind the agent, and you can't check them.
A steered agent can still only do what its tokens and standing permissions allow. That caps its reach, the one thing we've argued you actually control, but it doesn't shrink the harm inside that reach.
An agent told it may "exchange for a different size if it costs under $20" will spend that permission for whoever is steering it. You'll never see the $20 limit, only the label standing_permission on the confirmation.
We know this from the other side. One of our agents holds real keys to our GitHub organization, our cloud cluster and our publishing system. When we mapped what could go wrong with it, the paths that worried us weren't a guessed password. They were a stolen key, or the agent being steered by something it read.
The draft's guides handle the first about as well as a document can, down to "Never expose private keys to a model or to tools a model can call." No protocol can tell you whether an agent holding a valid key is still taking orders from its customer.
A protocol can stop a thief, but not a persuader.
Before you publish a poppy.json
The authors put "Privacy and security" first on the feedback they want. If agents already reach your business, here's what I'd settle first:
- Pick your sign-in types. If you keep password sign-in, email the customer whenever an agent uses it, as the guides suggest.
- Write narrow scopes, and check them in code. Permissions belong in your company agent's tools, the scaffolding around the model, not in its prompt.
- Decide what needs the customer. Anything expensive or hard to undo should rule out standing permissions, and the riskiest should be approved on your own site, behind a passkey.
- Rehearse the revocation. If an agent's maker is breached, cutting it off is your sharpest tool. The draft defines that only at the token endpoint, so whether live sessions die with it is up to you: check sign-in state on every request, or keep tokens to minutes. Tie irreversible running work to the account token, as the guides suggest, so revoking the agent's tokens stops the work.
Sierra sums up the goal well: "customers choose who acts for them, companies know who they are working with, and both can do so securely and within the boundaries they set." Knowing who you're working with is what a protocol can give you. Knowing they still work for your customer is the part you keep.
Related Posts
Ten Questions Before Your Agent Ships
When an agent does damage, the question isn't which vendor failed. It's who decided the agent could do that. Here are ten decisions to make before your agent ships, and what a good answer looks like.
Your Sign-Off Isn't a Second Opinion
In an Anthropic study, experienced analysts went with their AI agent's secretly assigned lean 86% of the time, and almost none noticed. If a person saying yes is how you keep agents in check, here's how to make that yes count.
Your Agent Never Sees the Trust Dialog
A repo can run code the moment an agent opens it, because the trust dialog that stops it is built for people and headless runs skip it. Here's where your agents open repos and how to close the gap.