Update (2026-11-15): Reorganized to follow the order of PAP’s Operations extension, and shortened. Since the November 14 revision for PAP 1.0, a charge on an action listed without
max_amountis refused, the two company modes are named and the stricter one also withholds an unscoped browser sign-in, the limits include an outcome still unknown when a Mission ends, and the asks to PAP gain two for mandates.
This page specifies the extension that
A Mission the Company Can Check
proposes, in PAP 1.0
terms. Its name is karlmcguinness.com/mission, version 1, under the
domain prefix PAP requires of extensions it does not define itself
(spec section 3.3). It requires the Operations extension, version 3.
PAP lets an agent approve an operation “on an instruction the User gave it,” and the company never sees that instruction (Operations sections 5 and 8.1). A Mission is the User’s instruction, approved on the company’s own sign-in page, which the company checks when the agent’s approval arrives. PAP’s roadmap lists approval “on the Company’s own page or in its app” as one approach to signed approvals, and says that mandates, “where the User signs once for a class of actions with limits,” would build on it. This extension applies that approach to the User’s instruction rather than to each revision. It does not verify a per-revision user approval, which other proposals on the roadmap address.
Version 1 limits each operation. It does not enforce a total amount or a number of operations across the Mission. After a Mission ends, the agent does not look up outcomes with another credential, so an outcome still unknown at the end is left to the User, in the company’s account settings. Governed actions sit at an API or an MCP server; conversations with the Company Agent and operations on websites are outside version 1.
It is a proposal, and neither PAP nor the Mission drafts have adopted it. It profiles two of my Mission-Bound Authorization drafts, the OAuth binding and the Resource Access Profile, and defines nothing they already define. The design note behind it was revised for PAP 1.0 on November 14, 2026. The examples continue PAP’s own jacket exchange. It adds no endpoint, no approval member, and no error code, and keeps PAP 1.0’s approval format. Its work falls on the company’s authorization server and resource server: Mission issuance, structured authority, action contracts, enforcement on every governed path, and revocation serialized with admission.
| Party | Responsibility | Where |
|---|---|---|
| Company authorization server | Accept the Mission request at sign-in, show its limits on the consent page, store the Mission, and issue tokens tied to it | Signing In, Tokens |
| Company actions service | Host the governed actions at a service with its own resource identifier (spec section 4.5), an API or an MCP server, and check each approval against the Mission | Requesting and Approving an Operation, What the Company Checks |
| Company account settings | List the agent’s active Missions, each with its goal, what was performed under it, and a revoke control | Ending a Mission |
| Company prerequisites | A read scope hinted changes: "none" that covers the reads a governed task needs, and DPoP at the actions service | Advertising Support |
| Personal Agent | Discover the extension, sign in once per task, keep each task’s tokens in its trusted runtime rather than the model, approve under the Mission token, answer refusals as listed, and revoke the Mission when the task ends | Mission Refusals, Retries and At Most Once |
| PAP core | No change for agents and companies that do not use the extension. For Mission grants it departs from three PAP rules: a Mission grant covers only the services its authority names, the actions service checks the carried entries in place of scopes, and the agent answers insufficient_scope without asking for scopes | Asks 3, 5, and 6 in What PAP Could Add |
Advertising Support
The company lists the extension in poppy.json beside operations,
with an entry for each major version it supports:
| |
The operations entry lists no endpoint, because this company returns
no operations on its website.
actionsmaps each action the company governs to the services where the agent requests it and the constraint keys the company enforces. Each entry inresourcesis a service with its own resource identifier, which its protected resource metadata names, and a Mission entry for the action names one of them.max_amountandtime_windowhave their Resource Access Profile meanings, and the amountmax_amountbounds is the action’s net charge. Any other key names atermskey and constrains that term to equal the given value.- An action listed with
max_amountis chargeable, and the authorization server refuses an entry that grants it without one. An action listed withoutmax_amountcarries no charge at all, not even a deduction from a refund. - Version 1 never lists
requires_action_approval. Itstruevalue needs a verifiable approval of each action, and a user approval is the agent’s statement. The authorization server refuses an entry carryingtrue, never grants it with the key dropped, and the actions service fails such an entry closed. An entry carryingfalseis granted without the key, which removes nothing. - Each governed action has a contract version: its documented
meaning, the complete set of
termskeys that describe its effects, and, for a chargeable action, how its net charge is computed. The authorization server records the version current at approval in the Mission, and the actions service evaluates every approval against it. A changed contract needs a new Mission. The version stays in the company’s own record, so nothing changes on the wire. Where the company’s configuration requires a contract reference for the actions service, the Resource Access Profile has the authorization server record it in the entry asresource_contract. - Read scope. PAP requires
scopeon every sign-in and grants at least one scope (spec section 4.7), and the OAuth binding projects a scope only from a carried entry and refuses a requested scope for a service that consumesauthorization_details. So the agent requests, for the default resource, company scopes hintedchanges: "none"that the task’s reads need, such asorders:read, and the authority proposal carries a read entry they project from. Those reads include the effects of the governed actions, such as the order, which is how the agent settles an outcome in doubt. A company with no such scope cannot offer this extension. - The actions service consumes
authorization_details. Its tokens carry the action entries and noscope. The default resource and the actions service are different audiences, so each follows one rule.
The authorization server advertises mission_bound_authorization_supported,
which obliges it to publish a pushed authorization request endpoint and
to list mission_resource_access among its
authorization_details_types_supported. The agent declares both
extensions on every request in the Session (spec section 3.4):
| |
The company also recognizes a Mission from the token itself, so it never refuses a request for lacking the Mission declaration alone. The operation itself carries nothing new; the company knows the action from the request it computed the operation from.
When support is absent. Before signing in, the agent stops and tells
the User when the company does not list both Operations version 3 and
the extension, and it never submits the Mission’s authority as bare
scope or authorization_details to a company that does not support
Missions. Operations forbids returning an operation to a request that
does not declare version 3, so under a Mission token the actions service
refuses such a request: an API with extension_required naming
operations, an MCP tool with an ordinary tool error.
Signing In
The agent pushes its request through PAR (RFC 9126), which PAP lets a
company require and tells agents to use whenever the metadata lists the
endpoint (spec section 4.2), then opens the company’s Direct Sign-In
page with the returned request_uri. The pushed request carries:
| Parameter | Value |
|---|---|
DPoP header | A proof, so the company can bind the code to the agent’s key |
response_type, client_id, redirect_uri, state, PKCE | As in any PAP Direct Sign-In |
scope | orders:read, the company’s read scope |
prompt | consent, PAP’s rule unless the redirect returns only to the device that opened the authorization URL |
mission_intent | The task’s goal, target resources, and expiry |
authorization_details | The proposed authority, below |
client_assertion | The agent’s private_key_jwt |
resource | Absent, as PAP recommends |
A Mission grant still covers only the resources its authority names: a
later token request for another service gets invalid_target. That
departs from PAP’s rule that a sign-in without resource covers every
service the company offers (spec section 4.5), and ask 5 would allow it.
A task that needs to read at another service, such as an MCP server for
product search, carries a read entry for it.
The Mission intent:
| |
The proposed authority, one entry for the reads and one for the action:
| |
One entry per action suffices. Operations version 3 has no cancel, reads an operation’s status only at the website endpoint, and performs nothing for a request without an approval, so the cap applies when an approval arrives, and the agent can still see a quote above it.
The agent never drops a limit the company cannot hold. It maps every limit the User set to a key the company lists for the action. When a limit has no listed key, it tells the User which limit the company cannot hold and proceeds only on the User’s choice, taken in its own interface: the task without that limit, which the consent page then shows as the broader authority it is; approval of each revision by the User under an ordinary token, outside this extension; or not proceeding.
The User signs in, in the way PAP requires (“only when the User signs in themselves,” spec section 5.4), and reviews the task and its authority:
See your orders. Exchange item itm_4Qa on order ord_7Hk2 for Stormline Insulated Jacket (M), for at most $75.00 more after the credit for this jacket, fees and tax included. Until 4 p.m. Pacific on November 15.
The code exchange is PAP’s, unchanged.
Device Sign-In. An agent that cannot receive a redirect uses Device
Sign-In (spec section 4.3) under the
Mission Device Authorization
companion, which is experimental and opt-in. The device authorization
request carries mission_intent and authorization_details along with
the scope PAP requires, the User approves on the company’s page on a
second device, and polling returns the Mission-bound tokens. The agent
uses it only where the authorization server advertises
mission_device_authorization_supported beside
mission_bound_authorization_supported. Device Sign-In’s phishing risk
applies unchanged.
Tokens
The code exchange returns PAP’s response, with the Mission’s members and the read entry:
| |
The agent then refreshes with resource=https://api.example.com/actions
for a token at the actions service (spec section 4.5), which carries the
granted exchange entry:
| |
- A separate grant. The Mission refresh token is a grant of its own, beside any ordinary refresh token or another Mission’s, and replaces none of them. PAP’s replacement rule is for a sign-in that asks for more access in place of an existing grant, so the agent revokes nothing because of a Mission sign-in, and revoking one Mission never ends another or the agent’s ordinary access. Sign-out still means revoking all of them (spec section 5.5).
- DPoP binding. Client authentication alone is weaker here: when a User’s device can get client assertions, a refresh token copied from one User works for another User of the same agent (spec section 10.7). So the agent sends DPoP proofs with its Mission sign-in and refreshes, with a key it uses for that User only, and the company binds the Mission refresh token, and the actions-service tokens, to that key. A read token the default resource accepts as Bearer is not protected this way, and a service that accepts only Bearer tokens can serve the read scope but cannot host governed actions.
- The actions-service token carries no
scope. Under PAP, an omittedscopewould read as the requested scopes granted. The response reports the grant inauthorization_details, and the agent reads that for this token. - No token outlives
mission_expires_at. - Access tokens stay opaque to the agent: a JWT, or an opaque token the company resolves through introspection or, where the service sits inside the issuer’s trusted boundary, locally.
- Sessions are not constrained. A refresh token serves any of the User’s Sessions, so a Mission does too. Giving each task its own Session keeps carts and conversations apart, and nothing depends on it, except that a Session using a Mission declares Operations version 3.
Requesting and Approving an Operation
At the default resource, a Mission token carries only the read scope, so
every write endpoint there already refuses it with
insufficient_scope. So does the Company Agent, which version 1 never
makes an actions service, because a signed-in conversation respects the
token’s scopes. At the actions service, the extension adds two rules:
- Every governed action returns an operation. A request under a
Mission token without an approval performs nothing. The service
returns
approval_requiredwith the operation when a granted entry names the operation’s action, whatever its constraints, so the agent can show the User a $90 quote without being able to have it performed. - An action the service does not govern is refused. No entry names
it, so the service refuses with
insufficient_scopeandmission_denial="insufficient_authority", and returns no operation.
Together these keep a Mission token from performing anything the agent meant only to ask about.
The approval is PAP’s, unchanged: the same request again, with the
approval in Poppy-Approval:
| |
An MCP server already takes tokens for its own resource (spec section
7), so it can be the actions service. Its tools return operations as
error results and take approvals in _meta, and a Mission entry names
the server’s url. An MCP server that accepts only Bearer tokens cannot
host governed actions.
What the Company Checks
After PAP’s Session and token checks, the company proceeds in order:
- A token without a Mission. PAP applies as usual, except that once
Operations’ own checks pass, a company in Mission-required mode
(Security Considerations and Limits)
declines an agent approval for an action it governs with
approval_declined. - Mission state, on every request. If the Mission is not active or
has expired, the request is refused with
invalid_token. - The action. The company computes the operation the request asks
for. If no granted entry names its action, it refuses with
insufficient_scopeandmission_denial="insufficient_authority". A request with no approval getsapproval_requiredwith the operation. - Coverage. A revision that carries a charge, including a
deduction from a refund, for an action the company lists without
max_amountis refused withinsufficient_authority. Otherwise, an entry with a key orresource_matchthe company does not enforce for the action gives no authority, and another entry the company can fully enforce may still authorize the whole request on its own. Entries are alternatives, never combined, so their order never changes the outcome. If no entry covers the revision, the company refuses withinsufficient_scope, and withmission_denial="constraint_unrecognized"when only unenforceable entries named the action,"insufficient_authority"otherwise. - The contract version. A revision whose
termscarry a key outside the version the Mission recorded, or that needs a different version, is refused withinsufficient_authority. - Operations’ checks. The Session can approve the operation, it has not been performed, and the revision is one the company returned, unexpired, and matching the request; a failure is answered as Operations says.
- Admission, in one transaction that locks the Mission. Revocation
takes the same lock. At that instant the approved revision must be
unexpired, the Mission active and before its expiry, and any covering
time_windowopen. The company rechecks its own eligibility rules that depend on changing state, such as one exchange per order item, and declines withapproval_declinedif one fails. It then claims the operation with one compare-and-set on its at-most-once record, the record Operations already requires, from unclaimed to being performed, with the Mission. If the claim fails, another approval holds it, and the company answers as Operations section 7 says. Otherwise it performs the action once.
A constraint holds when:
| Key | Holds when |
|---|---|
max_amount | The revision’s net charge, as the recorded contract version computes it, is at most the value in the same currency, as an exact decimal |
time_window | The admission instant is inside the window |
| Any other enforced key | The revision’s terms value equals the constraint’s value |
The net charge is every amount the User pays, every fee and tax included, plus any deduction from a credit, minus the credits. For the exchange, it is the replacement’s price less the credit for the returned jacket, plus fees and tax. A fee added in a later revision, including one taken out of a refund, counts against the cap.
- The Mission checks are token checks. Operations makes its own
checks after the token checks in spec section 7, so a Mission refusal
is the resource server’s enforcement of the token’s carried authority
and uses the OAuth binding’s
insufficient_scope. At the actions service the covering entries stand in for the scope check PAP makes for an ordinary token, one of the three PAP rules a Mission grant departs from. - The Mission in force is the token’s. The Mission checked is always the one whose token accompanies the approval, never the one under which the operation was returned.
- A Mission token acts only within its Mission, whatever
approversays. If the User wants a revision the Mission does not cover, the remedy is a new Mission.
A performed action’s response is the action’s own, with nothing added.
The company records the Mission with each operation it performs under
it, in the OAuth binding’s mission claim shape
({ "id": "msn_8RfX2Lqv9TqM", "issuer": "https://auth.example.com" }),
and shows those operations against the Mission in account settings.
Mission Refusals
A failed Mission check is a token refusal. For Mission tokens only, the
extension replaces PAP’s usual response to insufficient_scope, a
refresh or a new sign-in for the named scopes. Only an agent that
declares the extension holds Mission tokens, so every agent this reaches
implements it.
| Condition | Response | What the agent does |
|---|---|---|
| Mission token: no granted entry names the action, or none covers the approved request (amount, terms, contract version, time window) | 403, WWW-Authenticate: DPoP error="insufficient_scope", mission_denial="insufficient_authority", no scope attribute; no operation | Requests no more scopes, retries with no other credential, does not approve that revision again under this Mission, and tells the User |
Mission token: an entry names the action with a key or resource_match the company does not enforce, and no fully enforceable entry covers the request | 403, … mission_denial="constraint_unrecognized", no scope; no operation | The same |
| Mission token at a write endpoint of the default resource | 403, DPoP error="insufficient_scope", with mission_denial="insufficient_authority" and no scope where the endpoint recognizes the Mission token; the body the endpoint returns today | The same, with or without mission_denial or a scope attribute |
| Mission token with the Company Agent | 200 or 202 with an authorization event (spec section 8.11) | The same |
| Mission not active or expired, on any request or at admission | 401, DPoP error="invalid_token" | Refreshes once; if the refresh fails, with or without mission_error, stops the task |
| Mission token at an API, on a request that does not declare Operations version 3 | 403 with extension_required naming operations; an MCP tool returns an ordinary tool error | Not reached by an agent that declares both extensions on every request |
At an MCP server, a Mission refusal is the same challenge on the HTTP
response, with resource_metadata. The refusal carries no scope
attribute, because no scope remedies it; RFC 6750 makes the attribute
optional. The company sends mission_denial only to a validly signed,
audience-correct Mission token, and an agent treats a value it does not
recognize as insufficient_authority. Proceeding after a Mission
refusal needs a new Mission, or the User acting on their own authority.
Stopping keeps any ordinary credential the agent holds out of the task; the OAuth binding forbids a client acting under a Mission to present one for it, unless a trusted enforcement path establishes the Mission for that request and applies its controls, which an ordinary request to the company does not. The User may separately choose an ordinary PAP workflow, under an ordinary token with a user approval of each revision, at a resource the company has not made Mission-governed. That is the User’s choice, never the agent’s fallback after a refusal. Under an ordinary token the agent cannot assume that a request returns an operation rather than performing the action, so it asks the User before sending any request the company does not document as returning one.
Declining an Approval
approval_declined keeps its PAP meaning, and the company returns it in
two cases:
| Condition | Response |
|---|---|
| Ordinary token, agent approval, for a governed action in Mission-required mode | 403 with approval_declined |
| A company eligibility rule fails at admission | 403 with approval_declined, and a reason saying nothing was changed |
On either, the agent follows Operations section 6: it does not send the approval again and approves no new revision for the action without asking the User.
Retries and At Most Once
One claim per operation, across every approval path. An operation can be approved under any Mission whose token accompanies the approval, or under an ordinary token, so every path claims it through the same compare-and-set at admission. The claim comes after every Mission check, so a refused or declined approval claims nothing, and two approvals of one operation under different Missions perform it once.
An unknown outcome. When an approval’s outcome is unknown, after a
timeout or a 503, the agent resends the same approval, never a new
one. If the company then answers with a new operation, which says
nothing about the first, the agent reads the order with the Mission’s
read token before approving anything new. If the order shows the action
performed, the task is done; if the read cannot settle it, the agent
tells the User and approves nothing new.
Ending a Mission
A Mission ends at its expiry, when the User revokes it in account settings, which the OAuth binding requires as an authenticated means to revoke it, or when the agent revokes the Mission refresh token at PAP’s RFC 7009 endpoint (spec section 4.6), which it does when the task completes. Revoking one refresh token is not sign-out while the agent holds others for the account, and disconnecting the agent still revokes everything.
Afterward:
- The Mission’s access tokens fail with
invalid_token, because the company checks Mission state on each request, and refresh fails withinvalid_grantandmission_errorset torevokedorexpired. - An approval racing the revocation is admitted only if it committed before the company acknowledged the revocation.
- Operations performed before the end stand; authority was checked when they were admitted.
- An operation returned but not performed stays unperformed, and the agent does not approve it under another credential.
- An operation whose outcome was in doubt stays unresolved until its outcome is established. The agent settles outcomes while the Mission is active. After it ends, the outcome shows in account settings against the Mission, and the agent does not look it up with another credential (Mission Refusals gives the reason).
- Other Missions are unaffected, because each is a separate grant.
Ending a Mission ends the authority to make new commitments under it. It does not end the record of commitments already admitted, which the company keeps and the User sees.
Security Considerations and Limits
Other credentials. The extension bounds Mission tokens, not the
agent. An agent that holds an ordinary write-capable credential at the
company can approve with approver="user" on its own word; the OAuth
binding forbids this for a Mission’s task, but the company cannot
observe the violation. A company that enforces only what is done under a
Mission token is in Mission-aware mode. A company in Mission-required
mode closes the gap with two policies together: it declines agent
approvals under ordinary tokens for governed actions, and it issues
agents no write-capable scope for them, including an unscoped
poppy:browser-sign-in, which on a web.unscoped website allows
everything the account can do there. Every agent write to a governed
action then goes through a Mission. The cost is that an agent without
the extension cannot perform a governed action at that company at all,
even with the User approving each revision, so the company chooses which
actions to govern.
Websites. A Mission sign-in neither requests nor receives
poppy:browser-sign-in; the authorization server refuses it with
invalid_scope, so a browser the agent joins under a Mission is signed
out, and no website operation acts under a Mission. A User acting in
their own browser acts on their own authority.
Conversations. The Company Agent is held to the read scope, so a
governed action there brings an authorization event, which the agent
treats as a Mission refusal. That event names the scopes needed and has
no form for a Mission refusal, so a conversation endpoint waits on one
(ask 6). A message’s text never approves.
What the company cannot verify. Three guarantees hold only in the agent’s trusted runtime: no limit the User set is dropped silently, an unknown outcome is settled before any new approval is sought, and the planner cannot choose a broader task credential.
| Not provided in version 1 | Consequence | Where it comes back |
|---|---|---|
| Cumulative limits | Two operations under one Mission can each be performed if each fits; narrow constraints limit this in practice, and PAP’s roadmap mandates (“transfers of up to $50 a week”) need it | Mission Metering, experimental, which defines accounting across operations: counters, reservations, and settlement |
| Verified approval of each revision | approver="user" stays the agent’s statement, and an entry with requires_action_approval: true is refused rather than satisfied by it | Mission Transaction Authorization, or PAP’s signed user approvals |
| Website operations | A Mission never acts in a browser | A later version, where the website applies the approval check to its own requests |
| Mediated Sign-In | It has no consent page, so it creates no Mission; PAP plans to retire it on March 17, 2027 | Nothing needed |
Conditions outside terms | Only terms and the common constraints are checked, never summary prose | PAP already requires every effect in terms |
| Outcomes after the Mission ends | If the response to an approval is lost just before the end, the agent cannot settle the outcome under the Mission and does not look it up with another credential; the User sees it in account settings | An open question to the Mission drafts on reading operations already started under an ended Mission |
| Governed actions on the default resource | The company hosts them at a service with its own resource | An open question to the Mission drafts on consuming entries and scopes at one audience |
| Governed actions through the Company Agent | A conversation endpoint is not an actions service | A conversation form of the Mission refusal, or a later version |
| Missions across companies | Each company sees only its own Mission, and aggregate limits are the agent’s job | Cross-domain projection, opted into at the cost of correlation |
Tests
Each test uses a Mission for exchanging itm_4Qa on ord_7Hk2 for
stormline-insulated-m with max_amount 75.00 USD, at the actions
service https://api.example.com/actions, unless the setup says
otherwise. T1, T3(c), T6(a), T14(a) and (b), and T16 send an agent
approval the Mission does not cover, as a mistaken or compromised agent
would, to show that the company refuses it.
| # | Setup | Action | Required result |
|---|---|---|---|
| T1 | A revision at 90.00 USD | Request the exchange under the Mission token without an approval, then with an agent approval of that revision | First: 403 approval_required with the operation. Second: 403 insufficient_scope, mission_denial="insufficient_authority", no scope attribute; nothing performed, no charge. Afterward the agent sends no sign-in or refresh for more scopes, no retry with another credential, and no approval of that revision under this Mission |
| T2 | A revision at 70.00 USD | Approve it with approver="agent" under the Mission token | The action’s own success response, exactly one exchange, and a record of the performed operation that names the Mission, listed under it in account settings |
| T3 | Mission tokens | (a) Call a write endpoint on the default resource. (b) Ask the Company Agent to perform the exchange. (c) At the actions service, request the exchange for a different SKU, then approve it. (d) Request an action the actions service does not govern. (e) Request the approved exchange without an approval | (a) 403 insufficient_scope, no effect. (b) An authorization event and no effect; the agent does not sign in again. (c) approval_required with an operation, and its approval refused with insufficient_authority; no effect. (d) 403, insufficient_authority, no operation. (e) approval_required with the operation |
| T4 | The company declines agent approvals under ordinary tokens for the action but still issues agents its write scope, the first of Mission-required mode’s two policies alone | An ordinary token with the action’s write scope approves the exchange, first with approver="agent", then with approver="user" | 403 approval_declined, nothing performed; then performed as ordinary PAP, with no Mission recorded |
| T5 | A revocation and an approval of the same operation run concurrently, many times, by settings and by RFC 7009 | Approve; after the revocation is acknowledged, approve again and refresh | Every admitted approval committed before the revocation was acknowledged, and none after; refused attempts have no effect. Afterward the approval returns 401 invalid_token, refresh returns invalid_grant with mission_error="revoked", and actions admitted earlier complete |
| T6 | Mission A covers this exchange; Mission B covers returning itm_9Zp | (a) A’s token approves B’s return operation. (b) An operation for this exchange, returned under an ordinary token in another Session, is approved under A’s token | (a) 403, insufficient_authority; B’s operation is not performed. (b) Performed once and recorded with Mission A |
| T7 | Two exchange entries: one covers the revision; the other carries a key the company stopped enforcing after issuance | Approve, with the entries in each order, then with only the unenforced entry granted | With both entries: performed in both orders. With only the unenforced entry: 403, mission_denial="constraint_unrecognized", no effect |
| T8 | (a) A proposal whose exchange entry carries requires_action_approval: true. (b) A grant that carries such an entry anyway | (a) Sign in. (b) Approve with user, then with agent | (a) The authorization server refuses the entry, or omits it and the granted entries show the omission; it never grants the entry with the key dropped. (b) 403, constraint_unrecognized for both approvals; no effect |
| T9 | A proposal whose exchange entry carries requires_action_approval: false | Sign in, then approve a covered revision with agent | The granted entry echoes the entry without the key, and the action is performed |
| T10 | The company lists Operations version 3 but not the extension | The agent starts the Mission workflow | The agent makes no action request, tells the User why, and submits the authority neither as bare scope nor as authorization_details |
| T11 | An operation returned under the Mission token at 90.00 USD; a non-conforming agent also holds an ordinary credential | It approves the operation at the actions service with the ordinary credential and approver="user" | (a) Where the company issues agents a write-capable scope for the action: performed as ordinary PAP, with no Mission recorded; the company cannot observe the violation. (b) Where it issues agents none for governed actions: the approval cannot happen |
| T12 | Requests for the same exchange in two interfaces, treated as two operations; the company relies on a one-exchange-per-item rule | Approve both concurrently under the Mission token | Exactly one is performed, once, and the other is declined with nothing changed. Without such a rule both may be performed, because the Mission alone does not count them. Recommended: one operation ID for one action across interfaces |
| T13 | The company lists browser_session_endpoint and returns operations on its website | (a) A Mission sign-in that requests poppy:browser-sign-in. (b) The agent joins its browser with the Mission read token | (a) invalid_scope. (b) Step 2 of the join refuses the token with insufficient_scope; the agent does not sign in again and joins signed out. No website operation is performed under the Mission |
| T14 | (a) Revision 2 adds a 10.00 USD fee to a 70.00 USD net. (b) A return, listed without max_amount, takes a 5.00 USD restocking fee from its refund. (c) A revision charges 170.00 USD, credits 100.00 USD, and adds 3.00 USD tax | Approve each with agent | (a) insufficient_authority: the net charge, 80.00 USD, exceeds the cap. (b) insufficient_authority: the deduction is a charge. (c) Performed: the net charge is 73.00 USD |
| T15 | An approval waits on the Mission lock while (a) the Mission’s expiry, (b) the revision’s expiry, or (c) the covering entry’s time_window end passes | Release the lock | (a) 401 invalid_token. (b) A new revision (approval_required), nothing performed. (c) insufficient_authority. No effect in any case |
| T16 | The Mission was approved under exchange contract version 1; version 2 adds a protection_plan term with a monthly charge | Request the exchange under version 2, then approve it with agent | insufficient_authority; nothing performed. A new Mission approved under version 2 performs it |
| T17 | Missions A (the exchange) and B (returning itm_9Zp), and an ordinary grant, for the same client, User, and account | (a) Sign in B. (b) Revoke A in settings, then repeat with RFC 7009 | (a) A’s refresh token and the ordinary one still work. (b) A’s tokens fail; B’s tokens and the ordinary grant keep working, and B’s return is performed |
| T18 | The company lists exchange without replacement_sku, and the User named the replacement | The agent starts the workflow | The agent pushes no exchange entry without the replacement until the User chooses in its own interface; per-revision approval, if chosen, uses an ordinary token outside the Mission |
| T19 | A Mission token at a write endpoint of the default resource, both legacy (it sends scope="orders:write") and one that recognizes Mission tokens | Call the endpoint | 403 insufficient_scope, no effect; the endpoint that recognizes Mission tokens sends insufficient_authority and no scope. The agent requests no scope, starts no sign-in, and tries no other credential |
| T20 | A Mission refresh token copied to another User’s device of the same agent, with its own DPoP key and client assertions | Refresh | invalid_grant, and no token issued |
| T21 | A Mission token on a request to the actions service that does not declare Operations version 3 | Request the exchange at the API, then call the tool at an MCP actions service | 403 extension_required naming operations at the API, an ordinary tool error at the MCP server; nothing performed, no operation returned |
| T22 | The approval of the 70.00 USD revision times out; the company performed the exchange, then forgot the operation after the revision’s expiry | The agent resends the same approval | A new operation comes back. The agent neither approves it nor asks the User to until it reads the order with the Mission’s read token, finds the exchange performed, and reports the task done. Exactly one exchange. Where the read cannot settle the outcome, the agent tells the User and approves nothing new |
| T23 | Missions A and C both cover this exchange, and the agent also holds an ordinary grant with the write scope | Approvals of the same revision under A’s token, C’s token, and the ordinary token arrive concurrently, many times | Exactly one is performed, once; the others get the first response, or 503 while performing. The record names the Mission whose approval claimed it, or none. Revoking A concurrently never lets an approval under A claim after the revocation is acknowledged |
The Agent Side
An agent can enforce the same limits before any company supports the extension, inside its own backend: the company connections supply access, a Mission in the backend records what the User approved, and a gateway that alone holds the credentials performs only what the Mission allows. The Mission Authority Server draft defines that placement for deployments that cannot change their authorization server. These are the pieces an agent builder needs, using a trip example: one flight and one refundable hotel, at most $3,000.
Before asking the User to approve:
| Check | What it prevents |
|---|---|
| The adapter knows each booking request returns an operation and cannot commit | A booking made when the backend asked only for terms |
| The adapter has a status read for each company’s outcomes | A booking lost or duplicated after a timeout |
| Both accounts are connected | Learning mid-trip that the hotel needs a sign-in |
| The stored grants cover booking and cancelling | A sign-in prompt after the hotel is booked |
| Neither company requires the User’s own confirmation | Learning at booking time that only the User can approve |
| Cancellation or recovery operations exist | A failed second booking with no way back |
What the backend records when the User approves:
| Dimension | Approved for this trip |
|---|---|
| Accounts | Airline account SKY-4417-92 and hotel account H-88-2051, both connected by this User |
| Travelers | The User only |
| Flight | One round-trip itinerary, San Francisco to Boston, out December 8 and back December 11, 2026, economy |
| Hotel | One room in Boston, check-in December 8, check-out December 11 |
| Spending | USD 3,000 combined, including taxes and fees |
| Refund condition | The hotel cancellable with no penalty until at least 48 hours before check-in |
| Data disclosure | Name, date of birth, and known traveler number to the airline; name and saved card to the hotel |
| Excluded actions | Seat upgrades, bags, insurance, loyalty purchases, account changes, messages to anyone |
| Commitment order | The cancellable booking first |
| Recovery | If the airline confirms the flight was not booked: one alternative itinerary at the same airline on the same dates within the remaining budget, or cancellation of the hotel inside its free window; anything else goes to the User |
| Lifetime | Ends when both bookings complete, or at 6 p.m. on November 15, 2026 |
How the agent’s Mission relates to a company’s. A Mission in the agent’s backend and a Mission at a company are separate grants. The company’s is approved again on its own page, with limits that correspond to the agent’s, and nothing lets the company verify one from the other. Revoking the agent’s Mission stops the agent’s gateway from admitting or committing anything new; the agent revokes each company’s Mission separately. They also differ after they end. The agent’s gateway is the trusted enforcement path the OAuth binding allows for the agent’s Mission, so after that Mission ends it may still read outcomes through the stored connection at a company that holds no Mission for the task. Where a company’s Mission governed the task, the agent settles outcomes while that Mission is active, and one still unknown at the end is left to the User, as Ending a Mission says.
How the backend binds a credential to the Mission. Trusted
orchestration fixes which Mission a task serves when it starts, and the
gateway takes the Mission reference from that binding, never from the
planner. The Mission Authority Server draft’s join rules then check that
the connected account’s subject maps to the Mission’s subject through
the backend’s connection record, and that the client is the agent’s
client_id; a failed join is a denial with no fallback, and a permit
never exceeds the credential’s authority, the Mission’s, or the
company’s policy. Inside one backend the gateway reports the subject and
client, so the join is only as trustworthy as the gateway. The
Mission AuthZEN profile,
used where the decision crosses a protected boundary, requires that “the
requesting component and the executing PEP MUST be the same enforcement
identity,” and signed decision evidence is never authorization to act.
What remains untrusted, before and after companies take part:
| Property | Agent-side only | With company enforcement |
|---|---|---|
| Common login provider required | No | No, if the company accepts the relevant delegation or grant relationship |
| User approval | Recorded by the personal agent | Portable approval evidence a company can check |
| Per-operation decisions | The agent’s decision service and gateway | Also the company’s enforcement point, through a decision request it makes itself |
| Account access | Stored OAuth connections | ID-JAG or another federated grant where trust already exists |
| Company authorization server changes | None | Possibly, depending on the integration |
| Mission limits enforced against the planner | By the protected gateway | By the gateway, the company’s enforcement point, or both |
| Company verifies Mission constraints itself | No | For the constraints the agreed profile conveys and the company understands |
| Credentials shown to be issued under the Mission | Not necessarily | Possible where issuance records the Mission |
| Shared budget | The backend ledger | Shared coordination or separate allocations per company |
| The Mission disclosed to companies | No | Depends on the projection profile |
What to build first:
| Priority | Contract | What it protects |
|---|---|---|
| First | Bind the authenticated task, User, client, company account, and concrete operation to the correct Mission | Substitution of another account, credential, or a more generous Mission |
| First | Trusted operation schemas that fail closed, preparation requests known not to commit, and the binding from decision to the request sent | Business limits the gateway can actually enforce |
| First | Durable admission, reservations, dispatch records, retries, status reads, and stop behavior | The User’s limits under concurrency and failure |
| Next | Companies advertising and accepting particular delegated approval bases | Independent company enforcement |
| Later | Account-scoped issuer enrollment and federated grant acceptance where existing trust is insufficient | Less dependence on stored grants, and broader delegation |
A prototype should show more than a successful booking:
- An already connected account works without another consent prompt.
- The planner cannot use another Mission or another User’s connection.
- A revision missing a required term, such as the total or the cancellation deadline, is refused.
- A request for scope outside the stored grant produces the company’s sign-in, never a silent expansion.
- Concurrent operations cannot exceed the shared budget.
- A purchase that times out is recovered without booking it twice.
- A failed second booking follows the approved recovery policy.
- Cancellation suppresses an approval admitted but not yet committed for dispatch, and resolves the outcome of a committed dispatch by reading status, never by sending the approval again.
How It Compares
Other open proposals in PAP’s repository address the approval PAP 1.0 leaves on trust. As of November 14, 2026:
| Proposal | Status | Scope and timing | Who verifies | Terms that first arrive after the User leaves |
|---|---|---|---|---|
| This extension | Design note revised for PAP 1.0 on November 14, 2026, not submitted to PAP | A class with limits, before execution | The company, against its own record | The agent approves the new operation on the Mission’s token, and the actions service checks it |
| Task grants (#28) | Open, revised October 23 | One operation, before or at execution | The company, on its own page | A new grant, from the User |
| Company-page approval (#46, with #45 closed as its duplicate) | Open, from DIRECTV | One operation, at execution | The company, on its own page | A new approval, from the User |
| Backchannel approval (#59) | Open, from Descope | One operation, at execution | The company, in its own app through CIBA | A new approval, from the User |
| Signed mandates (#71) | Open | A standing mandate, with a User-signed approval per operation | The company, against a User key it enrolled | Unresolved: the per-operation approval is signed by the User’s key |
| Payments (#61) | Open, revision 2 of November 2 | A transaction mandate at execution, or an intent mandate with constraints before it | The company, against a mandate the User signed with a passkey | For payments, a credential the Payment Provider issues under the intent mandate |
Approval assurance (#74, from FaceSign) works across all of these: a company can require that an approval show informed, express, and uncoerced consent to a particular revision, and keep the evidence. It strengthens an approval, and pairs with this extension where a company wants assurance that the User, not the agent, completed the sign-in that approved the Mission.
A replacement revision answering the agent’s own approval is a separate case. Under PAP 1.0 it goes to the User whichever of these is in place (Operations section 5). Ask 8 below would change that.
What PAP Could Add
These help PAP whether or not Missions are used:
- An optional
actionidentifier and an optional typed charge (amountandcurrency) on the operation, so agent approvals become checkable by machine. - A way for a company to say, in its API descriptions or tool annotations, which actions need approval and which it accepts agent approvals for only under a Mission or another approval it holds, so the agent knows before it sends the request and can gather that approval before the User leaves.
- A rule for reporting a per-service token without scopes. RFC 6749
cannot express an empty grant, so a service authorized by
authorization_detailsneeds its token response’sscopeleft out without meaning “the scopes requested.” - On the Signed approvals topic, this profile for mandates: the “Company’s own page” approach applied to the User’s instruction.
- Permission for a grant whose own authority is narrower to cover fewer
services than a sign-in without
resourcenormally does. - A statement that
insufficient_scopemay omitscopewhere no scope remedies the refusal, and a form of the conversationauthorizationevent for such a refusal. - On the Signed approvals topic, a mandate form of signed approval that says what the agent presents for an operation the User does not sign, and how a company binds the mandate’s signer to its own account holder.
- A change to Operations section 5 letting the agent approve a replacement revision under a mandate the company holds or verifies, such as a Mission, when the company checks that exact revision against the mandate’s fixed limits rather than the revision it replaced.