Abstract
AI assistants now do work that used to require a person to use a website, contact an organization, or run software themselves. The standards behind them are moving quickly: Agents can discover tools, talk to other agents, and increasingly identify themselves to businesses. The person who hands off the work is left to piece together what authority they granted, what the software tried, what the receiving organization accepted, and what is still open. Each provider sees only its own part of the transaction.
This paper looks at the infrastructure growing up around that problem. It proposes personal software that keeps account of the work a person delegates to agents from different providers. Organizations would get simple interfaces for accepting agent requests with a defined scope. The goal is ordinary transactions that people can verify after the software completes them. Legal authority, official decisions, and appeals stay with whoever holds them now. The first useful version works with the APIs, protocols, agents, and networks already in place.
Executive summary
Most of the web assumes a person visits a service, signs in, completes a task, and sees the result. More often now, the person asks an AI assistant to find the service, gather what it needs, act, and report back. When one task runs through several organizations, the agent's activity log, the service's transaction record, and the person's own understanding can disagree.
Most new infrastructure serves the other participants: the AI providers that run agents, the protocols that open services to software, identity vendors that help organizations authenticate automated actors, and financial platforms offering bounded agent transactions. Each one's records stay inside a single organization. [1–9]
A layer on the individual's side would let people connect their assistants to compatible services through an ordinary graphical interface, grant limited permissions, approve consequential actions, and keep their own transaction history. A matching component on the provider's side would turn existing APIs, forms, or staff workflows into operations the provider can account for when an agent requests them. This paper puts that architecture forward as a proposal. Its pieces exist separately today.
Public services raise the stakes. Agencies have to establish legal authority, keep official records, allow for review, and treat each decision as distinct from the request that prompted it. The decision to accept a transaction stays with the agency, under the law that governs it. A record held by the individual makes the chain of delegation easier to follow, which gives agencies a structured way to take part. [10–14]
The near-term test uses one independent application. Can someone authorize a narrow task with it, see the exchange that followed, check whether the provider acknowledged what the agent reported, and carry the record to a second compatible client? Existing APIs, a local database, and a demonstration provider service are enough to show it before any agency commits.
Four records of one transaction
Select each record from a license renewal to see what it shows.
Delegated transactions involve more than two parties
Consider someone renewing a local business license. They ask an assistant to check the requirements, complete the application, and tell them when it is done. The assistant replies, “Your renewal is complete.” What does complete mean?
It might mean the assistant found the right form, filled in a draft, or sent a submission. Even if the agency has acknowledged receipt, it may still be deciding whether to accept the application for processing. A licensing officer may have a decision to make after that.
The ordinary web transaction now has more participants: the person, the personal agent, any intermediary tools the agent uses, and the organization receiving the request. Each can hold a different record. The assistant's activity transcript is evidence of what the assistant reported. Whether the agency received the application, accepted it for processing, or approved it is a separate question with separate evidence.
Private transactions have the same problem. Someone tells an assistant to cancel a subscription. The provider may recognize the agent, ask for more confirmation, or answer only through its website. The person ends up comparing messages across several accounts to work out what happened, even when every system works as designed.
A person in that position wants to know: When software acts for me, where can I see what I allowed, what happened, and what I still need to do?
What a person needs from delegated software
Access without technical expertise
Integrations are usually described in terms of APIs, Model Context Protocol (MCP) servers, agent skills, OAuth scopes, and configuration files. Terms written for developers get in the way of a person trying to sort out an ordinary matter. A consumer interface could present the available actions as tasks, explain what each connection permits, and show who provides the service behind it. Because MCP leaves the choice of interface to the client, a graphical interface fits the protocol fine. [1, 2]
Delegation with limits a person can read
Account access has usually meant broad permissions: read an account, manage a calendar, write to a service. Delegated work needs narrower instructions, such as check the application every Friday without submitting changes, ask before sending a refund request, or spend up to a stated amount with an approved recipient. Some financial agent products already apply this kind of policy to transactions. Within a single provider's system, OAuth lets people withdraw the consent they gave. [7–9]
A person needs to see the difference between permission to look at data, permission to prepare an action, and permission to carry it out. Those limits have to be enforced at the service where the action happens, because a general instruction to an AI model is too weak to hold them.
A record that shows where each claim came from
An assistant's statement that a task is finished should be labeled as the assistant's statement. When a controlled connector sees a request, the record marks it as observed. A confirmation from the receiving organization keeps its original contents, including who issued it. The record should show each one separately, even where it can reconcile them, because a single reassuring “done” would hide the differences.
To survive a change of vendor, the record should export to a documented format that anyone can read with common tools. It needs consistent identifiers, events in time order, provenance, and careful handling of missing evidence.
Ways to undo an action
Revoking a local agent's tool access, revoking a token issued by a remote service, withdrawing an application, and appealing an official decision are four different operations. A consumer interface can point to the right path for each control that exists. Revoking a credential held by another provider takes that provider's cooperation. Whether a person can appeal at all depends on the rules that govern the service.
Existing tools cover parts of the problem
Much of the technical work already exists, in layers built for different customers.
| Layer | Relevant developments | What they address | What remains outside their principal scope |
|---|---|---|---|
| Agent-to-tool access | Model Context Protocol (MCP), server registries, and MCP Apps | Tool discovery, tool calls, authorization, and interactive interfaces | A cross-provider personal account of delegated work |
| Agent-to-agent communication | Agent2Agent (A2A) | Communication between independent agent systems | A consumer's record of authority across multiple providers |
| Personal agents dealing with companies | Personal Agent Protocol (“Poppy”), draft 0.1 | Company discovery, sessions, sign-in, APIs, conversations, proposed operations | A mature, independent, portable personal transaction history with universal adoption |
| Consent | OAuth consent management for connected apps | Managing provider-issued credentials | Oversight across unrelated issuers, including the legal authority behind each downstream transaction |
| Financial-agent transactions | Agent payment products such as Lightspark Grid | Spending controls, approval thresholds, and transaction histories within financial products | Comparable guarantees across government, education, insurance, and everyday services |
| Enterprise agent security | Non-human identity management, agent monitoring, and access governance | Protecting organizations' systems | A personal broker that acts for the individual across organizations |
| Public digital infrastructure | Digital-identity wallets, government APIs, Estonia's Aruait initiative | Official identity, public transactions, and emerging agent authorization experiments | General consumer-side delegation across many unaffiliated institutions |
MCP's July 2026 specification introduced a stateless protocol core, stronger authorization, and an extensions framework. Its tool specification defines how clients call the tools a server exposes, leaving the user experience to the application. A2A defines a common language for separate agent systems. The legal meaning of a completed government transaction sits outside both. [1–3]
The Personal Agent Protocol is the closest to this problem. Sierra published a draft with its design partners in October 2026. It describes how a personal agent can identify itself to a company, keep a session, use APIs, and reach company agents. Its optional Operations extension covers proposed terms, approval, confirmation, tracking, and protection against running an operation twice. As a draft 0.1 specification, it may still change. Its authors note that a personal agent's statement of user approval needs separate evidence before it proves the user approved the terms. [4–6]
Identity providers already offer working consent management. Stytch documents how an application can show scopes, list authorized connected apps, and revoke the tokens it issued. In Grid Global Accounts, Lightspark lets account holders set approval thresholds for AI agents. Cobo has added authorization controls for agent-driven blockchain activity. [7–9]
Governments have started too. The National Institute of Standards and Technology (NIST) launched an AI Agent Standards Initiative in February 2026. A separate NIST project is studying how agents get authorized. Estonia's Reason Reserve (Aruait) project, launched in June, proposes revocable authority for agents, a trust registry, interoperability work, and at least one pilot involving agents from outside government. Both are still in progress. The EU Digital Identity Wallet program sets a precedent for portable credentials the person controls, which a record of delegated actions could sit beside. [10–13]
No neutral system for tracking consequential actions across unrelated organizations has wide support yet.
A missing layer for personal delegation
A practical response has two components that work together. Each can be built on its own to work with other compatible software.
The personal component runs on a device the individual controls. It has a directory of compatible services, a graphical interface for choosing tasks, a place to grant, review, and withdraw the permissions it manages, an approval screen for consequential actions, and a lasting record of what happened. It works with whichever agents the person chooses, from any model provider.
The provider component lets an organization describe the authorization each supported operation requires. An organization with an established API may need only an adapter. Where an organization already supports an agent protocol such as MCP, it can expose that interface directly. A smaller organization with no programmatic API could start with structured intake reviewed by staff, if it chooses to accept that channel.
An action record ties the two together. It links the person's instruction, the agent's proposed operation, the authorization that applied, the observed exchange, and the provider's response. The person gets value from it as soon as one organization takes part.
Read the original text diagram
Person
| chooses task, grants limited permission, reviews results
v
Personal delegation client with local record
| ^
| approved request | observed exchange
v |
Selected agent ---- controlled connector (MCP / API / Poppy)
|
v
Service-provider interface
API, agent, or staff queue
|
v
Provider decisionThe personal client, agent, connector, and provider can each run with a different hosting company. The interfaces between them should use published standards wherever possible.
The record tracks six transaction states
The record would track six states: requested, authorized, attempted, acknowledged, decided, and contested. “Completed” would always carry a precise meaning, such as the API call finished, the agency acknowledged receipt, or the provider confirmed cancellation.
Each event would name whoever is making a claim, the target service, the task, the relevant permission, the time, and any supporting reference. When a third party issues a receipt, the record keeps the original. A response the system only observed is marked as observed. A gap in the evidence shows as unverified until evidence arrives.
The same structure allows independent reconciliation. A system can check an agent's description of its work against the activity observed at a connector, which catches claims the activity doesn't support. The comparison covers what the connector can see. Whether the organization met a legal obligation is a separate question.
Public services keep legal decisions with the agency
Government transactions make visible the distinctions that commercial automation tends to blur. Agencies decide under law, keep official records, and may owe people notice, review, or an appeal. Software that's allowed to help prepare information may still lack legal permission to submit it.
Public programs have long had forms of authorized representation. Federal Medicaid regulation 42 CFR §435.923, for example, provides for designated representatives under specified conditions. Because those rules cover legally recognized representatives, a software agent acting as one would need its own legal basis. [14]
The technical design should keep three questions apart: who is asking, what the person has permitted the software to attempt, and whether the receiving organization will legally recognize the result. Authentication answers the first, local delegation the second, and official acceptance the third.
Municipal APIs offer a small starting point. In participating jurisdictions, Open311 GeoReport v2 lets applications discover service types, check the status of service requests, and sometimes submit new ones under local rules. A client can report the status the API returns, labeled as the city's account of the repair. [15]
Federal agencies already have recordkeeping obligations. The National Archives and Records Administration's August 2026 guidance explains how the Federal Records Act applies to AI inputs, outputs, audit trails, and other materials when they qualify as federal records. A record held by the consumer would sit alongside the agency's official system of record. [16]
A shared model would give people one consistent view of transaction states across government programs, each of which keeps its own decision procedures.
Organizations can join with the systems they already have
Agent-capable services will spread unevenly. Some organizations already publish usable APIs. A network that required MCP would leave out the many others people need to reach, whose only channels may be a website, a document upload, a contact center, or an email inbox.
A reasonable participation model has four routes:
| Existing capability | Suitable connection | Limit of the connection |
|---|---|---|
| Published agent protocol such as MCP | Direct client connection using supported authorization | Only the operations the service permits |
| Documented REST API | Versioned adapter with test cases | API coverage may be narrower than the website |
| Official web form | Assisted submission through approved channels | The client must not represent preparation as official receipt |
| Willing provider with no machine interface | Structured intake reviewed by staff, with a receipt | Requires the provider to agree to operate the intake channel |
An open starter kit for providers could include service descriptions, authentication setup, approval callbacks, transaction IDs, status updates, and an inbox for human review, all over ordinary HTTP with exportable data. Anyone could publish adapters, including the organizations themselves.
Once a provider implements this on its own, any person should be able to connect to it directly, with no proprietary marketplace in between.
A listing in a service directory shows only that the endpoint exists. Trust in a third-party connector has to come from details: a named publisher, source documentation, a list of permitted operations, a description of how it handles data, and a maintenance status. The MCP Registry describes itself as a metadata catalog that makes no promise about the services it lists. [17]
A demonstration that tests five claims
Using open-source tools, a small implementation could test the whole idea against public APIs. Its goal is to show the personal client supervising the same kind of transaction end to end through two different connections.
A first build would have six parts: an application on the person's device, a local SQLite event store, a plain-language task interface, a read-only connector to a public API such as Open311, a demonstration provider service that confirms proposed operations, and an optional MCP adapter for independent agents. Viewing a case, checking status, reviewing permissions, and exporting records would all work with the language model switched off.
In the demonstration, a person asks the client to prepare a follow-up on an existing municipal request if it is still open. The client records the official status it fetches. After the person approves a message the agent drafted, the message goes out only through an authorized channel. In the provider environment, a separate proposed action is approved, executed, and acknowledged with a reference number from the provider. The personal record keeps each of those stages separate.
A second compatible client imports the same history to pick up the work. Because credentials stay with the service that issued them, the new client gets its own through its own connection.
The demonstration tests five claims in working software: a graphical interface can hide protocol complexity, authorization can be scoped at the connector, the exchange can be recorded apart from the agent's own account, a provider can issue a meaningful receipt, and the record can move to another client.
The technical pieces are familiar: TypeScript, a small local application framework, SQLite, documented JSON event shapes, OAuth where available, and protocol adapters. What's new is the set of conventions that let the record travel.
Adoption, incentives, and governance
A personal application is useful before any network exists. It can keep a reliable record of a useful task through one supported connection. The wider benefit comes when people can carry their records between providers, which depends on compatible implementations being widely adopted.
Providers need reasons to take part. A supported interface for agents could cut ambiguous automated traffic, keep transaction references intact, define acceptable operations, and send exceptions to staff. Those benefits need measuring, because easier automation can also flood the organizations receiving it with duplicate requests.
How an intermediary gets paid shapes how it behaves. One that routes people to third-party agents could be paid by its users, by participating services, or by vendors seeking placement, each pulling in a different direction. Referral payments, hidden ranking preferences, resale of behavioral records, and exclusive integrations would each undercut a claim of independence. A serious implementation discloses how it is paid, keeps data exportable, and works with other software on open terms.
A broker is a useful analogy for the operator. Because a real broker's fiduciary duties come from law, any operating rules would need to spell out what the operator promises, what it can verify on its own, and where another institution keeps responsibility.
The person using the agent is one of several people with something at stake. A request may contain information about family members, employees, patients, or students who never agreed to the assistant's use. Data minimization should apply to what each action contains, including information about those people.
Eight questions for evaluating a working implementation
These questions give a working implementation something observable to be judged on before anyone claims a new standard.
| Question | Possible evaluation |
|---|---|
| Can an ordinary person connect a service? | Complete a supported task without terminal commands |
| Can they understand the permission? | Explain in their own words what the agent is allowed to do |
| Are boundaries enforced? | Check that the controlled interface refuses a prohibited operation |
| Does the record match events? | Reconcile the agent's report with the captured exchange |
| Are receipt states intelligible? | Tell local completion, provider acknowledgment, and final decision apart |
| Is the record portable? | Import an exported case into a separate implementation without losing provenance |
| Can providers join incrementally? | Expose one existing API through an adapter without replacing the provider's application |
| Does it reduce burden? | Measure successful resolutions, abandoned steps, duplicate submissions, and human handling time |
A real trial matters because technical compatibility says little about adoption. Three results would change the plan. If most people only need help preparing documents, a general delegation client is more than they need. Developers who struggle to adopt the event format would weaken the case for portability. A provider gateway may fail as a business, even alongside a useful consumer interface, if service providers see little operational benefit from structured agent requests.
Conclusion
More online work is being done by software acting for people. The person's own view across providers lags behind the standards that let agents reach organizations. A successful delegated transaction can span an assistant, a tool provider, an intermediary, and a receiving organization, each keeping its own partial record.
This paper proposes a personal delegation client that works with an open interface providers can use to accept agent requests. On the person's side, it offers a familiar interface for connecting services, granting limited permission, approving work, and keeping a portable history. Any organization could take part through existing APIs, supported protocols, or structured human workflows. Shared conventions for receipts make transactions easier to understand across every AI platform involved.
All of this can be tested now on services that already have APIs, before any government commits. A small executable can show whether the permissions, observations, and receipts help an ordinary person get work done with a clear account of what happened.
Sources
The sources below describe the situation on October 15, 2026. The proposed architecture, including its evaluation criteria, is this paper's own analysis, which goes beyond what the cited specifications require.
- Model Context Protocol maintainers, “The 2026-07-28 Specification,” July 28, 2026. https://blog.modelcontextprotocol.io/posts/2026-07-28/ . Documents protocol evolution, authorization hardening, extensions, and tools.
- Model Context Protocol specification, “Tools,” revision 2026-07-28. https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2026-07-28/server/tools.mdx . Describes model-controlled tools, leaving clients free to choose interaction patterns.
- Agent2Agent Protocol, “A2A Specification,” current published specification. https://a2a-protocol.org/v1.0.0/specification . Defines how agents communicate across systems, leaving server-side authorization to the provider.
- Sierra, “Sharing a draft of Personal Agent Protocol,” October 9, 2026. https://sierra.ai/uk/blog/poppy . Names the draft's design partners.
- Personal Agent Protocol, “Specification,” draft 0.1, October 2026. https://personalagentprotocol.org/docs/spec . Defines company discovery, personal-agent sessions, authentication, and supported interaction channels.
- Personal Agent Protocol, “Operations extension” and “Path to 1.0,” draft 0.1. https://personalagentprotocol.org/docs/extensions/operations and https://personalagentprotocol.org/docs/path-to-1 . Documents approvals, operation IDs, duplicate-prevention semantics, stated limits of approval evidence, and areas not yet standardized.
- Stytch, “Consent management,” Connected Apps documentation. https://stytch.com/docs/connected-apps/resources/consent-management . Documents OAuth consent, connected-app visibility, scopes, and revocation within a participating provider.
- Lightspark, “Introducing AI Agent Support for Grid Global Accounts,” May 4, 2026. https://www.lightspark.com/news/lightspark/introducing-ai-agent-support-for-grid-global-accounts . Describes how a financial account product enforces revocable agent permissions.
- Cobo, “Cobo Launches Agentic Wallet,” April 20, 2026. https://www.cobo.com/agentic-wallet/news/cobo-launches-agentic-wallet-how-ai-agents-interact-on-chain . Describes controls on what agents can do in supported blockchain activity.
- NIST, “Announcing the AI Agent Standards Initiative for Interoperable and Secure Innovation,” February 17, 2026. https://www.nist.gov/news-events/news/2026/02/announcing-ai-agent-standards-initiative-interoperable-and-secure .
- NIST National Cybersecurity Center of Excellence, “Software and AI Agent Identity and Authorization,” 2026 project page. https://www.nccoe.nist.gov/projects/software-and-ai-agent-identity-and-authorization . Current exploration of agent identity, authorization, and interoperable approaches.
- Estonian Information System Authority, “Reason Reserve / Aruait,” 2026. https://ria.ee/en/state-information-system/artificial-intelligence/reason-reserve-aruait . Describes a 24-month initiative to develop agent authorization, a trust registry, interoperability, and pilots. None of its planned outcomes is reported as complete.
- European Commission, “European Digital Identity,” current 2026 overview. https://commission.europa.eu/topics/digital-economy-and-society/european-digital-identity_en . Describes the rollout of the EU Digital Identity Wallet.
- 42 CFR § 435.923, “Authorized representatives.” https://www.law.cornell.edu/cfr/text/42/435.923 . Federal Medicaid rule on designating authorized representatives under specified conditions.
- Open311, “GeoReport v2.” https://wiki.open311.org/GeoReport_v2/ . Stable open API specification for participating municipal service-request systems.
- National Archives and Records Administration, Memorandum AC 11.2026, “Guidance on Applying the Federal Records Act to Artificial Intelligence Materials,” August 21, 2026. https://www.archives.gov/records-mgmt/memos/ac-11-2026 .
- Model Context Protocol Registry, “About the MCP Registry,” 2026 preview documentation. https://github.com/modelcontextprotocol/registry/blob/main/docs/modelcontextprotocol-io/about.mdx . Describes the registry's metadata function, which is still in preview.