| Internet-Draft | Agent Handoff Context | November 2026 |
| Srivastava | Expires 19 May 2027 | [Page] |
When one agent hands a task to another, the receiver needs to know who handed it over, on whose behalf, through which earlier agents, and which prior context the work depends on. It needs to know the handoff is fresh and meant for it, and the sender needs a clear answer back. This document defines a small, transport-neutral handoff context: a signed offer, a signed status reply, and the chain of earlier offers that led to the current one, in CDDL for JSON and CBOR, with a lifecycle that maps to Agent2Agent task states. Each offer names the one before it by hash, so a dropped or reordered intermediate hop is detectable when the chain is carried. Prior context is named by digest only. The document is input to the agentproto working group's use cases and dialog-context work.¶
This note is to be removed before publishing as an RFC.¶
Discussion of this document takes place on the Agent Communication Protocols (agentproto) Working Group mailing list (agentproto@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/agentproto/.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
Agent systems hand work across agents, vendors, and trust boundaries. A planner agent asks a coding agent to write a patch; the coding agent asks a test agent to run it. Each hop raises the same questions for the agent that receives work:¶
The sender, in turn, needs a clear answer: accepted, rejected and why, completed, or failed.¶
The individual draft "Agentic AI Use Cases and Requirements" [I-D.agentic-ai-usecases-requirements] states several of these needs as requirements. For example, its B3-6 asks for a verifiable provenance record of a request and its response across a delegation chain, such that removal of a hop is detectable; B3-7 asks that a receiver can detect and reject a delegation chain that contains a cycle; and B3-9 asks that dialog context propagate across each hop. The same document places accountability and auditing out of its own scope.¶
This document describes one way to meet part of those per-hop needs with a small element that existing agent protocols can carry, without defining an audit log. It links the offers that hand work along a chain. It does not cover responses, and it does not attribute transformations to hops. Section 7 says, for each requirement it touches, what is and is not met.¶
An authorization token answers one question: may this agent act, and within what limits. A handoff raises questions that a token does not carry. Which agent handed this work over, to which agent, in which dialog, and when? Which earlier handoffs led here? Which prior context does the work depend on? Did the receiver take the work, and how did it end? OAuth 2.0 Token Exchange [RFC8693] can record a history of actors inside a token, but the token is issued by an authorization server, not by the agent handing over, and it says nothing about the dialog or about the answer back. The element defined here is signed by the agents themselves, at each hop, and is small enough to travel beside whatever token the host protocol carries.¶
This document defines:¶
The following are out of scope:¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
Member names are short text strings so that one definition serves JSON and CBOR. Except in Digest, which is closed, a receiver MUST ignore members it does not understand and a forwarder MUST NOT remove them from a signed offer or status, since they are covered by the signature. Members of the Handoff object itself (Section 2.1) are not signed.¶
HandoffOffer = {
v: 1,
type: "offer",
hop: HopId,
dialog: text,
? task: text,
iss: AgentId,
aud: AgentId,
iat: Time,
exp: Time,
? obo: Principal,
? grant: Digest,
? prev: Digest,
? refs: [+ ContextRef],
* text => any
}
¶
HandoffStatus = {
v: 1,
type: "status",
hop: HopId,
offer: Digest,
iss: AgentId,
aud: AgentId,
iat: Time,
state: State,
? reason: Reason,
? detail: text,
? refs: [+ ContextRef],
* text => any
}
State = "accepted" / "rejected" / "completed" /
"failed" / "canceled"
Reason = "bad-signature" / "untrusted-key" / "wrong-audience" /
"stale" / "replay" / "equivocation" / "broken-chain" /
"cycle" / "too-deep" / "unverifiable-ref" /
"ref-mismatch" / "policy" / text
¶
HopId = text .regexp "[A-Za-z0-9_-]{22,64}"
AgentId = text
Time = uint
Principal = {
sub: text,
? iss: text,
* text => any
}
Digest = {
alg: "sha-256" / text,
val: B64u
}
B64u = text .regexp "[A-Za-z0-9_-]+"
ContextRef = {
kind: "digest" / "salted-digest" / "scitt-receipt" / text,
dig: Digest,
? loc: text,
? proof: any,
* text => any
}
; In JSON, a chain element is SignedHandoffJson.
; In CBOR, a chain element is SignedHandoffCbor.
SignedHandoff = SignedHandoffJson / SignedHandoffCbor
SignedHandoffJson = JwsCompact / B64u
SignedHandoffCbor = JwsCompact / bstr
JwsCompact = text .regexp
"[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+"
¶
In Principal, sub identifies the principal, and iss, when present, names the issuer in whose namespace sub is unique.¶
Time is seconds since 1970-01-01T00:00:00Z, ignoring leap seconds, as an integer.¶
Digest is a closed map: it has exactly the two members shown. Its alg names the hash function, and its val is the full hash output in base64url without padding. This document defines one value, "sha-256", meaning SHA-256 [RFC6234], which implementations MUST support. Other values are left to future specifications, which MUST NOT define a hash whose output is shorter than 256 bits. A receiver that does not implement the alg of a Digest MUST treat a check that depends on it as failed for prev and grant, and as unverifiable for refs.¶
What the host protocol carries is a Handoff: the signed offer together with its chain.¶
Handoff = {
offer: SignedHandoff,
? chain: [+ SignedHandoff],
* text => any
}
¶
The chain is outside the signature on purpose. The prev links already fix its membership and order, and a chain inside each signed offer would double in size at every hop; outside, it grows by one offer per hop. A chain that does not connect to the offer fails Section 5.5; a removed chain is simply absent, and the receiver's policy treats it as any missing chain.¶
A status is carried on its own, as a SignedHandoff.¶
A ContextRef names prior context by digest. It says "the sender asserts that this work depends on the object with this digest". It does not say what the object means.¶
A receiver that checks a reference reports one of four outcomes: verified (digest matched and any proof checked against a key it trusts), mismatch, unverifiable (it could not obtain or check the object), or not checked. A receiver MUST NOT report a reference as verified unless it performed the check. These outcomes follow the distinction drawn in [I-D.he-agentproto-verifier-evidence] and [I-D.konda-agentproto-evaluation-state] between a negative result and a result that could not be established.¶
An assistant agent has handed a task to a planner, and the planner now hands part of it to a coder. The planner's offer payload, before signing, is:¶
{
"v": 1,
"type": "offer",
"hop": "q3Zl0v8bVfQmJm2c4bq1Ww",
"dialog": "ctx-7c1e",
"task": "task-42",
"iss": "spiffe://a.example/agent/planner",
"aud": "spiffe://b.example/agent/coder",
"iat": 1793000000,
"exp": 1793000120,
"obo": {
"sub": "u-8f2a",
"iss": "https://idp.u.example"
},
"grant": {
"alg": "sha-256",
"val": "SKLjsfET5xtZoO5hzIiZFigz2JoYZLmW8Cg8GuYh4o4"
},
"prev": {
"alg": "sha-256",
"val": "M-OyKnHLAGKpiZKw7sNqAsNKmtfRQ7DUFhtKAL3Slmg"
},
"refs": [
{
"kind": "digest",
"dig": {
"alg": "sha-256",
"val": "V_WPM8F9ztg6WxBxj1ZIGnzRbM1Xyp5GVdpEYmwbvuQ"
},
"loc": "https://a.example/ctx/9"
}
]
}
¶
The planner signs it with ES256 and sends it as a Handoff whose chain holds one element, the assistant's signed offer to the planner. prev is the handoff digest of that element; grant is the digest of the credential the coder will be given; the reference names, by digest, a JSON object the coder is expected to fetch from loc. The coder accepts and replies with this status payload, signed with its own key; offer is the handoff digest of the planner's signed offer.¶
{
"v": 1,
"type": "status",
"hop": "q3Zl0v8bVfQmJm2c4bq1Ww",
"offer": {
"alg": "sha-256",
"val": "kJIcudVNmFFwbYKTXNO3mqC3e9dQSWVXDNbamGeoP18"
},
"iss": "spiffe://b.example/agent/coder",
"aud": "spiffe://a.example/agent/planner",
"iat": 1793000003,
"state": "accepted"
}
¶
Every offer and status MUST be signed by its iss. An unsigned element MUST be treated as absent.¶
The payload is the JSON form of the element. The signed handoff is the JWS Compact Serialization [RFC7515].¶
The payload is the CBOR form of the element. The signed handoff is a COSE_Sign1 message [RFC9052] with tag 18.¶
In a JSON chain, a COSE signed handoff is carried as base64url text, which never contains a period and so cannot be confused with a JWS. In a CBOR chain, a JWS is carried as text and a COSE message as a byte string.¶
The handoff digest is SHA-256 over the signed handoff's octets exactly as sent: the ASCII octets of the JWS Compact Serialization, or the encoded tagged COSE_Sign1 message. Hashing what was signed, as sent, avoids any need for canonical JSON. A party that forwards a signed handoff in a chain MUST forward these octets unchanged.¶
This document does not define how a receiver learns that a key speaks for an AgentId. A receiver MUST use a key only if its own trust configuration binds that key to the iss of the message, for example through workload identity credentials of the kind WIMSE is chartered to define, X.509 certificates chaining to a configured anchor, or keys configured out of band. A key carried inside the message itself, without such a binding, shows nothing about who signed. A receiver MUST accept each trusted key with exactly one algorithm (Section 3.1 of [RFC8725]).¶
The agentproto charter asks for a reference architecture describing related protocol building blocks that the dialog management protocol can reuse, including identity and authentication. This element is meant to use whatever that architecture names.¶
Each hop has its own lifecycle, held separately by the delegator and the delegate.¶
offer (delegator)
|
v
+---------+ rejected (delegate)
| offered |---------------------> [rejected]
+---------+
| | canceled (delegator)
accepted | +-----------------------> [canceled]
(delegate) v
+----------+ canceled (delegator)
| accepted |--------------------> [canceled]
+----------+
| |
completed | | failed (delegate)
(delegate) v v
[completed] [failed]
Brackets mark terminal states. Not drawn: "completed" or
"failed" sent directly from "offered" (accepted is implied),
and the local, provisional state "expired". A "rejected"
with reason "stale" or "replay" is not terminal (Section 5.3).
The host protocol keeps its own task state. The table gives the nearest A2A TaskState [A2A] for each hop state; A2A states with no entry, such as TASK_STATE_INPUT_REQUIRED, stay in the host protocol.¶
| Handoff state | Nearest A2A TaskState |
|---|---|
| offered | TASK_STATE_SUBMITTED |
| accepted | TASK_STATE_WORKING |
| rejected | TASK_STATE_REJECTED |
| completed | TASK_STATE_COMPLETED |
| failed | TASK_STATE_FAILED |
| canceled | TASK_STATE_CANCELED |
A delegate that receives an offer performs these checks. The first failure ends processing. Except where a check says otherwise, the delegate SHOULD send a "rejected" status with the reason shown, unless doing so would itself leak information its policy protects.¶
If all checks pass and the delegate takes the work, it sends "accepted".¶
Only the outer offer's expiry is checked. Earlier offers in a chain are history; Section 5.5 checks only that each was live when the next was issued.¶
Messages can be lost in either direction. A delegator that has not received a status it expects learns the state of the hop by asking again, never by guessing. This follows Section 4.2.1 of [I-D.agentic-ai-usecases-requirements]: check the outcome before resending, and leave an outcome that cannot be determined unresolved.¶
"completed" and "failed" are claims about what happened. A delegate makes them only when it knows, including after a crash or a lost acknowledgement from its own storage.¶
How the outcome is recorded is the delegate's business. This document requires only that "completed" and "failed" be true when sent.¶
Let C[0..n-1] be the decoded chain, oldest first, and O the current offer. For uniformity, let C[n] denote O.¶
Failures of checks 2 through 4 use reason "broken-chain".¶
A verified chain shows that each listed agent signed an offer to the next, in that order, while the earlier offer was live. Removing or reordering an intermediate hop breaks check 2 or 3. It does not show that the agents were authorized, or that what they said was true (Section 8.1). It also does not show that an earlier offer had not been rejected or canceled when the next was issued.¶
The obo member names the principal for whom the root of the chain acted, such as a user. Prior delegators appear in chain. OAuth 2.0 Token Exchange [RFC8693] records a similar actor history with nested "act" claims, where the outermost actor is current and nested actors are earlier ones. As with nested act claims in Section 4.1 of [RFC8693], the prior delegators in chain are informational. Unlike a token's sub claim, obo is not an authorization claim. A receiver MUST NOT make an access control decision based on obo or chain alone.¶
Authority comes from credentials that the host protocol carries, issued under OAuth, WIMSE, or a similar framework. The grant member lets the delegator bind the hop to one such credential by digest. A receiver that is given a credential with the hop can check that it is the one the delegator named. Whether the credential's authority exceeds what the previous hop held (B3-8 in [I-D.agentic-ai-usecases-requirements]) is for that framework to decide, not this element.¶
The handoff context is meant to travel inside the host protocol's own messages. This document defines no new transport and no HTTP header.¶
For each requirement of [I-D.agentic-ai-usecases-requirements] that this element touches: what it provides, then what it leaves to other mechanisms.¶
[I-D.bu-agentproto-security-principal-binding] asks a protocol to state, for each security-relevant claim, its carrier, verifier, binding, freshness, and failure, among other fields. This element makes five. That the offer comes from iss: carried by the signature, verified by the delegate against a key its trust configuration binds to iss (Section 3.4), kept fresh by iat, exp, and hop (Section 5.2), failing as "rejected" with bad-signature, untrusted-key, or stale. That the offer is for this receiver in this dialog: carried by aud and dialog under the signature, bound by aud equal to the delegate's AgentId and dialog equal to the host identifier, failing as wrong-audience or policy. That the offer follows the earlier offers in order: carried by prev and the chain, bound by the handoff digests with continuity and timing (Section 5.5), kept fresh by check 4 there, failing as broken-chain, cycle, or too-deep, or unverifiable where a key is untrusted. That the work depends on the referenced context: carried by refs, verified when policy requires, bound by the object's digest and any proof, with no freshness of its own, failing as unverifiable-ref, ref-mismatch, or not checked (Section 2.2). That the delegate answered as stated: carried by the signature over the status, verified by the delegator (by the delegate, for "canceled") against a key bound to status.iss, bound by status.offer equal to the offer's digest, with the first verified status standing except a "stale" or "replay" rejection (Section 5.6), a conflicting status being discarded and the conflict flagged to the operator.¶
A delegator can omit prev and the chain and present itself as the start. The offer is still valid. A receiver that needs to know the origin MUST require a full chain whose first element is signed by an origin it trusts. Without the chain, a receiver also cannot tell whether the delegator passed on an offer that had expired, been rejected, or been canceled.¶
Replay protection depends on the receiver keeping its (iss, hop) cache and on loosely synchronized clocks. A receiver that loses its cache, for example after a restart, SHOULD reject offers with iat before the restart until the maximum lifetime has passed, with reason "replay", since it cannot tell whether it has seen them; hops whose records survived the restart (Section 5.2) are answered as in Section 5.3, and the delegator treats "replay" as it treats "stale". Once a delegate drops a hop's records, a new offer that reuses the hop identifier passes every check; Section 5.6 forbids signing a hop twice, but such a delegate cannot detect it.¶
A delegate answers a retransmission by resending a status it already signed (Section 5.3), so anyone who can replay the offer can cause that status, with its state, reason, and refs, to be sent again, and A2A and MCP return the reply to whoever sent the request. A delegate SHOULD resend a status only when the host protocol has authenticated that party as offer.iss, for example by the credential the request carries, and otherwise SHOULD NOT.¶
A stolen delegator key lets an attacker issue offers in that delegator's name until the key is withdrawn from trust. Short lifetimes limit how long a captured offer is useful, not what a stolen key can sign. Key revocation belongs to the key distribution mechanism (Section 3.4).¶
The typ and content type values keep a signed handoff distinct from other JWS or COSE objects signed with the same key, and receivers MUST check them (Section 5.1). That protects a handoff receiver; it does not protect a verifier of some other object type that does not check a type. Separate keys for separate purposes avoid the question. The media types of Section 10 carry no active content.¶
Chains and references can be large, and loc invites fetches. Receivers MUST bound chain length and element size, and SHOULD NOT fetch loc URIs from untrusted senders without the safeguards they apply to any untrusted URL.¶
The element MUST NOT contain secrets: no access tokens, API keys, tool credentials, passwords, or private keys. Credentials appear only as digests in grant.¶
The considerations of [RFC6973] apply.¶
This document requests two media type registrations in the "Media Types" registry [RFC6838]. The first names a complete JWS signed handoff, for the typ header (Section 3). The second names the CBOR payload of a COSE signed handoff, for its content type header. No other registry is requested.¶
RFC Editor: please replace "RFC XXXX" below with the number of this document and remove this note.¶
This type labels the CBOR payload carried inside a COSE_Sign1 signed handoff (Section 3).¶
This section is to be removed before publishing as an RFC.¶
Shortened. The charter-relationship section is now one test in Section 1.2. The requirements-coverage table is a list (Section 7); the security-claims table is one paragraph at the top of Section 8. The SCITT appendix is folded into Section 2.2. The Learnlog appendix and the kind "learnlog-head" are removed; a future document can define that kind under a URI. The signed example, its keys, and the digest arithmetic are removed (the -01 text keeps them). Sections 5.3 and 5.4 say the same things in fewer words, the short security subsections are merged, and the -00 change log is gone. The references to Learnlog, JCS, and RFC 8792 went with the removed appendix and example. No rule changed.¶
Iman Schrock and Justin Kintzele worked three state-import cases against -00 with the author. Their cases found the lost-response gap that Sections 5.3 and 5.4 address, and Iman's review sharpened the conditions in Sections 4 and 5.4. This document was drafted with the help of an AI assistant and edited by the author.¶