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_amount is 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.

PartyResponsibilityWhere
Company authorization serverAccept the Mission request at sign-in, show its limits on the consent page, store the Mission, and issue tokens tied to itSigning In, Tokens
Company actions serviceHost 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 MissionRequesting and Approving an Operation, What the Company Checks
Company account settingsList the agent’s active Missions, each with its goal, what was performed under it, and a revoke controlEnding a Mission
Company prerequisitesA read scope hinted changes: "none" that covers the reads a governed task needs, and DPoP at the actions serviceAdvertising Support
Personal AgentDiscover 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 endsMission Refusals, Retries and At Most Once
PAP coreNo 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 scopesAsks 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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
"extensions": {
  "operations": [{ "version": "3" }],
  "karlmcguinness.com/mission": [{
    "version": "1",
    "actions": {
      "exchange": {
        "resources": ["https://api.example.com/actions"],
        "constraints": ["order_id", "item_id", "replacement_sku", "max_amount"]
      },
      "return": {
        "resources": ["https://api.example.com/actions"],
        "constraints": ["order_id", "item_id"]
      }
    }
  }]
}

The operations entry lists no endpoint, because this company returns no operations on its website.

  • actions maps each action the company governs to the services where the agent requests it and the constraint keys the company enforces. Each entry in resources is 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_amount and time_window have their Resource Access Profile meanings, and the amount max_amount bounds is the action’s net charge. Any other key names a terms key and constrains that term to equal the given value.
  • An action listed with max_amount is chargeable, and the authorization server refuses an entry that grants it without one. An action listed without max_amount carries no charge at all, not even a deduction from a refund.
  • Version 1 never lists requires_action_approval. Its true value needs a verifiable approval of each action, and a user approval is the agent’s statement. The authorization server refuses an entry carrying true, never grants it with the key dropped, and the actions service fails such an entry closed. An entry carrying false is granted without the key, which removes nothing.
  • Each governed action has a contract version: its documented meaning, the complete set of terms keys 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 as resource_contract.
  • Read scope. PAP requires scope on 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 consumes authorization_details. So the agent requests, for the default resource, company scopes hinted changes: "none" that the task’s reads need, such as orders: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 no scope. 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):

1
Poppy-Extensions: "operations";v="3", "karlmcguinness.com/mission";v="1"

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:

ParameterValue
DPoP headerA proof, so the company can bind the code to the agent’s key
response_type, client_id, redirect_uri, state, PKCEAs in any PAP Direct Sign-In
scopeorders:read, the company’s read scope
promptconsent, PAP’s rule unless the redirect returns only to the device that opened the authorization URL
mission_intentThe task’s goal, target resources, and expiry
authorization_detailsThe proposed authority, below
client_assertionThe agent’s private_key_jwt
resourceAbsent, 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:

1
2
3
4
5
6
7
{
  "intent": {
    "goal": "Exchange the Stormline Jacket (M) on order ord_7Hk2 for the insulated version if it costs no more than $75 more.",
    "target_resources": ["https://example.com", "https://api.example.com/actions"],
    "expires_at": "2026-11-16T00:00:00Z"
  }
}

The proposed authority, one entry for the reads and one for the action:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
[
  { "type": "mission_resource_access",
    "resource": "https://example.com",
    "actions": ["orders:read"] },
  { "type": "mission_resource_access",
    "resource": "https://api.example.com/actions",
    "actions": ["exchange"],
    "constraints": {
      "order_id": "ord_7Hk2",
      "item_id": "itm_4Qa",
      "replacement_sku": "stormline-insulated-m",
      "max_amount": { "amount": "75.00", "currency": "USD" }
    } }
]

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
{
  "access_token": "eyJhbGciOi…Qp4w",
  "token_type": "DPoP",
  "expires_in": 3600,
  "refresh_token": "pat_M7c2…Rr4",
  "scope": "orders:read",
  "mission_id": "msn_8RfX2Lqv9TqM",
  "mission_expires_at": "2026-11-16T00:00:00Z",
  "authorization_details": [
    { "type": "mission_resource_access",
      "resource": "https://example.com",
      "actions": ["orders:read"] }
  ]
}

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
{
  "access_token": "eyJhbGciOi…Zt7m",
  "token_type": "DPoP",
  "expires_in": 600,
  "mission_id": "msn_8RfX2Lqv9TqM",
  "mission_expires_at": "2026-11-16T00:00:00Z",
  "authorization_details": [
    { "type": "mission_resource_access",
      "resource": "https://api.example.com/actions",
      "actions": ["exchange"],
      "constraints": {
        "order_id": "ord_7Hk2",
        "item_id": "itm_4Qa",
        "replacement_sku": "stormline-insulated-m",
        "max_amount": { "amount": "75.00", "currency": "USD" } } }
  ]
}
  • 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 omitted scope would read as the requested scopes granted. The response reports the grant in authorization_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:

  1. Every governed action returns an operation. A request under a Mission token without an approval performs nothing. The service returns approval_required with 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.
  2. An action the service does not govern is refused. No entry names it, so the service refuses with insufficient_scope and mission_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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
POST /actions/orders/ord_7Hk2/exchanges HTTP/1.1
Host: api.example.com
Poppy-Session: eyJ0eXAiOiJwb3BweS1zZXNzaW9uK2p3dCIs…
Poppy-Version: 1.0
Poppy-Extensions: "operations";v="3", "karlmcguinness.com/mission";v="1"
Authorization: DPoP eyJhbGciOi…Zt7m
DPoP: eyJ0eXAiOiJkcG9wK2p3dCIs…
Content-Type: application/json
Poppy-Approval: operation_id="exc_5Rt2", revision="1791487200-k3Jd9Qx2mW8v", approver="agent", approved_at=1791487255, reference="apr_01JD8ZK3R4"

{ "item_id": "itm_4Qa", "replacement_sku": "stormline-insulated-m" }

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:

  1. 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.
  2. Mission state, on every request. If the Mission is not active or has expired, the request is refused with invalid_token.
  3. The action. The company computes the operation the request asks for. If no granted entry names its action, it refuses with insufficient_scope and mission_denial="insufficient_authority". A request with no approval gets approval_required with the operation.
  4. Coverage. A revision that carries a charge, including a deduction from a refund, for an action the company lists without max_amount is refused with insufficient_authority. Otherwise, an entry with a key or resource_match the 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 with insufficient_scope, and with mission_denial="constraint_unrecognized" when only unenforceable entries named the action, "insufficient_authority" otherwise.
  5. The contract version. A revision whose terms carry a key outside the version the Mission recorded, or that needs a different version, is refused with insufficient_authority.
  6. 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.
  7. 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_window open. The company rechecks its own eligibility rules that depend on changing state, such as one exchange per order item, and declines with approval_declined if 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:

KeyHolds when
max_amountThe 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_windowThe admission instant is inside the window
Any other enforced keyThe 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 approver says. 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.

ConditionResponseWhat 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 operationRequests 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 request403, … mission_denial="constraint_unrecognized", no scope; no operationThe same
Mission token at a write endpoint of the default resource403, DPoP error="insufficient_scope", with mission_denial="insufficient_authority" and no scope where the endpoint recognizes the Mission token; the body the endpoint returns todayThe same, with or without mission_denial or a scope attribute
Mission token with the Company Agent200 or 202 with an authorization event (spec section 8.11)The same
Mission not active or expired, on any request or at admission401, 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 3403 with extension_required naming operations; an MCP tool returns an ordinary tool errorNot 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:

ConditionResponse
Ordinary token, agent approval, for a governed action in Mission-required mode403 with approval_declined
A company eligibility rule fails at admission403 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 with invalid_grant and mission_error set to revoked or expired.
  • 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 1ConsequenceWhere it comes back
Cumulative limitsTwo 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 itMission Metering, experimental, which defines accounting across operations: counters, reservations, and settlement
Verified approval of each revisionapprover="user" stays the agent’s statement, and an entry with requires_action_approval: true is refused rather than satisfied by itMission Transaction Authorization, or PAP’s signed user approvals
Website operationsA Mission never acts in a browserA later version, where the website applies the approval check to its own requests
Mediated Sign-InIt has no consent page, so it creates no Mission; PAP plans to retire it on March 17, 2027Nothing needed
Conditions outside termsOnly terms and the common constraints are checked, never summary prosePAP already requires every effect in terms
Outcomes after the Mission endsIf 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 settingsAn open question to the Mission drafts on reading operations already started under an ended Mission
Governed actions on the default resourceThe company hosts them at a service with its own resourceAn open question to the Mission drafts on consuming entries and scopes at one audience
Governed actions through the Company AgentA conversation endpoint is not an actions serviceA conversation form of the Mission refusal, or a later version
Missions across companiesEach company sees only its own Mission, and aggregate limits are the agent’s jobCross-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.

#SetupActionRequired result
T1A revision at 90.00 USDRequest the exchange under the Mission token without an approval, then with an agent approval of that revisionFirst: 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
T2A revision at 70.00 USDApprove it with approver="agent" under the Mission tokenThe 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
T3Mission 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
T4The 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 aloneAn 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
T5A revocation and an approval of the same operation run concurrently, many times, by settings and by RFC 7009Approve; after the revocation is acknowledged, approve again and refreshEvery 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
T6Mission 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
T7Two exchange entries: one covers the revision; the other carries a key the company stopped enforcing after issuanceApprove, with the entries in each order, then with only the unenforced entry grantedWith 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
T9A proposal whose exchange entry carries requires_action_approval: falseSign in, then approve a covered revision with agentThe granted entry echoes the entry without the key, and the action is performed
T10The company lists Operations version 3 but not the extensionThe agent starts the Mission workflowThe agent makes no action request, tells the User why, and submits the authority neither as bare scope nor as authorization_details
T11An operation returned under the Mission token at 90.00 USD; a non-conforming agent also holds an ordinary credentialIt 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
T12Requests for the same exchange in two interfaces, treated as two operations; the company relies on a one-exchange-per-item ruleApprove both concurrently under the Mission tokenExactly 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
T13The 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 taxApprove 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
T15An 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 passesRelease the lock(a) 401 invalid_token. (b) A new revision (approval_required), nothing performed. (c) insufficient_authority. No effect in any case
T16The Mission was approved under exchange contract version 1; version 2 adds a protection_plan term with a monthly chargeRequest the exchange under version 2, then approve it with agentinsufficient_authority; nothing performed. A new Mission approved under version 2 performs it
T17Missions 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
T18The company lists exchange without replacement_sku, and the User named the replacementThe agent starts the workflowThe 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
T19A Mission token at a write endpoint of the default resource, both legacy (it sends scope="orders:write") and one that recognizes Mission tokensCall the endpoint403 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
T20A Mission refresh token copied to another User’s device of the same agent, with its own DPoP key and client assertionsRefreshinvalid_grant, and no token issued
T21A Mission token on a request to the actions service that does not declare Operations version 3Request the exchange at the API, then call the tool at an MCP actions service403 extension_required naming operations at the API, an ordinary tool error at the MCP server; nothing performed, no operation returned
T22The approval of the 70.00 USD revision times out; the company performed the exchange, then forgot the operation after the revision’s expiryThe agent resends the same approvalA 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
T23Missions A and C both cover this exchange, and the agent also holds an ordinary grant with the write scopeApprovals of the same revision under A’s token, C’s token, and the ordinary token arrive concurrently, many timesExactly 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:

CheckWhat it prevents
The adapter knows each booking request returns an operation and cannot commitA booking made when the backend asked only for terms
The adapter has a status read for each company’s outcomesA booking lost or duplicated after a timeout
Both accounts are connectedLearning mid-trip that the hotel needs a sign-in
The stored grants cover booking and cancellingA sign-in prompt after the hotel is booked
Neither company requires the User’s own confirmationLearning at booking time that only the User can approve
Cancellation or recovery operations existA failed second booking with no way back

What the backend records when the User approves:

DimensionApproved for this trip
AccountsAirline account SKY-4417-92 and hotel account H-88-2051, both connected by this User
TravelersThe User only
FlightOne round-trip itinerary, San Francisco to Boston, out December 8 and back December 11, 2026, economy
HotelOne room in Boston, check-in December 8, check-out December 11
SpendingUSD 3,000 combined, including taxes and fees
Refund conditionThe hotel cancellable with no penalty until at least 48 hours before check-in
Data disclosureName, date of birth, and known traveler number to the airline; name and saved card to the hotel
Excluded actionsSeat upgrades, bags, insurance, loyalty purchases, account changes, messages to anyone
Commitment orderThe cancellable booking first
RecoveryIf 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
LifetimeEnds 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:

PropertyAgent-side onlyWith company enforcement
Common login provider requiredNoNo, if the company accepts the relevant delegation or grant relationship
User approvalRecorded by the personal agentPortable approval evidence a company can check
Per-operation decisionsThe agent’s decision service and gatewayAlso the company’s enforcement point, through a decision request it makes itself
Account accessStored OAuth connectionsID-JAG or another federated grant where trust already exists
Company authorization server changesNonePossibly, depending on the integration
Mission limits enforced against the plannerBy the protected gatewayBy the gateway, the company’s enforcement point, or both
Company verifies Mission constraints itselfNoFor the constraints the agreed profile conveys and the company understands
Credentials shown to be issued under the MissionNot necessarilyPossible where issuance records the Mission
Shared budgetThe backend ledgerShared coordination or separate allocations per company
The Mission disclosed to companiesNoDepends on the projection profile

What to build first:

PriorityContractWhat it protects
FirstBind the authenticated task, User, client, company account, and concrete operation to the correct MissionSubstitution of another account, credential, or a more generous Mission
FirstTrusted operation schemas that fail closed, preparation requests known not to commit, and the binding from decision to the request sentBusiness limits the gateway can actually enforce
FirstDurable admission, reservations, dispatch records, retries, status reads, and stop behaviorThe User’s limits under concurrency and failure
NextCompanies advertising and accepting particular delegated approval basesIndependent company enforcement
LaterAccount-scoped issuer enrollment and federated grant acceptance where existing trust is insufficientLess 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:

ProposalStatusScope and timingWho verifiesTerms that first arrive after the User leaves
This extensionDesign note revised for PAP 1.0 on November 14, 2026, not submitted to PAPA class with limits, before executionThe company, against its own recordThe agent approves the new operation on the Mission’s token, and the actions service checks it
Task grants (#28)Open, revised October 23One operation, before or at executionThe company, on its own pageA new grant, from the User
Company-page approval (#46, with #45 closed as its duplicate)Open, from DIRECTVOne operation, at executionThe company, on its own pageA new approval, from the User
Backchannel approval (#59)Open, from DescopeOne operation, at executionThe company, in its own app through CIBAA new approval, from the User
Signed mandates (#71)OpenA standing mandate, with a User-signed approval per operationThe company, against a User key it enrolledUnresolved: the per-operation approval is signed by the User’s key
Payments (#61)Open, revision 2 of November 2A transaction mandate at execution, or an intent mandate with constraints before itThe company, against a mandate the User signed with a passkeyFor 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:

  1. An optional action identifier and an optional typed charge (amount and currency) on the operation, so agent approvals become checkable by machine.
  2. 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.
  3. A rule for reporting a per-service token without scopes. RFC 6749 cannot express an empty grant, so a service authorized by authorization_details needs its token response’s scope left out without meaning “the scopes requested.”
  4. On the Signed approvals topic, this profile for mandates: the “Company’s own page” approach applied to the User’s instruction.
  5. Permission for a grant whose own authority is narrower to cover fewer services than a sign-in without resource normally does.
  6. A statement that insufficient_scope may omit scope where no scope remedies the refusal, and a form of the conversation authorization event for such a refusal.
  7. 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.
  8. 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.