---
title: "The Mission Extension for PAP 1.0"
date: "2026-11-14T21:30:00-08:00"
lastmod: "2026-11-15T00:00:00Z"
description: "Reference for a proposed Personal Agent Protocol extension, karlmcguinness.com/mission. A User approves a task's limits once on the company's own sign-in page, the company keeps that approval as a Mission, and every agent approval for the task is checked against it at the service that performs the action. Advertising support, the sign-in, tokens, what the company checks, refusals and declines, retries, ending a Mission, security considerations, tests, and how it compares with other open PAP proposals, in PAP 1.0 terms."
summary: "The Mission extension for PAP 1.0 in one place, in the order of PAP’s Operations extension: who does what (no change to PAP core for anyone who does not use it), the poppy.json entry, the pushed sign-in with its authority entries and consent text, the read token and the actions-service token, the check a company runs on each agent approval, the refusals and declines it returns with the agent’s response to each, retries, how a Mission ends, security considerations and limits, twenty-three conformance tests built on PAP’s jacket exchange, the agent side, and a comparison with task grants, backchannel approval, signed mandates, payments, and approval assurance."
slug: "the-mission-extension-for-pap"
tags:
  - "Agentic Identity"
  - "Authorization"
  - "OAuth"
  - "Mission-Bound Authorization"
  - "Personal Agent Protocol"
  - "Standards"
---


> **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](/notes/poppys-standing-permissions-work-on-trust/)
proposes, in [PAP 1.0](https://personalagentprotocol.org/docs/1.0/spec)
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](https://personalagentprotocol.org/docs/roadmap#signed-approvals)
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](https://mcguinness.github.io/mission-bound-authorization/),
the
[OAuth binding](https://mcguinness.github.io/mission-bound-authorization/#go.draft-mcguinness-oauth-mission.html)
and the
[Resource Access Profile](https://mcguinness.github.io/mission-bound-authorization/#go.draft-mcguinness-oauth-mission-resource-access.html),
and defines nothing they already define. The
[design note](https://github.com/mcguinness/mission-bound-authorization/blob/main/notes/pap-mission-sketch.md)
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](#signing-in), [Tokens](#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](#requesting-and-approving-an-operation), [What the Company Checks](#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](#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](#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](#mission-refusals), [Retries and At Most Once](#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](#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:

```json
"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):

```http
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:

| 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:

```json
{
  "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:

```json
[
  { "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](https://mcguinness.github.io/mission-bound-authorization/#go.draft-mcguinness-oauth-mission-device-authorization.html)
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:

```json
{
  "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:

```json
{
  "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`:

```http
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](#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:

| 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 `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.

| 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 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](#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](https://mcguinness.github.io/mission-bound-authorization/#go.draft-mcguinness-mission-metering.html), 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](https://mcguinness.github.io/mission-bound-authorization/#go.draft-mcguinness-oauth-mission-transaction-authorization.html), 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](https://mcguinness.github.io/mission-bound-authorization/#go.draft-mcguinness-mission-authority-server.html)
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](https://mcguinness.github.io/mission-bound-authorization/#go.draft-mcguinness-mission-authzen.html),
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](https://github.com/personal-agent-protocol/personal-agent-protocol/issues/28) (#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](https://github.com/personal-agent-protocol/personal-agent-protocol/issues/46) (#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](https://github.com/personal-agent-protocol/personal-agent-protocol/issues/59) (#59) | Open, from Descope | One operation, at execution | The company, in its own app through CIBA | A new approval, from the User |
| [Signed mandates](https://github.com/personal-agent-protocol/personal-agent-protocol/issues/71) (#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](https://github.com/personal-agent-protocol/personal-agent-protocol/issues/61) (#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](https://github.com/personal-agent-protocol/personal-agent-protocol/issues/74)
(#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.

