Summary
- An agent’s credentials decide what it can technically do, and the law often looks at them to decide whose act the agent’s action was. Under UETA, showing that a security procedure was effective is one way to prove whose act an electronic record was. Under UCC Article 4A, a security procedure agreed with the bank can decide whether a business bears an unauthorized wire or other funds transfer.
- Identity, authentication, authorization and authority are four different things. Proving who an agent is says nothing about what it may do.
- OAuth scopes are the closest thing in software to a written grant of authority. Add-on standards let a token carry amounts, the chain of delegation and the service the token is meant for (its audience), but only if the authorization server is set up to include them and the receiving service enforces them.
- Standards bodies have begun working on agents directly. Expect their standards to show up in contracts, in “commercially reasonable” tests and in negligence arguments.
- Map each term of an agent’s mandate to the control that enforces it, and give each agent its own scoped, expiring credentials.
Four words that aren’t synonyms
| Concept | Question | Technical form | Legal counterpart |
|---|---|---|---|
| Identity | Which agent is this, and whose is it? | A client ID, service account or workload identity | Identifying the actor and the principal |
| Authentication | Can it prove which agent it is? | Keys, signed tokens, certificates | Attribution through a security procedure |
| Authorization | What will the system let it do? | Scopes, roles, policies, spending caps | Evidence of actual or apparent authority; authorized access under computer-access law (CFAA)1 |
| Authority | What did the principal authorize, or lead others to believe it authorized? | None, though a system can record or enforce what the principal authorized | Actual and apparent authority |
The first three are engineering terms with established meanings. The fourth is a legal term with no technical form of its own. Many agent disputes are likely to start from assuming authorization equals authority. See Technical Permission vs. Legal Authority.
How an agent gets access
A typical path for an agent calling a vendor’s system looks like this. Each step leaves a record, and each record answers a legal question.
- A person approvesA manager signs in and approves the access the agent asks for, on a consent screenWhat did the principal approve?
- A token is issuedAn authorization server issues a token listing scopes, audience and expiryWhat was the agent permitted to do?
- The agent calls the serviceThe agent presents the token with each requestWhose act is this?
- The service checksThe service checks that the token was issued for it and allows the request, and sees its scopes and limitsWhat could the other side reasonably believe?
- The action is loggedBoth sides record which credential was used (an identifier, never the token itself), the actor and the resultWhat will the evidence show?
The highlighted steps are where technical permission is set and checked. Inside an Agent System shows the same path inside the agent.
OAuth in plain terms
OAuth lets one system get limited access to another system without receiving the user’s password.2 For lawyers, OAuth matters because the access it grants can reflect what a person approved, it can carry limits and delegation, and it sets a benchmark for reasonable care. The protocol doesn’t itself require a record of that approval; the application can keep one.
Four roles are involved:
- Client: the software asking for access, here the agent.
- Resource owner: the person or company that can approve the client’s access to its account or data. In an agent deployment, this is usually the agent’s principal.
- Resource server: the service the agent wants to use, such as a vendor’s ordering system, where the principal usually has an account.
- Authorization server: the system that issues tokens, usually run by the service or by an identity provider the service trusts.
The authorization server checks who is asking and what the resource owner approved, then issues the client an access token: a credential that states what the client may do and for how long. The service checks the token on each of the client’s requests before acting. For example, when a company’s procurement agent orders from a vendor, the company is the resource owner (and the agent’s principal), its agent is the client, and the vendor runs the service and usually the authorization server. This is the path shown in the diagram above.
Scopes are a written grant
A token carries its scopes, or refers to them. Some tokens are readable lists of claims; others are opaque references the receiving service looks up. Scopes are permissions such as orders:create or invoices:read.3 When a person approves them on a consent screen, and the application keeps a record of that approval, the record helps identify who granted technical access and for what purpose. Compare it with that person’s own authority and the company’s mandate when assessing actual authority. Scopes are also known to the service that checks the token, so they may shape what the other side could reasonably believe.4
The limit is that ordinary scopes are coarse. orders:create says nothing about $10,000, approved vendors or product categories. A mandate usually has more detail than any scope can hold.
Add-on standards can carry more of the agent’s mandate
Several later IETF standards build on OAuth. Three can record more of what the principal approved, and a fourth lets access end early.
- Rich authorization requests let a client ask for, and the authorization server grant, structured authorization details, such as an amount, a currency or a type of transaction, instead of a scope name alone. The service can read the granted details from the token or by asking the authorization server. The authorization server and the service receiving the token both have to enforce those details; putting a dollar amount in a token doesn’t by itself stop a larger order.5
- Token exchange lets a client trade a token for a new one, for example when a subagent authenticates with its own credentials to obtain a token for its part of a task, or when an agent exchanges its token for a narrower downstream token. The authorization server can make the new token narrower than the original and record the chain of delegation in an actor (“act”) claim, though the standard requires neither step. Where an actor claim is used, the receiving service relies on the top-level claims and the current (outermost) actor for access decisions; nested prior actor claims can help trace earlier handoffs, but are informational only. Check the mandate and the actual order to establish what the company authorized and who acted.6 Revoking the original token also doesn’t automatically revoke tokens obtained from it.7 Decide whether new tokens must be narrower, whether the chain must be recorded, and what happens to them when the original is revoked.
- Resource indicators let the client name the service a token is for, so the authorization server can limit the token to that service. If the client names none, the authorization server may apply a default. The limit works when the authorization server restricts the token to the intended vendor’s service and that service checks that each token was issued for it. MCP goes further and requires clients to name the service.8
- Revocation lets a client tell the authorization server to invalidate a token before it expires. Authorization servers that implement this standard must support revoking refresh tokens, while revoking access tokens is only recommended. Because the endpoint is client-initiated, cutting off a compromised or third-party-hosted agent usually requires revoking its grant or disabling its client directly through the authorization server’s administrative controls rather than relying on the agent client to call revocation. Many access tokens are also checked by the receiving service without asking the authorization server, so a revoked token can keep working there until it expires.9 Short lifetimes limit the exposure from any one token, but expiry isn’t the end of access: the client can use a refresh token, or its still-valid credentials, to get a new token. Cutting an agent off means stopping the authorization server from issuing or refreshing tokens for it, and revoking tokens and ending sessions already active. Ending the agent’s legal authority is a separate step. It depends on the mandate and on notice to those the agent deals with.
Two ways an agent gets a token
In the authorization code flow, a person signs in and approves access for the agent, or an administrator approves it in advance. OAuth doesn’t require the authorization server, often run by the vendor, to keep a record of who approved, so the deploying company should keep its own: log who approved, which scopes were granted and when, and keep that log with the agent’s mandate. The approval gives the agent access to the service within those scopes, often for weeks through refresh tokens. It doesn’t approve each order; authority for an order has to come from the mandate or from a person whose own authority covers that order.
In the client credentials flow, the agent proves its identity with its own credentials, and no person approves access when it connects. This flow is common for back-office agents. The only approval of the agent’s access is the setup: usually an administrator registers the agent and chooses its scopes in advance. The deploying company should record who did that and which scopes were granted, and keep that record with the agent’s mandate.
Current security practice
The IETF’s RFC 9700 (Jan. 2025) sets out current best practice for OAuth security, updating the original OAuth specifications.10 Among other things, it recommends tokens tied to the client they were issued to, so a stolen token is harder to use. A contract that requires “industry-standard OAuth security” may well be measured against RFC 9700. A provider that ignores RFC 9700 will have a harder time showing it used reasonable care.
API keys and service accounts
API keys are the older alternative to OAuth tokens. Instead of a scoped, expiring token issued after someone approves access, the agent holds a static API key: a fixed secret string that works like a password for software. Many agents still run on these keys, or on shared service accounts, logins used by software rather than a person. Keys and shared accounts create three legal problems.
- All-or-nothing access. Many keys grant everything the account can do. That leaves the widest possible gap between what the agent can do and what anyone approved.
- No record of who acted. A key used by three agents and an engineer can’t show which of them placed an order.
- No natural end. Keys often never expire. Unless someone revokes the key, the agent’s access outlasts both the job and its legal authority.
Each problem makes it harder to prove what was authorized and easier for a counterparty to argue that the company, by handing over its credentials, led the counterparty to believe the agent had authority.
Roles and rules inside the company. Access is usually managed through roles (role-based access control: a “buyer” role may place orders up to $10,000) or through rules on attributes (attribute-based access control: amount, vendor status, department, credential expiry). Roles look like an authority matrix. Attribute rules come closest to enforcing a mandate in code. The closer the access model tracks the authority matrix, the smaller the gap between permission and approval.
MCP and tool connections
The Model Context Protocol is an open protocol for connecting AI applications to tools and data. When an agent “uses a tool,” it’s often calling an MCP server, a program that makes a tool or data source available to agents. MCP doesn’t replace OAuth: MCP handles the connection between an agent and a tool, and OAuth handles whether the agent may use the tool.
In MCP terms, the agent, or the AI application running it, is the client, and the MCP server plays the role of the service: it checks the agent’s token before letting the agent use the tool. An MCP server often sits in front of another system, such as a vendor’s ordering system, and calls that system for the agent. Some MCP servers run over the web; others run locally on the user’s machine.
MCP’s authorization specification (version dated July 28, 2026) adopts OAuth 2.1 and adds requirements of its own.11 OAuth 2.1 is still an IETF draft rather than a finished standard, so a contract that requires “OAuth 2.1 compliance” should say which draft it means. Several rules in the specification matter legally:
| MCP rule | What it does | Why it matters legally |
|---|---|---|
| Authorization is optional | MCP servers may run without authorization. Connections over HTTP, whether across the web or on the same machine, that use authorization should follow MCP’s authorization rules. MCP servers that an application starts as a local process (the “stdio” transport) should instead take credentials from their environment, such as a key stored on the machine. | Many agent tools use whatever key is stored on the machine. Whose key it is decides whose account the agent acts in, and what the key allows decides what the agent can do, even if the agent’s mandate allows less. |
| Tokens limited to one server | An MCP server must accept only tokens the authorization server issued for that MCP server | The audience check confirms which service a token was issued for, so a token issued for one service can’t be used at another. It doesn’t show that a particular action is within what the principal approved; that takes separate checks of the token’s scope, the account or tenant (the customer’s own space within a shared service), and the transaction |
| No token passthrough | If the MCP server needs another system to complete the agent’s task, it never forwards the agent’s token to that system. If that system’s API uses OAuth, the MCP server uses a separate token issued for that API; otherwise it follows that API’s own authentication requirements. | A vendor receiving an order applies its own access rules. If the MCP server signs in to the vendor, check whose account it uses and what that account may do. It could be the provider’s or the customer’s, and its permissions may exceed the agent’s mandate. A public resource may require no credential. |
| Least privilege and step-up | The agent asks the authorization server for only the scopes it needs. If the agent later tries something its token doesn’t allow, the MCP server should refuse, and the agent can ask the authorization server for the additional scope. That second request is the step-up. An agent acting on its own behalf, with no person in the flow, may stop instead. | A step-up request is a natural point for a person to review what the agent is doing. Whether a person is asked depends on how the authorization server is configured, so the deploying company should require, or ask the vendor to require, a person’s approval before broader scopes are granted. Broader scopes give the agent access to the tool. Before placing an order, check it against the mandate and the counterparty agreement. An order covered by standing authority can proceed. If either requires approval for that order, obtain it from someone authorized to approve it and record it with the order. |
Machine-readable authority
A central problem in agent authority is that the counterparty usually can’t see the agent’s limits. Limits a vendor has no way to know generally won’t defeat its reasonable reliance. Verifiable credentials, a standard of the W3C since 2019 (version 2.0 published May 2025), let software verify who issued a credential and detect changes to its claims, such as a statement about what someone may do. A digital signature is one way to provide those checks.12 In principle, a verifiable credential could carry an agent’s mandate: whose agent it is, what it may buy, up to what amount, until when. A vendor’s system could check the credential before accepting an order.
A companion W3C Recommendation, Bitstring Status List (May 2025), lets whoever issued a credential, such as a company whose credential carries its agent’s mandate, publish whether the credential has been revoked or suspended.13 That matters for an agent mandate: a vendor could check whether the issuer has revoked or suspended the credential, not only that it was once granted. The check shows the issuer’s published status as of the list the vendor retrieved, and a cached list can be out of date. It doesn’t by itself show that the legal mandate is still in force or that a transaction fits its limits; relying on the credential also takes checks of its validity period, the issuer and the transaction.
This is an emerging use, not established practice. The example below shows selected fields from Acme’s mandate. To check an actual order, the vendor would also need the agreed terms, the running total with that vendor and any required approval reference. The example uses a custom schema and omits the cryptographic proof a vendor would need to verify the credential. Its second context tells software processing it to keep the custom terms; real use would need a published context and agreed meanings for terms such as amounts and categories. It expires at 05:00 UTC on Jan. 1, 2027 (midnight as Jan. 1 begins in New York, expressed in UTC as the W3C specification recommends), so it covers all of Dec. 31 as Acme’s mandate specifies. It uses Acme, the company in this guide’s worked example below. The credential’s issuer is named by a decentralized identifier tied to Acme’s web domain.
{
"@context": ["https://www.w3.org/ns/credentials/v2", "https://www.w3.org/ns/credentials/undefined-terms/v2"],
"type": ["VerifiableCredential", "AgentMandate"],
"issuer": "did:web:acme.example",
"validUntil": "2027-01-01T05:00:00Z",
"credentialSubject": {
"agent": "acme-procurement-agent-01",
"actsFor": "Acme Corp.",
"mayPurchase": ["servers", "networking-hardware"],
"maxPerOrder": { "amount": 10000, "currency": "USD" },
"subAgents": "prohibited"
}
}
If a vendor’s system checks a mandate like this, the vendor would struggle to claim it reasonably believed the agent could exceed the mandate’s limits. Whether a check run by software gives the vendor itself notice is still unsettled.
Payment networks
The card networks are building their own ways to recognize agents and record what each agent was allowed to do. These are industry specifications, not law. But they decide what a merchant can see when an agent pays, and that bears on whose act the payment was and whether the merchant’s reliance was reasonable.
- Visa Trusted Agent Protocol (Oct. 14, 2025, developed with Cloudflare): signed messages that let merchants recognize approved agents, tell them apart from malicious bots, and receive what the agent intends to buy and, optionally, payment details. It is built on the IETF’s HTTP Message Signatures standard.14
- Mastercard Verifiable Intent (Mar. 5, 2026, co-developed with Google and open-sourced): a tamper-resistant record linking the cardholder who authorized the agent, the cardholder’s instructions, and the agent’s dealings with the merchant. For purchases the agent makes with less direction from the cardholder, it gives merchants information to decide whether to ask for further confirmation.15
- Know-Your-Agent collaboration (announced Sept. 9, 2026 by Ant International, Mastercard and Visa): an exploratory effort toward common principles for linking each agent to the verified company or person that runs it, certifying agents and monitoring them over time. It aims to bridge the three companies’ protocols, while each network keeps its own verification and decisions.16
None of these yet settles who bears the loss when an agent pays without authority. That still turns on payment law (UCC Article 4A for business wires and other funds transfers; the card agreement and, for credit cards, Regulation Z for card payments), network rules and the parties’ contracts. See Who bears the loss when an agent makes a payment?
NIST’s agent work
NIST has begun studying agents directly. None of this work is binding, but it is likely to set the vocabulary for contracts and for what counts as reasonable care.
- AI Agent Standards Initiative (launched Feb. 17, 2026): an effort focused on industry-led standards, interoperable agent protocols, and research on agent authentication and security.17
- Software and AI Agent Identity and Authorization (concept paper from NIST’s National Cybersecurity Center of Excellence, Feb. 2026): how to identify, manage and authorize the actions of software agents, including AI agents. The comment period closed Apr. 2, 2026. Following public feedback, the NCCoE aligned its initial implementation use case with its DevSecOps project, working toward a practice guide in its SP 1800 series.18
- NIST AI 200-2, the TEVV-Athlon Framework (initial public draft, Aug. 7, 2026; TEVV stands for test, evaluation, verification and validation): a method for designing evaluations of AI systems, expressly including agentic systems. The comment period closed Oct. 6, 2026.19
- AI Risk Management Framework: the voluntary governance framework, which NIST is revising under the White House AI Action Plan (as of Nov. 2026).20
- SP 800-63-4 (July 2025): NIST’s guidelines for verifying people’s identities online. Its authentication assurance levels, which grade how strongly a person’s sign-in is verified, are a useful benchmark for how strongly the person approving an agent’s actions should be verified.21
The AI Risk Management Framework is organized around four functions. Applied to agent authority, each function points to a different set of issues:
| Function | For agent authority |
|---|---|
| Govern | Who may deploy agents, grant authority, set limits, approve new tools and revoke authority |
| Map | What each agent can actually affect: read data, negotiate, change contract text, place orders, trigger payments |
| Measure | Whether the controls hold: can the agent exceed a limit, be steered by planted instructions, deal with an unapproved counterparty, or start a subagent with broader access? |
| Manage | The responses: approval steps, enforced limits, narrow scopes, logging, credential expiry, shut-off, review, insurance and contract terms |
How standards become law
Technical standards aren’t law, but they can affect legal outcomes in four ways.
- By contract. An agreement can require compliance with a named standard, such as MCP’s authorization rules or a NIST assurance level. Compliance with that standard then becomes a contract term.
- Through “commercially reasonable.” Under UCC Article 4A, a business can be bound by a payment order it didn’t actually authorize if the order passed a security procedure the business agreed with its bank. That holds only if the procedure is commercially reasonable and the bank proves it accepted the order in good faith, followed the procedure and complied with applicable restrictions on acceptance. The bank has to have a reasonable opportunity to act on a customer’s instruction before acceptance and need not follow one that conflicts with their agreement. Check the governing enactment for the required form of the agreement or instruction, as explained in The agent made a payment.22 Commercial reasonableness is judged partly by the procedures in general use among similar customers and banks, so as agent credential standards mature, they are likely to set that benchmark. Article 4A covers wires and other funds transfers, not card payments; for cards, see The company’s travel agent booked a nonrefundable stay. UETA gives a security procedure less force: a record that passes the procedure isn’t automatically the act of the person it appears to come from. Showing that the procedure was applied to the record and was effective is one way to prove whose act the record was, but it isn’t conclusive.23
- Through negligence. Industry practice is evidence of reasonable care, though not conclusive. A whole industry can lag behind what is reasonable.24 Failing to use available controls, like scoped tokens, may look careless to a court after a loss. Between contracting parties, though, the economic loss rule often bars a negligence claim for purely financial loss. In those cases, the same evidence usually goes to whether a party met a contract duty such as “reasonable security.”25
- Through regulation and procurement. Regulators and large buyers cite standards in rules and questionnaires, and those references tend to spread to other rules and contracts. See The Regulatory Overlay.
When a contract names a standard, say whether it means a fixed version or the standard “as amended.” Several of the standards above are drafts or under revision, so an open-ended reference can change a party’s obligations without anyone signing anything. Agent Use Clauses has sample language for either choice, with a grace period before a revision applies.
A provider contract should also make this guide’s credential recommendations binding: one set of credentials per agent, limited permissions and expiry. Sample language is in Agent Use Clauses under credentials and shut-off (clause 8), with related terms on designated agents and their limits (clause 1) and logs and evidence (clause 7).
Not every document called a standard carries the same weight. As a rough rule of thumb, not settled doctrine, the weight a document carries tends to run from law and regulation, to government frameworks such as NIST’s, to formal standards bodies such as the IETF, W3C and ISO, to industry protocols such as MCP, to widespread platform practice, and finally to a single vendor’s documentation. Courts and arbitrators may weigh them differently in a given dispute.
From mandate to control
For each term in an agent’s written mandate, name the control that enforces it.
| Mandate term | Control | Standard or mechanism |
|---|---|---|
| Acts only for Acme | A separate identity for the agent, with its grants bound to Acme’s account or tenant | OAuth client registration; workload identity; tenant-bound grants |
| May place orders | The vendor’s service checks for the ordering scope before accepting a request | OAuth scopes |
| Up to $10,000 per order | A limit check before the order is sent, an amount limit the vendor’s service enforces, and a capped card as a payment backstop | Orchestrator checks; rich authorization requests enforced by the authorization server and the vendor’s service; card controls |
| Approved vendors only | Tokens limited to each approved vendor’s service, plus a vendor or payee check on each order where one service hosts several vendors | Resource indicators; allowlists; order-level checks |
| Human approval for otherwise permitted orders above $5,000 through $10,000, the first order with a vendor, or the first under the Addendum | A person’s approval of the specific order, recorded with it | Approval workflow; strong authentication for approvers (step-up alone doesn’t approve a transaction) |
| No subagents | The orchestrator and tool list block calls to other agents; no token exchange | Orchestration and tool policy; token exchange disabled |
| Ends Dec. 31 | No new or refreshed tokens after Dec. 31, active tokens revoked, and counterparties told | Deactivating the agent’s client registration; refresh-token and token revocation; short-lived tokens to limit exposure; notice to counterparties |
| A record of who acted | Logs of the credential identifier (never the live token), the actor claim, the approval and the result | Actor claims; audit logs |
Use this table in step 3 of the authority review, when you name what enforces each line of the mandate, and record the answers in the Agent Mandate’s gap column. The control map in Building Limits into Agent Systems covers the controls in more detail.
Acme, with standards
Acme, the company in this site’s running example, limits its procurement agent to $10,000 per order. Consider what happens when the agent tries to place a $42,000 order under two different setups.
- Built on a borrowed key. The agent holds a card with a $100,000 limit and uses an API key copied from an Acme buyer’s account with the vendor. The key can do anything the buyer can. The vendor sees orders from Acme’s account and nothing to show an agent placed them. The logs can’t distinguish the agent from the buyer. The account record supports attributing the order to Acme. If the vendor relies on apparent authority, it must show that Acme’s words or conduct led it reasonably to believe the buyer could place an order of this size. Acme also has a hard time proving the agent acted outside its mandate.
- Built on standards. Acme gives the agent its own client identity and a virtual card capped at $10,000 per payment. The Director of IT Procurement, whose own limit is $25,000, approves the $10,000 order limit. The CFO also approves deployment because the agent can authenticate orders and pay by card. Short-lived access tokens carry the order limit and are usable only at the vendor’s service. Acme stops issuing tokens when the mandate ends and limits each token’s lifetime to the remaining term. The ordering tool blocks the $42,000 request before sending it. If the tool misses the limit, the vendor’s service checks the grant and rejects the order. An approval request goes to an officer whose delegated authority covers $42,000, asking whether Acme should place that purchase separately. A procurement manager can check the order first, but that check isn’t the approval. If the officer declines, no order is placed. If the officer approves, the agent still has a $10,000 ceiling. An authorized buyer can submit the order through a separate purchasing channel that permits $42,000. Acme records the approval and who actually submitted the order. That record is strong evidence of authorization, though the approval’s legal effect still depends on the officer’s authority and Acme’s agreement with the vendor.
The legal rules are the same in both versions. In the first version, Acme must reconstruct an order the vendor received. In the second, Acme can show which control stopped the request and whether an authorized buyer later placed a separate order.
Both sides of the deal
For diligence on any agent product, or for a security questionnaire, use the Agent Diligence Questions in the Toolkit. They cover the points in this guide, including each agent’s identity, who approves its access, how tool connections such as MCP servers are authorized, which limits the product enforces, revocation and logs, and they flag the answers that should worry you. Providers can answer them in one form, the Agent Authority Profile.
If you deploy agents
- Replace shared keys with per-agent identities and scoped, expiring, revocable tokens.
- Write the mandate first, then map each term to a control using the table above.
- Require named standards in provider contracts where a relevant standard exists.
If you build agents
- Support scoped, expiring, revocable credentials per agent, and document them.
- Follow MCP’s authorization rules, including no token passthrough.
- Expect buyers to ask the Agent Diligence Questions. Have written answers, or fill in an Agent Authority Profile.
Open questions
- Will courts treat an approved OAuth scope as a manifestation of actual authority, apparent authority, or both?
- When agent credential standards mature, will a business’s use of shared keys stop being “commercially reasonable” under Article 4A?
- Does a machine-readable mandate change what a counterparty is taken to know? If the counterparty’s system checks the mandate, is the counterparty charged with notice of the mandate’s limits? If the system could have checked and didn’t, can the counterparty still claim reasonable reliance?
- 18 U.S.C. § 1030(a)(2), (e)(6) (opens in a new tab); Van Buren v. United States (opens in a new tab), 593 U.S. 374 (2021) (asking whether a person may enter a system or area of it, not why). See Technical Permission vs. Legal Authority. ↩
- IETF RFC 6749, The OAuth 2.0 Authorization Framework (opens in a new tab) (2012), abstract & § 1. ↩
- IETF RFC 6749 § 3.3 (opens in a new tab) (scopes). ↩
- Restatement (Third) of Agency §§ 2.01, 2.03, 3.03 (opens in a new tab) (Am. L. Inst. 2006) (actual and apparent authority). See Technical Permission vs. Legal Authority. ↩
- IETF RFC 9396, OAuth 2.0 Rich Authorization Requests (opens in a new tab) (2023). ↩
- Restatement (Third) of Agency § 3.15 (opens in a new tab). See Can an agent hand off work to another agent? ↩
- IETF RFC 8693, OAuth 2.0 Token Exchange (opens in a new tab) (2020), §§ 2.1 (effect of exchange), 4.1 (“act” claim). ↩
- IETF RFC 8707, Resource Indicators for OAuth 2.0 (opens in a new tab) (2020), § 2.1 (default resource); Model Context Protocol, Specification: Authorization (version 2026-07-28) (opens in a new tab) (clients must send the resource parameter). ↩
- IETF RFC 7009, OAuth 2.0 Token Revocation (opens in a new tab) (2013), §§ 2–3; see also IETF RFC 6749 §§ 1.5, 4.4, 6 (opens in a new tab) (refresh tokens and client credentials). ↩
- IETF RFC 9700, Best Current Practice for OAuth 2.0 Security (opens in a new tab) (Jan. 2025). ↩
- Model Context Protocol, Specification: Authorization (version 2026-07-28) (opens in a new tab). ↩
- W3C, Verifiable Credentials Data Model 1.0 (opens in a new tab) (Recommendation, Nov. 19, 2019); W3C, Verifiable Credentials Data Model v2.0 (opens in a new tab) (Recommendation, May 15, 2025). ↩
- W3C, Bitstring Status List v1.0 (opens in a new tab) (Recommendation, May 15, 2025). ↩
- Visa, Visa Introduces Trusted Agent Protocol: An Ecosystem-Led Framework for AI Commerce (opens in a new tab) (press release, Oct. 14, 2025); IETF RFC 9421, HTTP Message Signatures (opens in a new tab) (2024). ↩
- Mastercard, When AI Starts Buying for You, Trust Becomes the Product (opens in a new tab) (Mar. 5, 2026). ↩
- Ant International, Ant International, Mastercard and Visa Initiate Collaboration on Know-Your-Agent Interoperability to Scale Agentic Commerce (opens in a new tab) (press release, Business Wire, Sept. 9, 2026). ↩
- NIST, AI Agent Standards Initiative (opens in a new tab) (Feb. 17, 2026). ↩
- NIST NCCoE, Accelerating the Adoption of Software and AI Agent Identity and Authorization (opens in a new tab) (concept paper, Feb. 2026); NCCoE, project resource hub (opens in a new tab) (accessed Nov. 15, 2026). ↩
- NIST AI 200-2 (initial public draft), The TEVV-Athlon Framework for Evaluating AI Systems (opens in a new tab) (Aug. 7, 2026). ↩
- NIST AI 100-1, AI Risk Management Framework 1.0 (opens in a new tab) (2023); NIST, AI RMF page (opens in a new tab) (revision under way). ↩
- NIST SP 800-63-4, Digital Identity Guidelines (opens in a new tab) (July 31, 2025; web page posted Aug. 1, 2025). ↩
- U.C.C. § 4A-202(b)–(c) (opens in a new tab). ↩
- Unif. Elec. Transactions Act § 9(a) (opens in a new tab) (Unif. L. Comm’n 1999); see also id. § 14 (contracts formed by electronic agents) and Can software make a contract? ↩
- The T.J. Hooper (opens in a new tab), 60 F.2d 737 (2d Cir. 1932); Restatement (Third) of Torts: Liab. for Physical & Emotional Harm § 13(a) & cmt. b (opens in a new tab) (Am. L. Inst. 2010) (custom). ↩
- Restatement (Third) of Torts: Liab. for Econ. Harm § 3 (opens in a new tab) (Am. L. Inst. 2020). The rule and its exceptions vary by state. ↩
Technical standards change often. The mandate example is illustrative only.