agentproto H. Moussa Internet-Draft A. Akhavain Intended status: Informational Huawei Canada Expires: 20 May 2027 16 November 2026 Context and Correlation Management Architecture for Distributed Agentic Activities draft-agentproto-context-management-architecture-01 Abstract Agentic applications increasingly distribute objectives across autonomous agents, tools, and services operating across different protocols and administrative domains. A single Activity may involve multiple independently maintained Dialogs, Tasks, Events, and Resources, spanning different modalities and extended periods of time. Existing protocols provide identifiers and context-management mechanisms for their own interactions, but these do not necessarily support correlation across Dialogs, protocols, and administrative boundaries, particularly as interactions evolve, branch, or resume over time. This document defines a context-and-correlation architecture based on Activities, Dialogs, Tasks, Resources, and typed Relationships. It describes how management and correlation metadata can be maintained and selectively propagated to preserve coherent context across distributed interactions, while allowing participants to determine the scope of correlations they share and manage. Status of This Memo 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 20 May 2027. Moussa & Akhavain Expires 20 May 2027 [Page 1] Internet-Draft Context Management Architecture November 2026 Copyright Notice 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. Table of Contents 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 4 2. Core Architectural Principle . . . . . . . . . . . . . . . . 5 3. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 7 4. Architectural Model . . . . . . . . . . . . . . . . . . . . . 12 4.1. Architecture Visualization . . . . . . . . . . . . . . . 12 4.2. Motivating Multimedia Example . . . . . . . . . . . . . . 14 4.3. Cross-Organization Operation . . . . . . . . . . . . . . 16 5. Dialogs Within an Activity . . . . . . . . . . . . . . . . . 17 5.1. Dialog Management State . . . . . . . . . . . . . . . . . 18 5.2. Reasons for Creating a New Dialog . . . . . . . . . . . . 21 5.3. Dialog Independence . . . . . . . . . . . . . . . . . . . 22 5.4. Multi-Party Dialogs . . . . . . . . . . . . . . . . . . . 23 5.5. Dialog Lineage . . . . . . . . . . . . . . . . . . . . . 25 5.6. Hidden Delegation and Partial Visibility . . . . . . . . 26 5.7. Dialog Topologies . . . . . . . . . . . . . . . . . . . . 27 5.7.1. Branching . . . . . . . . . . . . . . . . . . . . . . 27 5.7.2. Chaining . . . . . . . . . . . . . . . . . . . . . . 28 5.7.3. Converging Dialogs . . . . . . . . . . . . . . . . . 28 5.7.4. The Dialog Graph . . . . . . . . . . . . . . . . . . 29 5.8. Independent Dialog Lifecycle . . . . . . . . . . . . . . 29 5.9. Recovery and Continuation . . . . . . . . . . . . . . . . 30 5.10. Interruptions and Barge-in . . . . . . . . . . . . . . . 34 5.11. Reuse Across Dialogs . . . . . . . . . . . . . . . . . . 37 5.12. The Running Example, Assembled . . . . . . . . . . . . . 38 6. Tasks Within a Dialog . . . . . . . . . . . . . . . . . . . . 39 6.1. Task Identity: Local and Global . . . . . . . . . . . . . 39 6.2. Task States . . . . . . . . . . . . . . . . . . . . . . . 40 6.3. Task Independence . . . . . . . . . . . . . . . . . . . . 41 6.4. Task Relationships Across Dialogs . . . . . . . . . . . . 42 6.5. Task Topologies . . . . . . . . . . . . . . . . . . . . . 42 6.6. Impact of Dialog Failures on Task Relationships . . . . . 43 6.7. Task Privacy Considerations . . . . . . . . . . . . . . . 44 Moussa & Akhavain Expires 20 May 2027 [Page 2] Internet-Draft Context Management Architecture November 2026 6.8. Events Within Tasks . . . . . . . . . . . . . . . . . . . 44 7. Binding to Protocol-Local Context . . . . . . . . . . . . . . 45 8. Context Management and Correlation Metadata Propagation . . . 46 8.1. Correlation Scope, Extension, and Maintenance Responsibilities . . . . . . . . . . . . . . . . . . . . 47 8.1.1. Logical and Managed Correlation Scope . . . . . . . . 48 8.1.2. Selective Extension and Boundary Bridging (Scope Leakage) . . . . . . . . . . . . . . . . . . . . . . 49 8.1.3. Maintenance Responsibilities Within the Established Scope . . . . . . . . . . . . . . . . . . . . . . . . 50 8.1.4. Failure Visibility and Bounded Accountability . . . . 51 8.2. The Propagation Model . . . . . . . . . . . . . . . . . . 52 8.3. What Is Propagated . . . . . . . . . . . . . . . . . . . 54 8.3.1. Activity Correlation . . . . . . . . . . . . . . . . 54 8.3.2. Dialog Lineage . . . . . . . . . . . . . . . . . . . 55 8.3.3. Task Lineage . . . . . . . . . . . . . . . . . . . . 55 8.3.4. Resource Identity . . . . . . . . . . . . . . . . . . 56 8.3.5. Propagation Summary . . . . . . . . . . . . . . . . . 58 8.4. Propagation Is Not Transitive by Default . . . . . . . . 58 8.5. Context Projection . . . . . . . . . . . . . . . . . . . 60 8.6. Identifier Translation . . . . . . . . . . . . . . . . . 61 8.7. Directional Propagation . . . . . . . . . . . . . . . . . 62 8.7.1. Downstream propagation . . . . . . . . . . . . . . . 62 8.7.2. Upstream propagation . . . . . . . . . . . . . . . . 62 8.8. Propagation of Assertions . . . . . . . . . . . . . . . . 62 8.8.1. Lifecycle-Affecting Requests and Consequences . . . . 63 8.9. Context Freshness and Lifetime . . . . . . . . . . . . . 64 8.10. Propagation Revocation . . . . . . . . . . . . . . . . . 65 8.11. Partial Visibility . . . . . . . . . . . . . . . . . . . 65 8.12. Propagation Failure Modes . . . . . . . . . . . . . . . . 66 8.12.1. Loss of Correlation . . . . . . . . . . . . . . . . 67 8.12.2. Incorrect Correlation . . . . . . . . . . . . . . . 67 8.12.3. Over-Propagation . . . . . . . . . . . . . . . . . . 67 8.12.4. Stale Context . . . . . . . . . . . . . . . . . . . 68 8.12.5. Semantic Drift . . . . . . . . . . . . . . . . . . . 69 8.12.6. Broken Lineage . . . . . . . . . . . . . . . . . . . 69 8.12.7. Excessive Lineage Propagation . . . . . . . . . . . 70 8.12.8. Inconsistent Local Mapping . . . . . . . . . . . . . 70 8.12.9. Partial Propagation Failure . . . . . . . . . . . . 70 8.12.10. Architectural Implication . . . . . . . . . . . . . 71 8.13. Propagation Example . . . . . . . . . . . . . . . . . . . 71 8.14. Relationship Taxonomy . . . . . . . . . . . . . . . . . . 72 8.15. Privacy and Administrative Boundaries . . . . . . . . . . 75 8.16. Relationship to Dialog-Management Protocols . . . . . . . 75 8.16.1. Functional Placement of Dialog Management . . . . . 76 8.16.2. Architectural vs. Protocol Surface . . . . . . . . . 77 8.17. Relationship to A2A . . . . . . . . . . . . . . . . . . . 77 8.18. Relationship to MCP and Tool Protocols . . . . . . . . . 78 Moussa & Akhavain Expires 20 May 2027 [Page 3] Internet-Draft Context Management Architecture November 2026 8.19. Relationship to Distributed Tracing . . . . . . . . . . . 78 8.20. Relationship to vCon . . . . . . . . . . . . . . . . . . 79 8.21. Architectural Considerations for Protocol Design . . . . 79 8.22. Out-of-Scope . . . . . . . . . . . . . . . . . . . . . . 80 8.23. Open Questions . . . . . . . . . . . . . . . . . . . . . 80 8.24. IANA Considerations . . . . . . . . . . . . . . . . . . . 81 8.25. Security Considerations . . . . . . . . . . . . . . . . . 81 8.26. Privacy Considerations . . . . . . . . . . . . . . . . . 82 8.27. Appendix A. Canonical Architecture . . . . . . . . . . . 83 Contributors . . . . . . . . . . . . . . . . . . . . . . . . . . 83 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 84 1. Introduction Distributed agentic systems are increasingly composed of multiple independently operated participants. A single Activity can involve: * Invocation by users, agents, or other invoking systems; * One agent delegating work to another; * Several independent agent-to-agent Dialogs; * Agent-to-tool interactions; * Resources produced in one branch and consumed in another; * Downstream delegation hidden from upstream participants; * Modality transformations, such as video to audio to text; * Multiple vendors and administrative domains; * Local protocol constructs that do not share identifiers or state; and * Operation over different transport protocols. Multiple Activities may proceed concurrently within the same distributed agentic system. Within each Activity, work may extend across independently maintained Dialogs, with participants having visibility into only parts of the overall interaction. This raises a practical challenge: as work is delegated, results are reused, or interactions resume after interruptions, how can the relevant Dialogs, Tasks, and Resources remain correctly associated? Moussa & Akhavain Expires 20 May 2027 [Page 4] Internet-Draft Context Management Architecture November 2026 Existing protocols provide their own context-management mechanisms and identifiers, but these alone do not establish interoperable correlations across independently maintained interactions. This document introduces an information model for representing these correlations and examines how they can be maintained and selectively shared. An Activity may extend beyond the correlations managed through a dialog-management protocol, while those that undertake to maintain established correlations are responsible for preserving their coherence as interactions evolve. The remainder of this document is organized as follows. Section 2 states the core architectural principle, and Section 3 defines terminology. Section 4 introduces the architectural model and illustrates it through motivating examples that cross organizational boundaries. Section 5 examines how independently maintained Dialogs coexist within one Activity, and Section 6 addresses Tasks within a Dialog. Section 7 describes binding to protocol-local context. Section 8 develops correlation metadata propagation, including scope and maintenance responsibilities, the propagation model, what is propagated, context projection, identifier translation, freshness, revocation, partial visibility, failure modes, related protocols, architectural considerations, out-of-scope items, and open questions. This document distinguishes settled architectural principles from open design questions. The open questions are deliberate: they identify the decision space reserved for the dialog-management protocol and for coordination with related work. They are candidates for resolution in subsequent protocol documents, not gaps in the architecture. 2. Core Architectural Principle The architecture rests on a single central principle: Identify the objects and relationships needed to keep independently maintained Dialogs, Tasks, and Resources correlated across protocol and administrative boundaries. Define their correlation semantics without replacing protocol-local mechanisms, and distinguish relationships maintained locally from information that needs to be propagated for interoperability. Moussa & Akhavain Expires 20 May 2027 [Page 5] Internet-Draft Context Management Architecture November 2026 The architecture distinguishes application content from the management and correlation metadata associated with it. Application protocols carry the interactions and content that may contribute to an agent's conversational or LLM context, while dialog-management functions maintain and exchange the metadata needed to preserve coherent context across independently maintained Dialogs, Tasks, and Resources within an Activity. The model uses five primary objects: Activity Dialog Task Resource Relationship The model also introduces Dialog Management State (DMS), a management-state abstraction associated with each logical Dialog. DMS maintains the Dialog's management information and relevant correlations with other architectural objects. The model also identifies four Activity-relative participant roles: Activity Initiating Entity (AIE) First Next Entity (FNE) Assistant Agent (AA) Assistant Tool (AT) Roles are relative to the invocation chain: the AIE initiates an Activity, its directly invoked entity is the FNE, and entities invoked downstream are Assistant Agents or Assistant Tools. Terminology follows below. The participant roles defined in this architecture refer to logical entities within an interaction wave, rather than prescribing their internal implementation. An AIE, FNE, or Assistant Entity may comprise multiple underlying participants. Such an entity may appear externally as a single Dialog endpoint, while its internal coordination and interactions remain hidden. Alternatively, constituent participants may be visible through separate Dialogs whose relationships are explicitly established. The architectural roles describe how entities participate in an interaction wave, independently of their internal organization. Moussa & Akhavain Expires 20 May 2027 [Page 6] Internet-Draft Context Management Architecture November 2026 This information model complements protocol-local context management mechanisms. A dialog-management protocol may use the model's semantics and convey relevant Correlation Metadata through bindings to existing protocols; this architecture does not define those bindings. 3. Terminology * Activity: is the root of an interaction wave, initiated by one logical Activity Initiating Entity (AIE) to pursue an objective and reach an outcome. An Activity is initiated when the AIE invokes one logical First Next Entity (FNE), establishing the Activity's initial Dialog. It groups the Dialogs and their Tasks, together with the Resources involved, for correlation purposes. This grouping does not imply a shared conversational context or a shared participant set. An AIE may initiate multiple Activities, and an Activity can involve multiple tools and protocols. - Examples: Analyze video V1 Plan a trip Investigate a network fault Prepare a financial report * Dialog: is a logical container established among a set of two or more participants that share a conversational context. It belongs to exactly one Activity, and is created to pursue an objective that contributes to that Activity. The Dialog may contain zero or more Tasks, each pursuing a part of the Dialog's objective. A Dialog is related to its Activity and to other Dialogs, Tasks, and Resources of that Activity through correlation metadata. The metadata also records the Dialog's lifecycle state. A Dialog is frequently pairwise, but may involve more than two participants. The same set of participants may maintain several concurrent Dialogs, within the same Activity or across different Activities. Each Dialog is identified by its own identity, not by its participant set. Every Dialog has its own objective, conversational context, and lifecycle state. Its associated DMS persists logically as its participant set changes. Moussa & Akhavain Expires 20 May 2027 [Page 7] Internet-Draft Context Management Architecture November 2026 * Dialog Management State (DMS): The logical management state associated with a Dialog, comprising its metadata such as identity, lifecycle state, applicable participant-membership information, and Correlation Metadata established within the Dialog's managed scope. Each Dialog is associated with one logical DMS, which may have multiple distributed representations maintained by its participants. These representations need not be identical. * Task: is a bounded unit of work within a Dialog, created to pursue an objective that contributes to the Dialog's objective. A Task progresses through one or more Events, which advance that objective. A Task has its own lifecycle state. A Task groups related Events under a common objective, allowing distinct strands of work within the same Dialog to be identified separately. Example: as part of the Activity "plan a trip", Agent A and Agent B work together to generate a shortlist of suitable hotels in a city within the trip's destination. Generating that shortlist is the objective of the Dialog between Agent A and Agent B. Within that Dialog, retrieving and evaluating each hotel is a bounded unit of work, that is, a Task. Within each Task, Agent A and Agent B carry out Events - for example, request hotel X's details, clarify its breakfast arrangement, or check availability - and those Events share the Task's identifier as they progress. * Event: is a message, a job invocation, a tool call, or a similar interaction carried out by the participants as they pursue a Task's objective. An Event has no objective of its own. It is part of carrying out the Task. An Event belongs to exactly one Task and carries that Task's identifier as it progresses. Events are local to their Task and are not correlation objects. An Event may carry or reference content in one or more modalities, including text, audio, images, and video. Events within the same Task or Dialog may use different modalities, concurrently or over time. A change in modality does not, by itself, require establishing a new Task or Dialog. Moussa & Akhavain Expires 20 May 2027 [Page 8] Internet-Draft Context Management Architecture November 2026 * Resource: is an identifiable object that participants consume, produce, refer to, or transform during an Activity, such as video, audio, text, documents, transcripts, tool outputs, and agent- produced artifacts. The same Resource can be used in more than one Activity. Each Activity may refer to it differently, and so may its Dialogs, Tasks, and Events. The architecture does not prescribe a particular method of referencing Resources. Inside an Activity, any Dialog, Task, or Event can refer to the Resource, and the same Resource can be referred to by several of them simultaneously. Resources can also be physically carried within Events. * Relationship: is a typed, directional association among Activities, Dialogs, Tasks, or Resources. A relationship expresses an association between its endpoints. Relationship types express the meaning of those associations. Relationship types are Correlation Metadata. A relationship may exist and be retained without its type being disclosed (disclosure of relationship types is a decision for the endpoints to make). The relationship types presented below are illustrative. The companion dialog-management protocol specification will determine which relationship types require standardized semantics and interoperable representation or exchange. Examples include: belongs-to delegated-from derived-from input-to output-of * Upstream and Downstream: are directional terms relative to a given Dialog. Upstream refers to Dialogs from which work was delegated, in the direction of the Activity Initiating Entity (AIE). Downstream refers to Dialogs created by delegating work, in the direction away from the AIE. Delegation proceeds downstream. Results, status, and correlation updates proceed upstream. * Context: in this document, refers to the set of relationships (correlations) among Activities, Dialogs, Tasks, and Resources, and to the Correlation Metadata that describes them. Context does not refer to the internal state maintained by an AI agent (sometimes called a "context window"). Agent-internal memory and its content is out of scope. Implementations maintain the protocol state needed for correlation, such as Dialog identities, asserted relationships, and protocol-managed correlation scopes for which they accepted maintenance responsibilities, independently of agent-internal memory or prompt context. This architecture does not prescribe how that state is stored or Moussa & Akhavain Expires 20 May 2027 [Page 9] Internet-Draft Context Management Architecture November 2026 deployed, whether in a library, sidecar, service, or equivalent form. Context as defined here is also distinct from the application conversation and Event content associated with a Dialog. The following should also be noted: Context, as defined in this document, represents an architectural correlation model and is broader than the Dialog context defined in the agentproto charter. The inclusion of an object or relationship in this model does not imply that it must be standardized or exchanged by the dialog- management protocol. A Dialog's DMS represents its own management state and selected shared correlations, not this broader architectural Context. * Correlation Metadata: is the information that participants may exchange to keep independently maintained Activities, Dialogs, Tasks, and Resources correlated and to enable the establishment of a coherent context. Correlation metadata consists of different kinds of assertions, examples include: relationships, such as "D2 delegated-from D1" or "T1 derived-from V1", and lifecycle state, such as "D5 revoked". It does not include Resource content or an agent's internal state or memory. * Protocol-Local Context: is the context establishment mechanism defined by the application protocol used within a Dialog. For example, an A2A contextId or taskId, etc are a Protocol-Local Context. * Dialog Management: The correlation and lifecycle management of an Activity's Dialogs and Tasks, including the correlation of the Resources they use and the Activity that groups them. Although named after the Dialog as the fundamental unit of interaction, Dialog Management is not limited to Dialogs. A dialog-management protocol supports these functions and enables participants to exchange the information needed to maintain these correlations. The protocol may represent and exchange the appropriate parts of a Dialog's DMS without replacing application-protocol state. * Resource Binding: describes a Resource's use or interpretation within an Activity, Dialog, or Task. * Interaction Wave: is the dynamically expanding set of Dialogs, Tasks, and Resources within an Activity as work is delegated and executed across participants. It is rooted at the AIE and begins with the initial Dialog between the AIE and the FNE invoked for that Activity. Subsequent invocations within the Activity extend the wave through additional Dialogs. Moussa & Akhavain Expires 20 May 2027 [Page 10] Internet-Draft Context Management Architecture November 2026 * Activity Initiating Entity (AIE): is the entity that starts an Activity and forms the root of the corresponding interaction wave. The AIE is the originator of the Activity. An AIE can be a user, an agent, or an invoking system. A tool cannot be an AIE. * First Next Entity (FNE): A logical entity directly invoked by an Activity Initiating Entity (AIE) to pursue the objective of a newly initiated Activity. Each logical AIE-to-FNE invocation establishes a distinct Activity and its initial Dialog. An AIE may initiate multiple Activities by invoking the same or different FNEs. The FNE may be an application, agent, or tool. Its designation reflects its role in the Activity rather than its entity type or internal implementation. The FNE serves as the logical entry point for an Activity, through which the overall Activity objective and applicable policies or configuration may be conveyed. This role does not prescribe how the FNE internally processes, manages, or delegates the handling of such information. An FNE may invoke Assistant Entities through additional Dialogs within the Activity. However, an FNE acting as a tool is a terminal logical endpoint and does not establish downstream Dialogs within that Activity. This does not restrict its internal implementation. * Assistant Entity: An entity invoked by an FNE or another Assistant Entity as part of an Activity. The invoking entity and the Assistant Entity interact through a Dialog associated with that Activity. An Assistant Entity may be an Assistant Agent (AA) or an Assistant Tool (AT). In this architecture, an application serving as an Activity entry point occupies the FNE role rather than an Assistant Entity role. This classification describes its role in the interaction wave and does not constrain its software implementation. * Assistant Agent (AA): An Assistant Entity that is an AI agent. An AA interacts with its invoking entity through a Dialog and may invoke other Assistant Entities (AAs or ATs) to assist in completing Tasks assigned to it within the Activity. * Assistant Tool (AT): An Assistant Entity invoked to perform a bounded Task. An AT acts as a terminal logical endpoint within the Activity's interaction wave and does not establish downstream Dialogs within that Activity. Its internal implementation may involve multiple participants or interactions, which are not exposed as downstream Dialogs of the Activity. An AT may complete its Task through a single request-response exchange, but this architecture does not require a particular execution pattern. Moussa & Akhavain Expires 20 May 2027 [Page 11] Internet-Draft Context Management Architecture November 2026 * Invocation: is the logical act of an entity initiating an interaction with another entity to pursue an objective. An AIE- to-FNE invocation establishes an Activity and its initial logical Dialog. Where either entity comprises multiple participants, several underlying interactions or Dialogs may be associated with that invocation without constituting separate Activity initiations. Downstream invocations establish additional Dialogs within the Activity. 4. Architectural Model 4.1. Architecture Visualization An Activity begins when an Activity Initiating Entity (AIE) invokes one First Next Entity (FNE) to pursue its objective. The invocation establishes the Activity and its initial Dialog between the AIE and the FNE: Activity +-----------------------------------+ | | | +-----+ Dialog D1 +-----+ | | | AIE |<-------+------->| FNE | | | +-----+ | +-----+ | | | | | DMS(D1) | +-----------------------------------+ If the goal of the Activity can be fulfilled by the FNE itself, no additional entities are invoked for that Activity. Alternatively, if assistance from additional entities is required, the FNE, or any downstream assistant entity, may invoke assistant entities. Dialogs are created between the invoking entity and each invoked assistant entity, and the respective Tasks are handled within their associated dialogs, all under the umbrella of the Activity, and the interaction wave propagates. Dialogs created in this way belong to the Activity but might not directly involve the AIE; each is related to the Dialog that created it through lineage relationships (see "Dialog Lineage"). The interaction wave may then look like the following: Moussa & Akhavain Expires 20 May 2027 [Page 12] Internet-Draft Context Management Architecture November 2026 Activity +------------------------------------------------------------------+ | | | +-----+ Dialog +-----+ Dialog +-----+ Dialog +-----+ | | | AIE |<---------->| FNE |<---------->| AA1 |<---------->| AA3 | | | +-----+ task(s) +-----+ task(s) +-----+ task(s) +-----+ | | + + | | Dialog | Dialog | | | | task(s) | task(s) | | v v | | +-----+ +-----+ | | | AT1 | | AT2 | | | +-----+ +-----+ | | | +------------------------------------------------------------------+ An Activity groups multiple independently maintained Dialogs, each of which may contain Tasks: Conceptually, the model looks like the following. Each Dialog has its own logically associated DMS; the DMS maintains management state and selected shared correlations rather than containing the Tasks, Events, or Resources themselves: Activity | +-----------+-----------+ | | Dialog D1 Dialog D2 | | | | | +-- DMS(D1) | +-- DMS(D2) | | Tasks Tasks (Events) (Events) | | +-----------+-----------+ | +-------------------+ | Resource Layer | +-------------------+ Moussa & Akhavain Expires 20 May 2027 [Page 13] Internet-Draft Context Management Architecture November 2026 The figure above introduces the Resource Layer, a logical view of the Resources associated with an Activity. It allows Dialogs and Tasks to refer to the same Resource, including multimedia content that is consumed, produced, or transformed across different Dialogs. A Resource may be carried in an application exchange or accessed separately by reference. The Resource Layer does not prescribe a storage service, content-transfer protocol, or globally visible repository. Cross-Dialog lineage and shared Resource use are the architectural focus. The interaction graph need not be globally stored or visible; participants may retain only the correlations their operations require. Neither the Activity nor the Resource Layer implies an Activity-wide DMS, a shared repository for every Dialog, or disclosure of the full correlation graph. An authorized view of an Activity may be assembled from several Dialogs' DMS representations and locally maintained correlations, without introducing a separate Activity-wide state object. 4.2. Motivating Multimedia Example Consider a user requesting an analysis of video V1. The user acts as the Activity Initiating Entity (AIE) and invokes Agent A, the First Next Entity (FNE), establishing an Activity with the objective "analyze video V1" and its initial Dialog, D1. A Task within D1 pursues the requested analysis, with V1 serving as an initial Resource. Agent A determines that the analysis requires two capabilities: processing the visual content and transcribing the audio into text. Agent A therefore invokes Agent B, an Assistant Agent (AA) capable of analyzing video and text, and Tool X, an Assistant Tool (AT) responsible for audio transcription. These invocations establish two additional Dialogs within the Activity: D2 between Agent A and Agent B, and D3 between Agent A and Tool X. Within D2, Agent A provides V1 to Agent B and assigns the video- analysis Task. Within D3, Tool X receives a reference to V1, accesses the video through an authorized Resource-access mechanism, and produces transcript T1. Agent A subsequently provides T1 to Agent B within D2, where it is analyzed alongside the video. The participant roles are: User AIE Agent A FNE Agent B AA (invoked by Agent A) Tool X AT (invoked by Agent A) Moussa & Akhavain Expires 20 May 2027 [Page 14] Internet-Draft Context Management Architecture November 2026 These roles follow the invocation chain rather than the nature of the entity. For example, if the user directly invoked Tool X to transcribe V1, Tool X would be the FNE of that Activity rather than an AT. The scenario is depicted below: User (AIE) | | Dialog D1: | (Activity, V1) v Agent A (FNE) +-----------+-----------+ | | Dialog D2: | | Dialog D3: (V1, Tasks) | | (Task, V1 ref.) v v Agent B (AA) Tool X (AT) video analysis audio transcription ^ | | v | T1 | | (back to agent A) | | | | +------ Dialog D2 ----Agent A (FNE) (T1 provided to Agent B) The example illustrates two cross-Dialog Resource patterns: V1 is consumed in both D2 and D3, while T1 is produced in D3 and subsequently consumed in D2. Resources may be transferred through application protocols, as with V1 in D2, or accessed through references, as with V1 in D3. The Resource Layer provides a logical model for identifying and relating these Resources across Dialogs, independently of how they are physically stored or accessed. Retained Event content or records of application exchanges may also be represented as Resources and referenced later, including during context recovery. For Agent B to interpret T1 correctly, its application runtime needs to associate the transcript with V1 and the work being performed within the Activity. This becomes particularly important when Agent B is concurrently processing similar videos across different Activities. The relevant correlations include: Moussa & Akhavain Expires 20 May 2027 [Page 15] Internet-Draft Context Management Architecture November 2026 D2 delegated-from D1 D3 delegated-from D1 T1 derived-from V1 In this example, the application runtimes invoke DCMP through their local interfaces to establish and maintain these correlations as part of the Dialog-management state. DCMP exchanges the relevant management and correlation metadata among authorized endpoints, while the application protocols carry the video, transcript, and other application content. The runtime associated with Agent B can use the available correlation metadata and Resources to assemble the context supplied to Agent B. Protocol-local identifiers, such as an A2A contextId or a tool- specific request identifier, remain useful within their respective application interactions. However, these identifiers alone do not establish the cross-Dialog relationships or Resource provenance illustrated above. DCMP provides a common means of representing and maintaining these correlations across independently managed Dialogs, protocols, and administrative domains. 4.3. Cross-Organization Operation The example of the previous section becomes architecturally more interesting when its participants are operated by different organizations: User (AIE) invokes Agent A (Organization 1) Agent A (FNE) Organization 1 Agent B (AA) Organization 2 Tool X (AT) Organization 3 Dialog D2, between Agent A and Agent B, and Dialog D3, between Agent A and Tool X, cross organizational boundaries, while Dialog D1 involves only the user and Organization 1. Each organization maintains its own local identifiers for the portions of the Activity it can see as shown below: Organization 1: activity_id = O1-17 Organization 2: A2A context = AB-92 A2A task = TB-44 Organization 3: tool job = JOB-991 Moussa & Akhavain Expires 20 May 2027 [Page 16] Internet-Draft Context Management Architecture November 2026 In architectural terms, O1-17 is Organization 1's local handle for the Activity, AB-92 is the Protocol-Local Context of Dialog D2, TB-44 is a protocol-local Task identifier within D2, and JOB-991 is Tool X's local identifier for the transcription Task in D3. These local identifiers need not be globally shared, unique, or even syntactically alike. Correlation must therefore work without replacing or exposing protocol-local state. The architecture separates: logical correlation from: local identifier representation A domain may maintain private mappings between the two. The Resource Layer is logical, not administrative: V1 may be stored by Organization 1 and accessed by Tool X subject to that organization's access and privacy policies. 5. Dialogs Within an Activity As described in the Architectural Model, a single Activity can involve multiple Dialogs. An Activity does not imply a common conversational context, participant set, protocol instance, or lifecycle for its Dialogs. In other words: An Activity groups multiple independently maintained Dialogs for correlation purposes. Dialogs in different branches may have explicit relationships without direct communication or shared conversation. Common Activity membership alone does not imply a relationship. An AIE may initiate multiple Activities to pursue a broader objective. The AIE may preserve associations between those Activities locally and coordinate their results or Resources across Activity boundaries. Consequently, Dialogs belonging to different Activities may be correlated indirectly through the AIE, without requiring a direct Dialog-to-Dialog relationship or disclosure of the other Activity to its participants. Having the same AIE does not, by itself, imply that those Activities are related. Moussa & Akhavain Expires 20 May 2027 [Page 17] Internet-Draft Context Management Architecture November 2026 This distinction supports delegation, specialization, cross-domain work, and recovery without collapsing independent interactions into one Dialog. The motivating example illustrates this property: Dialogs D1, D2, and D3 are established by separate invocations, are maintained independently, and may use different application protocols, yet all belong to the same Activity. Multiple participants may jointly constitute an AIE when pursuing a common objective with a shared fulfillment condition. Conversely, independently initiated requests with distinct fulfillment conditions constitute separate Activities, even when they involve the same FNE, reuse the same Resources, or share downstream work. The completion of one Activity does not imply the completion of another. It is worth re-iterating that a dialog here refers to the application level interaction as well as the correllation level interaction via the Dialog Context Management Protocol that feeds the logical Dialog Management State (DMS) assocaited with the dialog. 5.1. Dialog Management State Each Dialog is associated with one logical instance of Dialog Management State (DMS). DMS comprises two main elements: * Management Metadata: Information associated with the management of the Dialog, including its identity, lifecycle state, participant information, and relevant management-operation metadata. * Correlation Metadata: Information describing the Dialog's relationships with its Activity, other Dialogs, Tasks, and Resources. The following illustrates the structure of DMS: text Dialog D1 | DMS(D1) | +----------+----------+ | | Management Metadata Correlation Metadata For example, the DMS associated with Dialog D1 may contain the following information: ```yaml DMS(D1): management: dialog_id: D1 lifecycle: ACTIVE Moussa & Akhavain Expires 20 May 2027 [Page 18] Internet-Draft Context Management Architecture November 2026 participants: - id: AgentA - id: AgentB - id: AgentC authentication: method: method-X verification_ref: authn-12345 admission: authorized_by: AgentA decision_ref: authz-67890 correlations: - D1 belongs-to A1 - D2 delegated-from D1 optional_references: tasks: - task_id: T1 event_ids: [E1, E2] - task_id: T2 resources: [R1] protocol_local_context: local-ctx-17 ``` Note: This representation is illustrative and does not prescribe a wire format or a mandatory set of fields. In addition to Dialog identity and lifecycle information, DMS may contain participant information, selected correlations, and references to Tasks, Events, Resources, or protocol-local identifiers. These references identify the corresponding objects without carrying their content. The inclusion of such information depends on the correlations established for management and the applicable disclosure policies. The management metadata may also include information associated with authentication and authorization. For example, when Agent C joins D1, its admission may involve authentication through an existing security mechanism and authorization by an entity with the appropriate authority. DMS may retain the authentication method, a reference to the verification process, and the corresponding authorization decision. Similarly, a lifecycle change may be associated with the identity of the participant that authorized it and a reference to the relevant authorization decision. Such information provides a record of the management operation without incorporating credentials or the underlying security exchanges into DMS. The dialog-context-management-protocol (DCMP) propagates the exchanges needed to establish and maintain DMS. A successful operation may change Dialog lifecycle state, participant membership, or managed correlations. Requests, acknowledgments, rejections, and authentication or authorization-related exchanges may also be needed, but do not necessarily modify DMS. The protocol records or communicates the relevant management outcome; it does not perform the application's work to enforce those management decisions. For Moussa & Akhavain Expires 20 May 2027 [Page 19] Internet-Draft Context Management Architecture November 2026 example, a terminiation of a task is reflected as a task status and lifecycle change in the DMS. However, that does not mean that the agent handling the task has stopped working on that task. For example, consider D1, initially established between Agents A and B. During the interaction, a relationship with D2 is established, Agent C joins after successful admission, Agent B leaves, and D1 is eventually suspended: Establish D1 Participants: A, B Lifecycle: ACTIVE | v Establish correlation D2 delegated-from D1 | v Authenticate and authorize Agent C Agent C joins D1 Participants: A, B, C | v Agent B leaves D1 Participants: A, C | v Authorized lifecycle update D1 becomes SUSPENDED Throughout these changes, D1 retains its identity and associated logical DMS. The protocol carries the exchanges needed to modify DMS, while DMS reflects the resulting management and correlation state. Implementations may maintain the current state, a history of management changes, or both. A DMS may have multiple distributed representations maintained by participating entities. These representations need not be identical, as correlation information and certain management metadata may be selectively disclosed. Correlations maintained privately by a participant do not automatically become part of the Dialog's shared DMS. DMS does not contain application message content, Resource content, or agent-internal memory. However, it may maintain identifiers and references to Tasks, Events, and Resources associated with the Dialog, allowing relevant portions of its interaction history to be identified. Where the corresponding content or interaction records Moussa & Akhavain Expires 20 May 2027 [Page 20] Internet-Draft Context Management Architecture November 2026 are retained as Resources in the Resource Layer, these references may support their subsequent retrieval, subject to applicable access controls. Application protocols carry the interactions and content used to accomplish the Dialog's objective. Local bindings associate relevant application identifiers and state with the Dialog and its DMS; these bindings need not be stored in DMS or exchanged with other participants. The companion dialog-management protocol specifies the applicable information elements, operations, and mechanisms for maintaining and recovering DMS across participants. Note: In the rest of the document, saying Agent X or participant Y sees this aspect about the dialog context, we refer to the DMS instance associated with the logical dialog that participant is part of. 5.2. Reasons for Creating a New Dialog New Dialogs routinely arise as an interaction wave expands through delegation, specialization, tools, or recovery. For example: * Delegation: An agent may delegate part of its work to another agent. * Specialization: A participant may invoke a specialist because the current participants lack a required capability. For example, if Agent B cannot understand language L, it invokes an agent capable of language L and creates a new Dialog with it. * Tool invocation: Invoking a tool establishes a Dialog with a terminal logical endpoint in the Activity's interaction wave. * Administrative Separation: A new Dialog may be created when execution crosses into another organization, vendor, security domain, or policy boundary. * Failure Recovery: A replacement Dialog may be created after the failure of a participant, route to a participant, the transport, or an intermediary entity. For example, if Agent B fails mid- Activity, a replacement Agent B' is started and opens a new Dialog with Agent A to continue from where they stopped. Moussa & Akhavain Expires 20 May 2027 [Page 21] Internet-Draft Context Management Architecture November 2026 * Privacy Separation: A participant may intentionally create a separate Dialog so that only a subset of Activity information is visible to the downstream participant. The same two participants may even run multiple Dialogs in parallel under the same Activity, each exposing a different subset of Activity information. The motivating example already exhibits several of these reasons: D2 arises from delegating video analysis to a specialist, D3 from tool invocation, and both Dialogs cross administrative boundaries. Applications decide when to establish Dialogs. The architectural concern is correlating each Dialog with its Activity and relevant lineage, where needed to capture causality. 5.3. Dialog Independence Each Dialog is independently maintained, with its own logical DMS. A shared Activity or participant set does not merge those states. In the motivating example, D2 and D3 both belong to the same Activity: Activity: analyze video V1 D2: Agent A <-> Agent B D3: Agent A <-> Tool X D2 and D3 may differ in: * Participants: Agent B versus Tool X; * Protocol (e.g., HTTP vs MoQ) and transport (e.g., TCP vs UDP); * Protocol-local identifiers: A2A context AB-92 and Task TB-44 in D2, tool job JOB-991 in D3; * Resources referenced: V1 and T1 in D2, but V1 by reference in D3; * Message history; * Lifecycle state: D2 is long-running, D3 is one-shot; * Privacy policy and authorization level; * Administrative domain: Organization 2 versus Organization 3. Moussa & Akhavain Expires 20 May 2027 [Page 22] Internet-Draft Context Management Architecture November 2026 Therefore: D2 != D3 even though both belong to the same Activity. Dialog independence extends to the same pair of participants. Two entities may maintain multiple concurrent Dialogs with each other: one per Activity on which they both work, or several within a single Activity when privacy or task separation calls for it. Suppose that, alongside D2, Agent A opens a clarification dialog with Agent B: Activity: analyze video V1 D2: Agent A <-> Agent B (video-analysis Tasks) D4: Agent A <-> Agent B (clarification dialog) Although D2 and D4 share participants, they have distinct local states and potentially different disclosures: D2 != D4 A Dialog is identified by its own identity and the Activity it belongs to, never by its participant set. A participant MUST NOT assume that another Dialog participating in the same Activity shares the same local state, and MUST NOT assume that its Dialog with a given counterpart is the only one. 5.4. Multi-Party Dialogs A Dialog may involve more than two participants sharing a common logical Dialog context and lifecycle. This does not require every participant to communicate directly with every other participant or have visibility into all application exchanges. For example, Agent A, Agent B, and Agent C may participate in a single Dialog, D1, while their application runtimes exchange messages through Agent B acting as an orchestrator: Moussa & Akhavain Expires 20 May 2027 [Page 23] Internet-Draft Context Management Architecture November 2026 Logical Dialog D1 +------------------------------------+ | | | Agent A <--> Agent B <--> Agent C | | | | Participants: {A, B, C} | | DMS(D1) | +------------------------------------+ The same application communication topology may also involve two distinct pairwise Dialogs: Agent A <--> Agent B <--> Agent C D2 D5 DMS(D2) DMS(D5) In this case, D5 may have been established through delegation from D2: D5 delegated-from D2 The distinction between these arrangements lies in their logical Dialog membership and management state, rather than the underlying application communication topology. A multi-party Dialog has one logical identity and associated DMS, whereas correlated pairwise Dialogs retain separate identities, management states, and lifecycles. This distinction also affects Dialog-management authority. In the multi-party arrangement, Agent C may join D1 and be granted authority to perform certain management operations, such as terminating the Dialog, according to an agreed authority policy. In the pairwise arrangement, Agent C participates in D5 but not D2. Its participation in D5 does not confer management authority over D2, regardless of the correlation between the two Dialogs. Any such authority would require separate authorization. A multi-party Dialog's participant set may change over time: Initially: {Agent A, Agent B} Agent C joins: {Agent A, Agent B, Agent C} Agent B leaves: {Agent A, Agent C} The Dialog retains its identity and associated logical DMS as participants join or leave. Each participant's Dialog-Management Protocol Endpoint may maintain an authorized local representation of that DMS, and these representations need not be identical. Admission Moussa & Akhavain Expires 20 May 2027 [Page 24] Internet-Draft Context Management Architecture November 2026 of a new participant may involve authentication and authorization, followed by propagation of the management and correlation metadata that the participant is authorized to access. Management authority may be assigned to the Dialog Originator or shared among authorized participants according to an agreed policy. Such authority may be scoped to particular operations and updated during the Dialog's lifetime. The DMS reflects applicable membership, lifecycle, and authorization information, while DCMP Endpoints process management operations according to the established authority policy. The application runtimes invoke these operations through local interfaces; their effects on application Task execution remain application-specific. A departing participant no longer receives future DMS updates by virtue of its former membership. Membership changes do not, by themselves, alter the Dialog's identity or invalidate its existing correlations, although associated permissions and correlation- maintenance responsibilities may need to be updated. This architecture supports both multi-party Dialogs and multiple correlated pairwise Dialogs without prescribing their underlying application communication topology. The companion dialog-management protocol defines the relevant membership, authority, propagation, and state-maintenance procedures. 5.5. Dialog Lineage Dialogs can be related through explicit lineage. For example: D5 delegated-from D2 indicates that D5 exists because work from D2 was delegated into a new Dialog. A new Dialog may carry forward work or correlation context from a previous Dialog: D2' continuation-of D2 Here D2 and D2' have distinct logical identities. This relationship does not represent resuming D2 with its original identity. A new Dialog may instead supersede an earlier Dialog: D2' replaces D2 The two relationships describe different associations and may coexist. Their semantics are further discussed under "Recovery and Continuation". Moussa & Akhavain Expires 20 May 2027 [Page 25] Internet-Draft Context Management Architecture November 2026 This architecture distinguishes: dialog identity from: dialog relationship Two Dialogs remain independently identified even when one was created from another. 5.6. Hidden Delegation and Partial Visibility A downstream Dialog need not be disclosed upstream. Suppose Agent B invokes Agent C: Agent A <------> Agent B <------> Agent C D2 D5 <-------------> Delegation Focusing on this delegation, the resulting visibility may be: Local correlation view for Agent A: Agent B D2 Local correlation view for Agent B: Agent A Agent C D2 D5 D5 delegated-from D2 Local correlation view for Agent C: Agent B D5 In the above example, Agent A does not know that Agent C exists. Agent C does not know that Agent A exists. In other words, the visibility level is a decision that participants make. Such hidden delegation is common across organizational, vendor, trust, and privacy boundaries. The architecture separates: relationship exists from: Moussa & Akhavain Expires 20 May 2027 [Page 26] Internet-Draft Context Management Architecture November 2026 relationship is disclosed A relationship can be retained locally by an intermediary without being propagated in full. For example, agents inside an organization need to know only that edge agent Y can help achieve objective X. Agent Y connects to agent Z in another organization; agent Z needs to know only that agent Y exists and is asking for V, not who asked Y. Yet agent Y must know that responses from agent Z relate to requests from internal agents. 5.7. Dialog Topologies An Activity's Dialogs may branch, chain, and converge. A participant may independently invoke another entity, so Activity topology may emerge from decentralized decisions. The following scenarios are a few possible examples of how topologies of an Activity may extend. 5.7.1. Branching A participant in a Dialog can create several downstream Dialogs with other new participants as need arises. Agent B may invoke both Agent C and Agent E to pursue independent parts of its work: Activity A1 | D1 | v D2, D4 Agent A <------> Agent B | /\ D3 | D5 / \ D6 v / \ Tool Y v v Agent C Agent E with the relationships: D5 delegated-from D2 D6 delegated-from D2 D5 and D6 are independent: they may execute concurrently, use different protocols, process different Resources, terminate independently, and expose different subsets of upstream context. Agent C and Agent E do not need to know of each other's existence. Moussa & Akhavain Expires 20 May 2027 [Page 27] Internet-Draft Context Management Architecture November 2026 5.7.2. Chaining A downstream participant can itself create further Dialogs. If Agent C invokes Agent E, the Activity gains another level: Activity A1 | D1 | v D2, D4 Agent A <------> Agent B | /\ D3 | D5 / \ D6 v / \ Tool Y v v Agent C Agent E ^ ^ | D7 | +--------+ yielding: D5 delegated-from D2 D7 delegated-from D5 The Activity therefore forms a delegation tree or, more generally, a graph. No participant is required to maintain the complete ancestry: Agent C may know that D5 has an opaque upstream origin without knowing the identity of Agent A or of D2. 5.7.3. Converging Dialogs Separate branches can later contribute to another Dialog. If Agent B invokes an aggregator, Agent F, to combine the results produced independently in D5 and D6: D2 / \ v v D5 D6 \ / \ / v D8 then D8 is correlated with more than one upstream Dialog: Moussa & Akhavain Expires 20 May 2027 [Page 28] Internet-Draft Context Management Architecture November 2026 D8 aggregated-from D5 D8 aggregated-from D6 aggregated-from indicates that D8 was created to aggregate or consume results produced independently in multiple upstream Dialogs. It is a multi-parent Dialog relationship, distinct from the single-parent delegated-from. Where only correlation is asserted and no aggregation causality is intended, the weaker related-to relationship may be used instead. 5.7.4. The Dialog Graph The set of Dialogs participating in an Activity can therefore be modeled as a directed graph: G_D = (D, R_D) where D is the set of Dialogs and R_D is the set of typed relationships among them. Examples may include: delegated-from aggregated-from continuation-of related-to replaces The graph may branch, converge, and evolve over time, and no participant is required to maintain it in full. 5.8. Independent Dialog Lifecycle Related Dialogs may hold different lifecycle states simultaneously. Each Dialog's lifecycle state is reflected in its own DMS, and a lifecycle transition in one Dialog does not, by itself, change the lifecycle state of another. The states below are illustrative; the dialog-management protocol defines the exhaustive list of lifecycle states of a Dialog. D2 ACTIVE D3 COMPLETED D5 SUSPENDED Termination of D5 does not imply termination of D2, and failure of D5 does not necessarily invalidate D2 or D3. This distinction matters for failure recovery, long-running activities, asynchronous delegation, partial completion, and retry behavior. Moussa & Akhavain Expires 20 May 2027 [Page 29] Internet-Draft Context Management Architecture November 2026 Related Dialogs can be correlated (they belong to the same Activity and may be linked through lineage) yet maintain independent lifecycle states. A transition in one Dialog does not inherently impose the same transition on another Dialog or its Tasks. However, changes in requirements, dependencies, or security and authorization conditions may have consequences for related work. Where needed, sufficient Correlation Metadata is preserved and selectively propagated to identify affected Dialogs and Tasks and associate any resulting changes with their causes. Lifecycle coupling, for example: if D2 terminates, D5 should terminate is not implied by this architecture. The actual consequences for related work depend on the applicable protocols, policies, and application requirements. This architecture concerns their correlation, not the operational transitions themselves. A suspended Dialog may be resumed, or a sub-dialog may be created as a child of it to resume partial operations, independently of other Dialogs. 5.9. Recovery and Continuation Dialogs may be long-lived, spanning extended periods of activity and inactivity, multiple transport connections, or participant restarts. A temporary loss of connectivity, failure of a participant, or expiration of an underlying protocol session does not, by itself, terminate the logical Dialog. Recovery therefore requires distinguishing continuity of the Dialog's identity and management state from continuity of its communication sessions and application work. When the existing Dialog D2 is resumed, its logical identity remains D2, even if its transport connection, protocol session, or protocol- local identifiers change: Before interruption: D2 After resumption: D2 (same logical Dialog) No continuation-of relationship between distinct Dialogs is needed in this case, because no new logical Dialog has been established. D2 retains its identity and associated logical DMS, even if local representations of that state must be recovered or synchronized. Correlations needed to maintain coherent context must remain available or be recoverable within the applicable disclosure scope. Moussa & Akhavain Expires 20 May 2027 [Page 30] Internet-Draft Context Management Architecture November 2026 Alternatively, recovery may involve establishing a new Dialog D2' with a distinct logical identity and its own DMS. D2' does not automatically inherit the management state or correlations of D2. Any relationships or metadata carried forward are established as part of the continuation or replacement process. Three situations are possible: * Continuation without replacement: D2' carries forward work or correlation context associated with D2, but does not necessarily supersede D2. D2' continuation-of D2 * Replacement without continuation: D2' supersedes D2 as a Dialog, for example when the original objective is attempted again without carrying forward D2's previous execution context. D2' replaces D2 * Continuation and replacement: D2' both carries forward work or context associated with D2 and supersedes D2 as a Dialog. D2' continuation-of D2 D2' replaces D2 continuation-of expresses that a new Dialog carries forward work associated with an earlier Dialog, including work that has not yet started. Relevant context or correlations may also be carried forward. This relationship does not, by itself, imply taking over responsibility for the earlier Dialog's overall objective. replaces expresses that a new Dialog supersedes an earlier Dialog as the primary Dialog through which the earlier Dialog's objective is pursued. The two relationships are not mutually exclusive. Neither relationship automatically triggers Task lifecycle transitions, terminates the original Dialog, or transfers all its correlations. Where only selected work is carried forward without assuming responsibility for the earlier Dialog's overall objective, continuation-of, together with relevant Task or Resource relationships, may express that narrower continuity. Historical associations remain meaningful following continuation or replacement. For example, if D3 was delegated from D2, that fact does not disappear when D2' replaces D2. If D2' also needs to correlate subsequent work with D3, the necessary associations must be preserved or established; they cannot be inferred solely from D2' replaces D2. Moussa & Akhavain Expires 20 May 2027 [Page 31] Internet-Draft Context Management Architecture November 2026 Communication recovery and correlation recovery are distinct. A transport may reconnect while a participant has lost the mappings needed to correlate D2 with related Dialogs, Tasks, or Resources. Conversely, those mappings may remain available while a participant or its transport path is unreachable. Resuming the same Dialog identity also does not, by itself, guarantee recovery of its application Task state or of the outcome of an interrupted operation. An uncertain operation outcome is not itself a correlation failure if the operation remains correctly associated with its relevant Dialog and Task. Within an established protocol-managed correlation scope, a participant remains responsible for the correlations it undertook to maintain through an interruption or recovery. Where necessary correlations cannot be preserved or recovered, that limitation must be distinguishable from successful correlation maintenance, subject to the detection and reporting capabilities of the relevant protocol. This does not imply visibility into unregistered downstream Dialogs or perfect attribution of a recovery failure. Recovery may involve several distinct layers: * Dialog-management and correlation state: preservation or re- establishment of the Dialog's DMS representation and relevant shared correlations, together with any participant-local mappings needed for cross-Dialog Task and Resource association. Restoring a DMS view does not imply recovering the full Activity Context. * Application-protocol state: the sessions, Tasks, and operation outcomes maintained by protocols such as A2A and MCP, which may continue independently of a transport connection. * Transport connectivity: re-establishment or migration of a connection or path through the underlying transport mechanisms. * Application-content recovery: retrieval of retained Event records, messages, or Resources when the application needs them to reconstruct interaction history or rehydrate its LLM context. DMS may supply useful references and provenance through local bindings, but neither DMS nor the Resource Layer guarantees that content was retained or that an agent's previous internal state can be restored. The architecture identifies these distinct concerns and their correlation implications, without specifying recovery procedures. Open protocol-design questions include how lost mappings are recovered or rebuilt, how peers distinguish resumption from new Dialog creation, how correlation is handled when an intermediary Moussa & Akhavain Expires 20 May 2027 [Page 32] Internet-Draft Context Management Architecture November 2026 disappears, and how unreachable participants or uncertain operation outcomes are reported. These questions are to be addressed in the dialog-management protocol draft, in coordination with relevant IETF working groups (for example, SIP Core for Dialog semantics, QUIC for transport migration, and TLS, WIMSE, and OAuth for session, identity, and delegated authority) and with the application protocols to which the protocol binds, such as A2A and MCP. The following matrix summarizes the recovery cases at the architecture level; it is a set of questions to examine, not a failure taxonomy. Propagation failure modes are described under "Propagation Failure Modes" (§8.12). Moussa & Akhavain Expires 20 May 2027 [Page 33] Internet-Draft Context Management Architecture November 2026 +=============+================+==============+=====================+ | Case | Logical Dialog | Mapping | What to examine | | | | state | | +=============+================+==============+=====================+ | Reconnect | Same Dialog D | Preserved | Whether | | | | | participants can | | | | | resume the existing | | | | | correlation. | +-------------+----------------+--------------+---------------------+ | Reconnect | Same intended | Lost | Whether they can | | with state | Dialog D | | detect or re- | | loss | | | establish the | | | | | association. | +-------------+----------------+--------------+---------------------+ | Continue | New Dialog D′ | Reference | Whether D′ is | | | (continuation) | to the | clearly related but | | | | earlier | distinct. | | | | Dialog | | | | | available | | +-------------+----------------+--------------+---------------------+ | Replace | New Dialog D″ | Earlier | What remains | | | (replacement) | state | related and what is | | | | partly | explicitly | | | | available | superseded. | +-------------+----------------+--------------+---------------------+ | Continue | New Dialog D′ | Reference | Whether D′ both | | and replace | | plus | carries work | | | | partial | forward and | | | | earlier | supersedes the | | | | state | earlier Dialog. | +-------------+----------------+--------------+---------------------+ | Peer | D or successor | Possibly | What can be | | unreachable | unknown | stale | reported without | | | | | inferring the root | | | | | cause. | +-------------+----------------+--------------+---------------------+ Table 1 5.10. Interruptions and Barge-in Work in progress can be interrupted. A barge-in is new input introduced while work is underway that may modify, redirect, or interrupt it. It does not automatically determine whether Tasks are modified, created, or replaced, or whether another Dialog is established. Moussa & Akhavain Expires 20 May 2027 [Page 34] Internet-Draft Context Management Architecture November 2026 The running Activity of "analyze the video" shows the pattern. The user asked Agent A to analyze video V1; Agent A delegated the video- analysis Tasks to Agent B and the transcription Task to Tool X, and work is in progress. Ten minutes in, the user barges in and tells Agent A to analyze only the last 50% of the video. In this example, no new entity is invoked: the same Activity and Dialogs remain, while the requirement governing the work changes. Two aspects of this barge-in are relevant to correlation: * First, the new requirement must be associated with the work it affects. In this example, Agent B's Task is modified to analyze only the last 50% of the video. Other barge-ins could instead result in new or replacement Tasks, suspension, cancellation, or no change to particular Tasks. Whether Tool X's transcription Task is also affected is an application decision: the existing transcript may still cover the full video, and Agent B may simply use its relevant part, or Tool X's Task may be narrowed to match. * Second, the input that carries the barge-in may arrive in a different modality from the original requirement. The original requirement reached Agent A as text; the barge-in reached it as voice. In this example, the spoken correction is a Resource used as input to the affected Task: AX1 input-to TB1 The correction is not a standalone requirement: "analyze only the last 50%" is meaningful only relative to the original requirement it narrows. Recording that the spoken correction modifies the original requirement, rather than leaving the two statements unconnected, is what lets any participant determine which requirement governs the work after the interruption. How that association is encoded is left to the dialog-management protocol. A barge-in may have several correlation-relevant aspects, which are not mutually exclusive: * a lifecycle change in an affected Dialog, for example from active to interrupted; * the establishment of a related Dialog, such as a clarification side-channel; and * Resource provenance or binding information when the new input uses a different modality or changes the requirement associated with a Task. Moussa & Akhavain Expires 20 May 2027 [Page 35] Internet-Draft Context Management Architecture November 2026 Which aspects arise is an application decision. The architectural concern is that the initiating input, affected Dialogs, Tasks, and Resources, and any resulting changes can be correctly associated; it does not prescribe the operational response. The user interruption is therefore treated here as a correlation- relevant occurrence; the Task modifications, creations, replacements, suspensions, or cancellations discussed in this section are illustrative application responses. The minimal question is which Dialog, affected Task or requirement, input or derived Resource, and local identifier must remain associated across the interruption and, where applicable, the modality change. A barge-in can also affect in-flight or subsequent Events within an affected Task. Events remain local to their Tasks and do not acquire independent lifecycle states. Where necessary, their association with the affected Task and relevant requirements must remain interpretable. A barge-in may affect several related Dialogs. Suppose Agent B has created D5 with Agent C, Agent C has created D7, and D8 aggregates D5 and D6. In this example: * D5 is interrupted: its in-flight Task is modified, because the requirement it was pursuing has changed. * D7, which Agent C chained from D5, is suspended: the work it was doing served the requirement that has just changed. * D8, which aggregates results produced independently in D5 and D6, is terminated: the Task that required D8 to aggregate from upstream Dialogs was replaced by the barge-in, so D8's reason for existence is gone and its awaiting Tasks are cancelled. * D6, which runs independently of D5, is untouched. One interruption readjusted work in four Dialogs: a lifecycle transition and Task modification in D5, a suspension in D7, and a termination in D8. Each is an explicit fact of the model, tied back to the interruption through the lineage relationships that link the four Dialogs. These questions are candidates for coordination with transport- oriented work (for example, WebTransport, WebRTC, and MoQ) and with the dialog-management protocol. Open questions include: * how lifecycle transitions behave when interruptions occur mid- course; Moussa & Akhavain Expires 20 May 2027 [Page 36] Internet-Draft Context Management Architecture November 2026 * how changes resulting from a barge-in are associated with affected Dialogs, Tasks, and Resources; * how affected ongoing or subsequent Events remain interpretable within the relevant Task; * how the association between the barge-in input and the requirement it affects is preserved across modality changes; and * how far correlation information about the effects of a barge-in needs to travel through the Activity graph. * How to inforce a barge-in from an application prespective or is it an out-of-scope item. 5.11. Reuse Across Dialogs The same Resource can appear in several Dialogs. In the running example, V1 is used by both D2 and D3, and T1, produced in D3, is consumed in D2 and later referenced in D5 as provenance: Resource V1 Resource T1 | | +--> D2 +--> D2 | | +--> D3 +--> D5 Sharing a Resource does not imply identical local interpretation: D2: T1 analyzed as primary text input D5: T1 retained only as provenance Resource identity remain stable while interpretation is local. These Dialog-local interpretations are Resource Bindings, and roles can change as the Activity executes and delegations happen. Sharing also does not imply the same Dialog. For example, that D2 and D5 both reference V1 does not imply: D2 == D5 Moussa & Akhavain Expires 20 May 2027 [Page 37] Internet-Draft Context Management Architecture November 2026 or that Agent A, Agent B, and Agent C share one conversation. Resource correlation and Dialog correlation are separate concerns: a reference identifies the same Resource across Dialogs, while the interpretation of that Resource remains local to each Dialog in which it is used. 5.12. The Running Example, Assembled The concepts introduced in this section can be assembled into a single picture of the running example. The figure below unifies the two views of the Architectural Model: the invocation view of the interaction wave, instantiated with the example's participants and roles, framed by the Activity root above and the Resource Layer below, as in the containment view. Activity: analyze video V1 | User (AIE) | | Dialog D1 (Activity, V1) v Agent A (FNE) + -----------------+ Dialog D2 | | Dialog D3 delegated-from D1| | delegated-from D1 task(s) v v task (one-shot) Agent B (AA) Tool X (AT) + Dialog D5 | delegated-from D2| task(s) | v Agent C (AA) (invisible to Agent A) +----------------------------------------------+ | Resource Layer | | V1: transferred to D2; referenced by D3 | | T1: produced in D3; consumed in D2; | | referenced as provenance in D5 | | AX1: barge-in input (voice); input-to TB1 | +----------------------------------------------+ The figure exhibits, in one place, most of the properties established in this section: * Branching: D2 and D3 are both delegated from D1. Moussa & Akhavain Expires 20 May 2027 [Page 38] Internet-Draft Context Management Architecture November 2026 * Chaining: D5 is delegated from D2, extending the wave below Agent B. * Hidden delegation: D5 and Agent C are invisible to Agent A. * Independent lifecycle: the Dialogs need not share state; D3 completes with its one-shot Task while D2 remains active and D5 may be suspended. * Resource reuse: V1 is shared by D2 and D3, and T1, produced in D3, is consumed in D2 and referenced as provenance in D5. * Interruption: a barge-in (AX1, voice) narrows the objective of TB1 mid-course; its effects travel through lineage to the Dialogs that depend on it. Every edge is an invocation, every Dialog is independently maintained, and every correlation is an explicit relationship. Thus D1, D2, D3, and D5 each have distinct logical DMSs, while the participant retaining the D5--D2 delegation may keep that assertion private rather than adding it to either Dialog's shared DMS. This is the structure that the later discussion of context propagation must preserve. 6. Tasks Within a Dialog Tasks are bounded units of work within Dialogs. An invocation establishes a Dialog but does not necessarily create a Task. A Dialog may contain zero or more Tasks, performed sequentially, in parallel, or through Assistant Tool interactions. The previous section zoomed in from Activities to Dialogs. This section zooms in one more level, to the Tasks inside each Dialog. It examines Task identity, states, cross-Dialog relationships, and the effects of failures and privacy boundaries. The model defines the relevant semantics; protocol documents determine their implementation. 6.1. Task Identity: Local and Global Tasks use identifiers defined by the local application protocol (such as an A2A taskId). Such identifiers are not assumed to be meaningful or resolvable outside their Dialog. Moussa & Akhavain Expires 20 May 2027 [Page 39] Internet-Draft Context Management Architecture November 2026 Unlike a Resource that needs stable identity across boundaries, a Task need not have a universal identifier. Its cross-Dialog association may be asserted by a participant that can resolve the relevant local Tasks. Whether to standardize a global Task identifier remains a protocol-design decision. 6.2. Task States Tasks have lifecycle states independent of their Dialog's state. The following states are illustrative and are not prescribed for application protocols. When Task-state information is used for interoperable correlation, the dialog-management protocol determines which assertions it supports and how they are represented. Progression states - a Task holds exactly one at a time: defined the Task exists; work has not begun queued the Task was accepted and is waiting behind other work in-progress work is in progress awaiting the Task cannot make progress on its own; it is blocked on something external, for example another Task's result, a decision, or an authorization delegated part of the work was passed to another Dialog; the Task awaits its result awaiting-approval the Task is blocked on a human decision auth-required the Task is blocked on additional authorization interrupted work was paused or cut off; may resume completed the bounded work is done failed work ended without completing timed-out the Task exceeded its maximum duration rejected the work was declined before it began, for example out of scope or against policy cancelled the Task was ended administratively, for example by a revoked delegation unknown the state of the Task cannot be determined Modifiers - facts about the Task that may persist alongside a progression state: modified the objective or parameters of the Task changed superseded another Task replaces this one Some states, such as completed, timed-out, rejected, or cancelled, may be final. Retry behavior is an application decision. Moussa & Akhavain Expires 20 May 2027 [Page 40] Internet-Draft Context Management Architecture November 2026 A one-shot Task with an Assistant Tool can pass through the whole set in one exchange: defined on assignment, in-progress on submission, completed on response. Structural relations such as delegation or replacement are generally stable; lifecycle assertions such as completion and modification are mutable and can become stale. Participant acting on an old copy can make incorrect decisions, as discussed later under Stale Context. A Task has one progression state at a time; modifiers may coexist with it. Thus a Task may be in-progress and modified without changing its progression state. Lifecycle updates are also Correlation Metadata. "t_32 completed", "t_21 modified", "t_15 superseded" are precisely the assertions that may need to propagate between involved parties, in the upstream direction alongside results and failure information, as discussed later under Directional Propagation. 6.3. Task Independence Each Task has its own lifecycle. A change to one does not automatically change another, even within the same Dialog. Within a single Dialog, several Tasks can be in different states at the same time: t_12 in-progress t_22 awaiting t_32 completed Completing, failing, or cancelling one Task does not automatically change the other Tasks within its Dialog. Task independence also applies across Dialogs. Relationships such as delegated-from or replaces record association; it does not couple their lifecycles, and it does not cause a change in one Task to propagate to another. Dependent work changes only when its participants decide or applicable requirements demand it. This permits partial completion, parallel work, and selective failure within one Activity. As with Dialog lifecycle, a Task's lifecycle state is mutable and may become stale; a participant acting on an old copy can make incorrect decisions, as discussed later under Stale Context. Moussa & Akhavain Expires 20 May 2027 [Page 41] Internet-Draft Context Management Architecture November 2026 6.4. Task Relationships Across Dialogs Examples of Task-level relationship types include: delegated-from t_12 delegated-from t_21 related-to a weaker assertion of correlation, without delegation causality replaces a Task supersedes another, typically a failed or abandoned one delegated-from is the primary cross-Dialog relationship: it asserts that one Task exists because of a requirement found in another. A Dialog may contain many Tasks while only one of them causes a downstream delegation; delegated-from records which one (see "Task Lineage"). At Task granularity, replaces expresses that one Task supersedes another. Replacing a Dialog does not automatically replace all of its Tasks. When a new Task actually supersedes an original Task, its relationship can be expressed explicitly: t_12' replaces t_12 Dependency on an existing result may be inferred from Resource provenance; awaiting a future result is Task state rather than a new relationship type. This avoids introducing a separate verb for every application dependency. 6.5. Task Topologies Dialog and Task lineage are related but distinct. Creating a Dialog does not require creating a Task or Task-to-Task association. Where delegation originates in a Task, its Task relationship can be represented explicitly: D5 delegated-from D2 (Dialog level) t_15 delegated-from t_22 (Task level, when applicable) The Dialog and Task graphs are related but need not mirror each other: * A Dialog may contain zero or more Tasks, so Task relationships add finer-grained detail where applicable. Moussa & Akhavain Expires 20 May 2027 [Page 42] Internet-Draft Context Management Architecture November 2026 * Within one Dialog, Tasks relate to one another through their Resources: the output of one Task is the input of another, sequentially or in parallel. * Assistant Tool Dialogs are terminal in the Activity's interaction wave, regardless of the tool's internal execution. The set of Tasks participating in an Activity can therefore be modeled as a directed graph: G_T = (T, R_T) where T contains the Tasks and R_T their typed relationships. This graph may correspond to, but need not mirror, the Dialog graph G_D. No participant is required to maintain it in full. 6.6. Impact of Dialog Failures on Task Relationships Dialog failures or lifecycle changes may affect Tasks without determining their states. Where consequential changes occur, they need to remain correlated with the affected Dialogs and upstream work. * Dialog terminated: Tasks may complete, fail, be cancelled, or continue under application-specific arrangements. Correlation captures relevant consequences without imposing a uniform transition. * Dialog replaced: When D2' replaces D2, that Dialog-level assertion does not determine what happens to each Task in D2. A Task may be continued through a new Task, superseded, retained in its existing state, or handled otherwise according to the application. Where a new Task t_12' actually supersedes t_12, that association can be recorded explicitly: t_12' replaces t_12 A Task that is not re-established in D2' must not automatically be interpreted as lost, cancelled, or failed solely because its Dialog was replaced. Its known outcome or unresolved status, where relevant, remains part of the correlation context. * Dialog suspended: Depending on the work and its dependencies, associated Tasks may be interrupted, left awaiting, or continue through other arrangements. The relevant Task states and any resulting changes may need to be correlated with the Dialog's suspension. Moussa & Akhavain Expires 20 May 2027 [Page 43] Internet-Draft Context Management Architecture November 2026 * Broken lineage: Loss of an upstream Dialog relationship can make related cross-Dialog Task assertions unverifiable and prevent result correlation or upstream resolution. 6.7. Task Privacy Considerations Task objectives and states can reveal intent, workflow, timing, and delegation. Sharing results need not require disclosing the Tasks that produced them. Administrative domains may therefore: * disclose Dialog participation without Task-level detail; * share a Task's output while withholding its objective; * omit cross-Dialog Task relationships entirely; * generalize Task objectives before propagation. Task associations may be kept privately by intermediaries. Even Task states may be withheld or generalized according to the applicable disclosure policy. 6.8. Events Within Tasks Events are the application interactions through which a Task progresses. For example, a Task T1 within D1 may involve a request E1, a response E2, and a later clarification E3: Activity A1 Dialog D1 Task T1 E1 (request) -> E2 (response) -> E3 (clarification) An Event may carry or reference text, audio, video, or other content; a Dialog may involve several modalities without creating a new Dialog or Task for each change. Application protocols carry these interactions. Where useful for correlation, the dialog-management protocol may carry opaque Event identifiers or references indicating that E2 responds to E1. Such tracking is optional and does not require DMS to hold an Event log or the underlying payloads. Event content and ordering remain matters for the application protocol and any retained application records. Event identifiers or reference, if logged in the DMS and the corresponding payload are added to the resource layer, subsequent authorized access maybe used to reconstruct the conversation and the reconstruction can be utilized in for example help rebuild the context window of an agent. Moussa & Akhavain Expires 20 May 2027 [Page 44] Internet-Draft Context Management Architecture November 2026 7. Binding to Protocol-Local Context Where separate application protocols are employed, they define their own context-management mechanisms, interaction semantics, and identifiers. The architecture complements these mechanisms through local bindings that associate application-protocol objects with the logical objects and correlation metadata defined in this document. Conceptually: Activity | +-- Dialog D1 <-> protocol-local context | | | +-- DMS(D1) | +-- Task <-> protocol-local task identifier | +-- Dialog D2 <-> protocol-local context | +-- DMS(D2) +-- Task <-> protocol-local task identifier Through a local interface, the application runtime invokes dialog- management capabilities and supplies the information needed to establish and maintain relevant correlations. The Dialog-Management Protocol Endpoint processes these operations, maintains or accesses the applicable DMS representations, and propagates selected management and correlation metadata. The runtime can subsequently use this metadata in conjunction with application-protocol state and Resource references. The scope and semantics of protocol-local identifiers are determined by their respective application protocols. A logical Dialog may be associated with multiple application-protocol interactions and identifiers, particularly in multi-party Dialogs or when the underlying communication arrangements change. For example, an application runtime involved in two Dialogs may establish a relationship between Tasks in those Dialogs: T14 delegated-from T22 Moussa & Akhavain Expires 20 May 2027 [Page 45] Internet-Draft Context Management Architecture November 2026 The local bindings associate T14 and T22 with their corresponding application-protocol objects. DCMP represents and propagates the relationship within the applicable managed correlation scope, without carrying the content or execution state of either Task. Where a relationship is propagated beyond its originating scope, its endpoints need to be referenceable by the receiving management endpoints. This may be achieved through logical identifiers, translated identifiers, or opaque references. Local bindings need not themselves be stored in DMS or disclosed to other participants. Application protocols retain their own identifiers, interaction content, and execution state, while DCMP provides common semantics for maintaining and propagating correlations across independently managed interactions. 8. Context Management and Correlation Metadata Propagation The preceding sections defined the model's objects and relationships. This section considers the Correlation Metadata needed to preserve and propagate their associations across participants. Context here means the correlations among Activities, Dialogs, Tasks, and Resources, not an agent's memory or the content of its conversations. Application runtimes invoke dialog-management capabilities to establish and maintain relevant assertions, such as D2 delegated-from D1, a reported lifecycle change, or a provenance relationship between two Resources. Each Dialog's DMS represents its management state and the correlations established within its managed scope. DCMP Endpoints propagate selected, authorized management and correlation metadata to establish or update local DMS representations. Other correlations may remain private, allowing participants to maintain coherent context without requiring a complete view of the Activity. The separation of responsibilities is as follows: * This architecture defines the objects, relationship semantics, and correlation-management principles. * The dialog-management protocol defines interoperable operations and exchanges for management and correlation information. Moussa & Akhavain Expires 20 May 2027 [Page 46] Internet-Draft Context Management Architecture November 2026 * Application-level interactions and content may be carried through separate application protocols or through payload-carriage mechanisms provided by the dialog-management protocol. Where separate application protocols are used, local bindings associate their relevant state with the corresponding management and correlation information. * Transport protocols carry the applicable exchanges. Application and dialog-management exchanges may share a transport connection or use separate connections. The following subsections examine the scope of managed correlations, the information to be propagated, and the principles governing its propagation and maintenance. 8.1. Correlation Scope, Extension, and Maintenance Responsibilities The logical extent of an Activity may exceed the scope of correlations managed through a dialog-management protocol. As an interaction wave expands, participants may establish additional Dialogs and relationships without bringing them into an existing protocol-managed correlation scope. The architecture therefore distinguishes three conditions: * A relationship exists between two objects. * A participant preserves knowledge of that relationship locally. * The relationship is established for management through a dialog- management protocol. The existence of a relationship does not necessarily imply that it is maintained or disclosed through a protocol. Similarly, associating a logical DMS with a Dialog does not, by itself, bring all of its relationships into a protocol-managed correlation scope. Participants selectively extend the managed correlation scope according to application requirements, authorization, and disclosure policies. While participants determine what information they disclose, their collective ability to establish the necessary correlations depends on the information made available. Whether the Activity can proceed under these conditions is a consequence of their disclosure decisions. A protocol-managed correlation scope may span multiple Dialogs and their associated DMS representations, supported by locally maintained mappings, without constituting a single Activity-wide DMS. Moussa & Akhavain Expires 20 May 2027 [Page 47] Internet-Draft Context Management Architecture November 2026 8.1.1. Logical and Managed Correlation Scope The following are views of one Activity, not additional protocol objects: * Logical interaction scope: the Dialogs, Tasks, Resources, and relationships that actually contribute to the Activity, including those unknown to some or all of its participants. * Maintained correlation scope: the associations that participants actually preserve and can relate, whether locally or through one or more context-management protocols. * Protocol-managed correlation scope: the associations brought under a particular interoperable context-management protocol, with identified participants accepting the corresponding maintenance responsibilities. Such scope need not be globally enumerable or visible to any single participant. For example, the AIE invokes the FNE through D1, the FNE invokes Agent A through D2, and Agent A invokes Agent B through D3. An illustrative context-management protocol (e.g., DCMP) manages their correlations with Act-1. Agent B then invokes Agent C through D5 using another non-interoperable protocol (XYZ), or no context- management protocol: Logical interaction scope of Act-1 +-------------------------------------------------------------------+ | | | AIE ---D1--- FNE ---D2--- Agent A ---D3--- Agent B | | | | | | +--- DCMP-managed correlation scope --------+ | | | | | +--- D5 (XYZ)--- C | | | +-------------------------------------------------------------------+ D5 can be logically related to Act-1 although DCMP has no knowledge of D5 or its participants. D5's absence from DCMP is not, by itself, a correlation-maintenance failure. In particular, the logical interaction scope under Act-1 may extend beyond the correlation scope of an employed protocol (i.e., DCMP or XYZ). In other words, the correlation scope of a protocol follows the relationships that have actually been established for management by that protocol. Within a protocol-managed correlation scope, an association is managed when it is included under a particular interoperable context- management protocol and the identified participants accept the Moussa & Akhavain Expires 20 May 2027 [Page 48] Internet-Draft Context Management Architecture November 2026 corresponding maintenance responsibilities. The acceptance boundary is conceptual: it is the point at which those participants accept that responsibility. How acceptance is signaled, negotiated, or recorded is a protocol-design question and is not defined here. Knowing an association, preserving it privately, or managing it through a non-interoperable practice does not by itself make it managed. The following conditions remain distinct: * Not enrolled: the association lies outside the protocol-managed scope, so no participant has accepted a maintenance responsibility for it within that scope. This is not, by itself, a maintenance failure. * Not disclosed: the association may be preserved or managed, but it is not revealed to a particular participant. * No longer maintainable: an accepted association cannot be preserved, recovered, or kept coherent, for example because required information is unavailable or policy prevents its use. The limitation is distinguishable from successful maintenance. * Incorrectly maintained: a participant retains or communicates an association that is wrong, stale, or applied to the wrong object. These conditions describe different observations; one does not imply another. These are scope and maintenance conditions, not the propagation failure taxonomy described under "Propagation Failure Modes" (§8.12). In summary, the logical interaction scope of an Activity may extend beyond the correlation scope of a management protocol; leakage between correlation scopes is determined by the participants shared across those scopes. 8.1.2. Selective Extension and Boundary Bridging (Scope Leakage) Extending a protocol-managed correlation to another Dialog is a participant decision. Agent B may still maintain a private bridge between its Task in D3 and work delegated through D5: Moussa & Akhavain Expires 20 May 2027 [Page 49] Internet-Draft Context Management Architecture November 2026 DCMP-managed Outside DCMP +------------------+ +-------------------+ | D3: Task t_13 | | D5: Task t_15 | | Agent A <-> B | | Agent B <-> C | +---------+--------+ +---------+---------+ | | +-- B's local t_13 <-> t_15 map --+ (not disclosed) B's private mapping can interpret D5 outcomes or relay relevant changes without disclosing C or D5. This preserves local correlation but does not place D5 within the first protocol's managed scope. The architecture does not prescribe protocol adoption or bridging mechanisms. 8.1.3. Maintenance Responsibilities Within the Established Scope Maintenance Responsibilities Within the Established Scope The principle is: The decision to extend the managed correlation scope is distinct from the responsibility to maintain established correlations. Once participants undertake responsibility for protocol-managed correlations, they are expected to keep those correlations sufficiently coherent for their intended purpose. This involves preserving or communicating relevant changes to affected correlations, rather than broadcasting every update or disclosing the complete upstream context. Intermediaries may retain private mappings or translate identifiers. The distinction between scope extension and maintenance is particularly relevant in autonomous and decentralized agentic systems, where participants may independently decide whether to extend the managed correlation scope. In controlled administrative domains or orchestrated environments, scope extension may instead be governed by deployment policies or orchestration logic. Where all relationships contributing to an Activity are required to be managed through the dialog-management protocol, the protocol-managed correlation scope may coincide with the logical interaction scope of the Activity. Maintenance responsibilities apply regardless of how scope extension is governed. Consider a barge-in in D1 that changes requirements for Tasks in D2 and D3 in a manner that affects established managed correlations: Moussa & Akhavain Expires 20 May 2027 [Page 50] Internet-Draft Context Management Architecture November 2026 D1 D2 D3 AIE <----> FNE FNE <----> Agent A Agent A <----> Agent B Task t_11 Task t_22 Task t_13 | | | barge-in changes | | requirement for t_11 | | +-- relevant update -->+-- relevant update --->+ | | correlate impact correlate impact on t_22 on t_13 An unrelated Dialog D5 does not require the same update. If Agent A fails to communicate a change necessary to maintain an established correlation between D2 and D3, this constitutes a maintenance failure rather than a decision not to extend the managed scope. The dialog-management protocol should make detected maintenance failures observable without requiring disclosure of private metadata. If Agent B establishes a further Dialog D6 with Agent C outside the protocol-managed correlation scope, the protocol cannot impose corresponding maintenance responsibilities on Agent C. Agent B remains responsible for its established managed correlations, even when dependencies outside that scope affect its ability to maintain them. Failures originating outside the managed scope may remain unobservable or their causes indeterminate. 8.1.4. Failure Visibility and Bounded Accountability Failure visibility is described in terms of observable correlation outcomes rather than attributed causes. Four outcome classes are useful: * Available and valid: the association can be resolved and used for the correlation it is intended to support. * Missing or unresolvable: no usable association is available, or a reference cannot be resolved. * Stale, inconsistent, or unverifiable: an association exists but is outdated, conflicts with other information, or cannot be checked. * Disclosure not permitted or insufficient information available: policy, authorization, or missing information prevents use of an association. Moussa & Akhavain Expires 20 May 2027 [Page 51] Internet-Draft Context Management Architecture November 2026 These are observations about correlation status. They do not by themselves indicate Activity progress, Task success, or evidence suitable for audit, and this architecture is not an audit system. A participant may observe an outcome without being able to identify its cause. Identifying the responsible step or participant is possible only where evidence and visibility allow it. A silently withheld update, an unreachable peer, or an undisclosed branch can leave a participant with unknown or unverified state rather than a proven violation; a missing response indicates uncertainty, not misconduct. The outcome may reflect any of the conditions in "Logical and Managed Correlation Scope": not enrolled, not disclosed, no longer maintainable, or incorrectly maintained. Distinguishing among them may not be possible from local observation. Where an association was accepted into managed scope, the maintenance responsibility principle applies, but failure to observe maintenance is not proof that maintenance failed. Scope and coverage may themselves be undisclosed. A participant therefore cannot assume that an apparently complete view is complete, and bounded accountability concerns the observable managed associations rather than hidden downstream interactions. This is consistent with §8.12: where supported by evidence, the affected managed step and responsible participant can be identified, but complete visibility and perfect attribution are not implied. When insufficient information prevents a required correlation from being established or an existing managed correlation from being maintained, the dialog-management protocol should make the detected limitation observable to the relevant authorized participants. The application determines the implications of this limitation for the associated Dialogs and Tasks. 8.2. The Propagation Model Propagation carries Correlation Metadata among participants so separately maintained Dialogs, Tasks, and Resources remain correctly associated with their Activity. Four acts are distinct in this model: Moussa & Akhavain Expires 20 May 2027 [Page 52] Internet-Draft Context Management Architecture November 2026 +===========+===========================================+ | Term | Meaning in this architecture | +===========+===========================================+ | Preserve | Keep an association accurately, possibly | | | only locally. | +-----------+-------------------------------------------+ | Propagate | Transfer selected correlation information | | | across a Dialog boundary. | +-----------+-------------------------------------------+ | Disclose | Reveal an identifier, participant, or | | | relationship to another party. | +-----------+-------------------------------------------+ | Project | Construct the limited, locally meaningful | | | view appropriate for a receiving Dialog | | | (see "Context Projection"). | +-----------+-------------------------------------------+ Table 2 For example, B may preserve D2 delegated-from D1 and a local mapping to a reference used by C. B propagates to C only the correlation C needs. C receives a locally meaningful reference and the delegated task objective, and does not learn A's identity or D1's identifier. If that reference cannot be resolved, the association may still be preserved at B but cannot correlate that response; this is a resolution limitation, not a requirement that C disclose more. Propagation adapts selected correlation information across Dialog boundaries rather than copying a participant's entire state: upstream correlation | | select (choose the metadata the receiving Dialog needs) | translate (map identifiers across the Dialog boundary) | correlate (relate it to objects already present) | bind (associate it with local objects and state) v downstream correlation The receiving Dialog's managed correlations may be associated with its DMS where they are established within its shared scope; other associations may be preserved locally by the bridging participant. Neither case requires duplicating the upstream Dialog's DMS. The bridging participant selects the relevant associations. Metadata may concern Activity association, Dialog or Task lineage, or Resource identity and provenance, as described below. Moussa & Akhavain Expires 20 May 2027 [Page 53] Internet-Draft Context Management Architecture November 2026 Two properties follow, both developed later in this section: * Propagation is selective: Only the metadata a receiving Dialog needs to maintain continuity, associate related interactions, or interpret shared Resources should be carried. * Propagation is directional: What travels downstream differs from what travels upstream. The architecture does not prescribe a fixed set of propagation events. Propagation is need-driven. A participant selects the Correlation Metadata needed when extending correlation to a new Dialog, subject to applicable policies. Once a participant has accepted responsibility for an established protocol-managed correlation, however, subsequent changes relevant to that association are subject to its maintenance responsibilities rather than a wholly new choice about whether to maintain the correlation at all. Establishing a new Dialog, delegating a Task, transferring a Resource, or resuming an interaction may each create a need for propagation. Participants may retain more correlations locally than they disclose; receiving Dialogs need only the subset required for coherent interaction. 8.3. What Is Propagated The dialog-management protocol propagates management and correlation metadata to maintain coherent context across participants. It may also provide mechanisms for carrying application payloads associated with Events within a Dialog, where separate application protocols are not employed or where direct payload carriage is desirable. Application payload carriage remains semantically distinct from management and correlation metadata propagation. The main classes of Correlation Metadata are described below. 8.3.1. Activity Correlation A downstream interaction may need to know that it participates in the same broader Activity as other interactions: D2 belongs-to Activity A1 D5 belongs-to Activity A1 Moussa & Akhavain Expires 20 May 2027 [Page 54] Internet-Draft Context Management Architecture November 2026 An Activity has a stable logical identity for correlation purposes. Different participants may use local identifiers or aliases to refer to the same Activity, without requiring a globally shared identifier value. The representation, exchange, and possible standardization of Activity identifiers are protocol-design considerations (see Identifier Translation). 8.3.2. Dialog Lineage When a new Dialog results from an existing one, the delegating participant can retain the relationship: D5 delegated-from D2 Dialog lineage preserves the causal or delegation relationship between two Dialogs. Preserving lineage does not imply propagating or disclosing it. A participant may retain lineage locally, and propagate it only when the receiving Dialog needs it, for example for upstream resolution or result correlation. When propagated, the relationship may be carried directly or as an opaque reference, or it may be withheld. Preservation, propagation, and disclosure are therefore separate concerns. Delegation is one lineage type among several; continuation-of, replaces, aggregated-from, and related-to are the others, and each propagates on the same terms described here. 8.3.3. Task Lineage A downstream Task may be correlated with the upstream Task from which it originated: t_15 delegated-from t_22 Task lineage is useful when a Dialog contains several Tasks and only one of them caused the downstream delegation; delegated-from records which one. Protocol-local Task identifiers are not intended to travel; the relationship carries the correlation. Task lineage is therefore optional and selective: it is established where the receiving Dialog requires it for continuity, upstream resolution, or correct interpretation, and withheld otherwise. Under hidden delegation it may be retained only by the participant common to both Dialogs. As with Dialog lineage, related-to and replaces are examples of other Task lineage types, and each propagates on the same terms. Moussa & Akhavain Expires 20 May 2027 [Page 55] Internet-Draft Context Management Architecture November 2026 8.3.4. Resource Identity A Resource that is referenced or transferred across Dialog, protocol, or administrative boundaries may need to retain a stable logical identity, so that independently operated participants can recognize that they refer to the same Resource: Dialog D2: Resource T1 Dialog D5: Resource T1 Where an operation transforms, derives from, or partially reuses an existing Resource, the participant performing the operation decides whether the result constitutes a new logical Resource or a new use of the existing one. A new logical Resource is related to its sources through a typed relationship such as derived-from; a new use of an existing Resource is expressed as a Resource Binding. The architecture does not determine which choice an application should make, but it requires the choice to be representable, so that participants can distinguish reference to the same Resource from reference to a distinct, related Resource. For example, in the barge-in scenario, analyzing the relevant part of an existing transcript is a Binding, whereas producing a narrowed transcript as a separate artifact creates a new Resource derived from the original. Resource identity is a logical assignment rather than a determination derived from content: two artifacts with identical content produced by different operations are distinct Resources, distinguished by their provenance. A participant that equates them is making a local mapping decision, not altering either Resource's identity. Where cross-Dialog Resource correlation is required, the association between references to the same logical Resource may be maintained through shared identifiers, local identifiers, or boundary-specific aliases and mappings. This does not require participants to exchange an identical Resource-ID value or disclose the association to every participant. Dialog D2: Resource reference = r-17, A2A artifactId = artifact-17 Dialog D5: Resource reference = r-91, A2A artifactId = artifact-91 Mapping: r-17 <-> r-91 (same logical Resource T1) A Resource's stable logical identity supports cross-Dialog correlation; identifier representations, mappings, storage, and content transfer remain separate implementation or protocol concerns. Identity identifies the Resource; provenance describes its origins, and Binding describes its local use. Moussa & Akhavain Expires 20 May 2027 [Page 56] Internet-Draft Context Management Architecture November 2026 8.3.4.1. Resource Provenance Resource identity establishes how participants refer to the same Resource. Resource Provenance is another resource-specific typed relationship. Examples include: T1 derived-from V1 TXT-3 produced as a result of task 1 in dialog 1 Provenance asserts that a Resource was produced from, or derived from, another object, and records that derivation as a typed relationship. Like Dialog lineage and Task lineage, provenance is preserved and disclosed selectively: it need not be propagated transitively, and a participant may retain a derivation locally without disclosing it. Receiving one derivation edge does not imply knowledge of earlier edges in a chain. Whether and how provenance is exchanged is a protocol-design question. Provenance describes origins; it does not by itself prove the derivation or that it was authorized. This architecture does not define a lifecycle state machine for Resources; where one Resource supersedes another, that is expressed as a relationship rather than as a Resource lifecycle state. 8.3.4.2. Local Resource Binding The same Resource can play a different role in each Dialog or Task in which it appears. A Resource Binding associates a Resource with a specific Dialog or Task and describes how it is used there: T1 input-to TB1 T1 augments TC1 Unlike identity and provenance, a Binding is not an end-to-end property of the Resource: D2 / Task TB1: T1 primary-input-to TB1 D5 / Task TC1: T1 supporting-input-to TC1 The same logical Resource is referenced in both cases, but its local role differs. When a Resource is propagated into a new Dialog, the upstream Binding is not assumed to apply there. The delegating party may carry it unchanged, restate it as a recommendation for the receiving Dialog, convey it in part, leave it unspecified, or let the receiving participant establish a new one. Bindings are therefore local semantics. They may be carried across a boundary when useful, but doing so does not make them universal: Moussa & Akhavain Expires 20 May 2027 [Page 57] Internet-Draft Context Management Architecture November 2026 T1 required-for TB1 does not imply T1 required-for TC1 8.3.5. Propagation Summary The classes differ in what they are and how they typically travel: +=============+=====================+============================+ | Information | Role | Typical propagation | +=============+=====================+============================+ | Activity-ID | Stable identity of | When cross-Dialog Activity | | | the Activity | correlation is needed | +-------------+---------------------+----------------------------+ | Dialog | Causal or | Retained where needed; | | lineage | delegation relation | selectively propagated | | | between Dialogs | | +-------------+---------------------+----------------------------+ | Task | Protocol-local | Selectively referenced for | | identifiers | unit-of-work | cross-Dialog correlation | | | tracking | | +-------------+---------------------+----------------------------+ | Event | Optional references | Only where fine-grained | | identifiers | to application | correlation is needed | | | interactions | | +-------------+---------------------+----------------------------+ | Resource-ID | Stable identity of | When cross-Dialog Resource | | | a logical Resource | correlation is needed | +-------------+---------------------+----------------------------+ | Resource | How a Resource was | When needed for correct | | provenance | produced or derived | interpretation | +-------------+---------------------+----------------------------+ | Resource | Local role of a | Primarily local; | | Binding | Resource | selectively carried | +-------------+---------------------+----------------------------+ Table 3 The rule is constant across all of them: Propagate only the correlation the receiving Dialog needs to maintain continuity, associate related interactions, or interpret shared Resources. 8.4. Propagation Is Not Transitive by Default Propagation in this architecture is selective rather than automatic. Moussa & Akhavain Expires 20 May 2027 [Page 58] Internet-Draft Context Management Architecture November 2026 A contextual element can be stable or important without being transmitted to every participant. Each propagation decision depends on whether the receiving Dialog requires that information for correlation, continuity, or correct interpretation. Receiving context information does not imply that the receiver should automatically propagate all of it further. For example: A <----> B <----> C B may receive from A: Activity A1 Resource V1 Resource T1 A's identity private policy metadata and propagate to C only: Activity correlation V1 T1 Therefore: Context received from an upstream participant is not automatically transitive. This principle governs the selection and disclosure of information when extending correlation. It does not release a participant from maintenance responsibilities already accepted for an established protocol-managed association. A participant need not forward an upstream update unchanged, but must preserve or communicate enough information to maintain the correlations for which it is responsible, or make the resulting inability to maintain them distinguishable. Each propagation step is subject to a new projection decision, determined by the participating parties as described under "Context Projection". A dialog-management protocol provides a means for the selective propagation of context metadata. This is important when agentic systems cross: * organizational boundaries; * trust boundaries; * privacy boundaries; Moussa & Akhavain Expires 20 May 2027 [Page 59] Internet-Draft Context Management Architecture November 2026 * protocol boundaries; and * changes in task extent. Propagation is triggered by the needs of the receiving Dialog rather than by a fixed set of protocol events. A new Dialog, delegated Task, transferred Resource, resumed interaction, or modality transformation may require propagation, but only the correlation information necessary for that Dialog should be carried. The architecture therefore defines propagation in terms of information requirements and Dialog boundaries, rather than prescribing a universal set of propagation events. 8.5. Context Projection Context Projection selects what is disclosed when B creates D2 from D1, without copying D1's complete state. For example: D1: Activity A1 objective V1 T1 A's identity private policy conversation history internal reasoning credentials | | projection by B v D2: Activity correlation delegated task objective V1 T1 relevant provenance Projection therefore determines what is exposed to the downstream Dialog. The projection is controlled by: * task requirements; * privacy policy; Moussa & Akhavain Expires 20 May 2027 [Page 60] Internet-Draft Context Management Architecture November 2026 * authorization policy; * administrative-domain policy; * protocol capabilities; and * application semantics. The projection algorithm is outside this architecture. The example includes both application-level material (such as the delegated objective and Resources) and correlation information. Projection of application content is not a transfer of DMS. Only correlation metadata explicitly established for D2's shared managed scope becomes part of DMS(D2); the other content remains with the application protocol or participant-local state. 8.6. Identifier Translation Identifiers may change across domains, provided that the necessary mappings preserve correlation: Organization 1: Activity-ID = A1 Organization 2 external view: Activity alias = X7 Organization 2 can retain: A1 <-> X7 privately. Likewise, a Resource may be represented as: Resource T1 in the architecture while having local identifiers: A2A artifactId = artifact-17 MCP resource URI = ... local database ID = 9f32 Identifier translation permits correlation without globally visible implementation identifiers. Its mechanisms belong to the protocol bindings or local-protocol specifications. Moussa & Akhavain Expires 20 May 2027 [Page 61] Internet-Draft Context Management Architecture November 2026 8.7. Directional Propagation Propagation can occur in both directions, but the information carried in each direction can differ. 8.7.1. Downstream propagation Typically carries: activity correlation task objective selected Resources selected provenance constraints 8.7.2. Upstream propagation Typically carries: results new Resources status questions failure information local observations A downstream participant does not necessarily return the same context that it received. For example: B -> C: V1 T1 analyze video C -> B: result R1 observation: T1 appears unnecessary The second message is related to the same Activity but introduces new local information. 8.8. Propagation of Assertions Correlation Metadata may be expressed as assertions, for example: Moussa & Akhavain Expires 20 May 2027 [Page 62] Internet-Draft Context Management Architecture November 2026 D2 delegated-from D1 T1 derived-from V1 T1 input-to TC1 An implementation should distinguish the existence of an assertion from the authority or trustworthiness of the entity making that assertion. For example, receiving: T1 derived-from V1 does not cryptographically prove the derivation. Likewise: D2 delegated-from D1 does not by itself prove that the delegation was authorized. Authentication, authorization, integrity protection, attestation, and provenance mechanisms can be used independently where required. This should be coordinated between the agentproto working group and other respective IETF working groups such as WIMSE and OAuth. Correlation assertions may also come from different sources. A Dialog's or a Task's state may be reported by its participants, observed by a peer, or asserted by a supervisory system. When two sources disagree about the same object - for example, when one reports a Task as in-progress while another reports it as failed - correlation requires that the assertions remain associated with the correct object and, where needed, distinguishable by their sources and relevant context. This architecture does not determine which assertion is authoritative or prescribe how disagreements are resolved. 8.8.1. Lifecycle-Affecting Requests and Consequences A lifecycle-affecting request, such as a request to cancel a Task, is distinct from an assertion that the requested transition has occurred. Application protocols may carry the request and report its outcome. This architecture concerns the Correlation Metadata needed to associate such requests and assertions with the affected Dialog or Task, and to maintain correlations with dependent work in other Dialogs. An application-level change to an Activity, Dialog, or Task objective does not by itself require a protocol-managed correlation update or DMS modification; only consequent changes to tracked identities, lifecycle, membership, relationships, or propagation-relevant metadata need to be represented in the applicable managed scope. Moussa & Akhavain Expires 20 May 2027 [Page 63] Internet-Draft Context Management Architecture November 2026 When an interruption, barge-in, cancellation, or security or authorization change may affect related work, the necessary associations may be preserved by a participant with visibility into the relevant Dialogs and Tasks. Sufficient Correlation Metadata is propagated where needed to allow affected participants to interpret the change and associate resulting states or outcomes with it. The metadata need not expose the full upstream context. Security- or authorization-related information may be included where required for correlation; this architecture does not define authorization decisions or enforcement. 8.9. Context Freshness and Lifetime Not all correlation assertions have the same lifetime. Examples include: Dialog D2 terminated delegation revoked resource superseded task completed Correlation information may be: stable mutable time-bounded revocable For example: T1 derived-from V1 is typically stable provenance. By contrast: D2 active is mutable lifecycle state. Propagation mechanisms need appropriate freshness and update behavior for each class. Representations of the same logical DMS can be transiently different or stale; the implementing protocol determines how participants recognize authoritative shared-state changes and recover a sufficiently current authorized view. Moussa & Akhavain Expires 20 May 2027 [Page 64] Internet-Draft Context Management Architecture November 2026 8.10. Propagation Revocation Revocation invalidates a relationship as a basis for future propagation. For example: D2 delegated-from D1 is revoked, no new downstream propagation should be created based on that relationship. Revocation need not terminate the Dialog or erase the historical fact that the relationship existed. When a participant leaves or is removed from a multi-party Dialog, its membership-based entitlement to future shared DMS updates can also end. Membership change and revocation of a cross-Dialog propagation relationship are distinct management concerns and do not automatically imply one another. The primary case is a Dialog that remains open while a propagation relationship is revoked. For example, D2 continues between A and B, but the propagation relationship on which B disclosed selected D2 metadata to C is revoked. D2 remains active. The prior association and disclosure remain historical facts and are not erased. What changes is that future disclosure or propagation based on that relationship is no longer authorized. This architecture does not determine whether existing recipients retain or delete previously received information; that remains a policy and protocol question, as noted below. Revocation may be only partially visible: some participants may not yet have learned of it and may treat the earlier association as locally current. Dissemination, ordering, and enforcement are protocol and security design questions; authority and trust are discussed under "Propagation of Assertions". Protocol-design questions include whether revocation cascades, how history is treated, and what participants do with earlier correlations derived from a revoked relationship. 8.11. Partial Visibility No participant needs the complete Activity graph. For example: Moussa & Akhavain Expires 20 May 2027 [Page 65] Internet-Draft Context Management Architecture November 2026 A | D1 | B / \ D2 Tool X | C A may know only: D1 B C may know only: D2 B V1 T1 B may know the relationship between D1 and D2. Tool X may know only: V1 its local invocation T1 The Activity can remain coherent with partial visibility. An intermediary may conceal a downstream Dialog while preserving necessary correlation, or establish it outside managed scope. Only accepted managed correlations entail the corresponding maintenance obligations. 8.12. Propagation Failure Modes Correlation can fail even when application Tasks and transport operate correctly. The following failures are distinct from application or connectivity failures. Propagation failures merit separate treatment. Illustrative failure modes follow. These are just examples. The list may be extended as the work progresses Moussa & Akhavain Expires 20 May 2027 [Page 66] Internet-Draft Context Management Architecture November 2026 8.12.1. Loss of Correlation A participant may receive an interaction or Resource without being able to associate it with the correct Activity, Dialog, Task, or Resource. For example: Agent D receives T1 but cannot determine which ongoing Activity or Dialog T1 belongs to. The Resource may remain usable while cross-Dialog continuity is lost. Loss of correlation can result from: * Missing Activity correlation; * Loss of Dialog lineage at an intermediary; * Failure to preserve Resource identity; or * Inability to map protocol-local identifiers to the broader correlation model. 8.12.2. Incorrect Correlation Incorrect correlation associates unrelated interactions or Resources. For example: T1 belongs-to Activity A1 may be incorrectly interpreted as: T1 belongs-to Activity A2 Misbinding may combine unrelated Activities or deliver results to the wrong Dialog; correlation mappings are integrity-sensitive. Implementations SHOULD therefore treat correlation identifiers and relationship mappings as integrity-sensitive state. 8.12.3. Over-Propagation A participant may receive more metadata than needed. For example, Agent D may require only T1 for summarization but receive: Moussa & Akhavain Expires 20 May 2027 [Page 67] Internet-Draft Context Management Architecture November 2026 Activity-ID A1 D3 delegated-from D2 D2 delegated-from D1 T1 derived-from V1 identities of upstream participants even though none of that information is necessary for summarization. Over-propagation increases: * privacy exposure; * topology disclosure; * metadata size and transmission overhead; * implementation coupling; and * cross-domain tracking risk. Selective propagation protects privacy and reduces coupling. 8.12.4. Stale Context Some context changes over time: For example: D2 ACTIVE may later become: D2 TERMINATED or a propagation relationship may be revoked. Stale context can produce incorrect decisions. Stable relationships and mutable lifecycle assertions require different freshness handling. For example, stable provenance such as T1 derived-from V1 differs from mutable lifecycle state such as D2 ACTIVE; propagation mechanisms therefore need appropriate freshness and update behavior for each. This concern is particularly relevant to long-lived Dialogs, where participants may retain local management and correlation information across extended periods of inactivity or disconnection. During such Moussa & Akhavain Expires 20 May 2027 [Page 68] Internet-Draft Context Management Architecture November 2026 periods, lifecycle state, participant membership, authorization information, or established correlations may change. A participant resuming communication may therefore hold an outdated DMS representation. The dialog-management protocol needs to support identifying stale state and recovering an appropriately current and authorized view, without requiring disclosure of information outside the participant's managed correlation scope. 8.12.5. Semantic Drift A downstream Dialog may incorrectly reuse an upstream local interpretation. For example: D1 / TB1: T1 required-for TB1 must not automatically be interpreted as: D2 / TC1: T1 required-for TC1 The Resource identity is preserved, but its local Binding may differ. Semantic drift arises when a local Resource Binding is treated as universally applicable. 8.12.6. Broken Lineage An intermediary may lose the relation connecting a delegated Dialog to its origin. For example: D1 -> D2 is created, but B later loses the relationship: D2 delegated-from D1 Without that link, subsequent questions, results, and failures may not be routed or correlated upstream. Broken lineage obstructs: * upstream resolution; * result correlation; * failure recovery; and Moussa & Akhavain Expires 20 May 2027 [Page 69] Internet-Draft Context Management Architecture November 2026 * audit or troubleshooting of delegated execution. 8.12.7. Excessive Lineage Propagation Excessive lineage disclosure is the opposite risk: A system may preserve and propagate an unnecessarily complete delegation chain: D5 <- D4 <- D3 <- D2 <- D1 to every downstream participant. An accurate but over-shared chain may reveal unnecessary participants, domains, or workflow topology. Preservation and disclosure are distinct. 8.12.8. Inconsistent Local Mapping Local mappings may include: Activity A1 <-> local activity-773 Resource T1 <-> local artifact-19 Inconsistent mappings can bind a valid logical identifier to the wrong local object, appearing externally as a cross-domain correlation failure. Such failures are local implementation failures, but they can appear externally as incorrect cross-domain correlation. 8.12.9. Partial Propagation Failure In a multi-element propagation operation, some context may arrive while other required context is lost. For example, a participant may receive: Resource T1 Activity-ID A1 but not the Resource identifier or relationship necessary to associate T1 with the Task awaiting it. Moussa & Akhavain Expires 20 May 2027 [Page 70] Internet-Draft Context Management Architecture November 2026 Partial propagation can be more difficult to detect than complete propagation failure because the receiving participant may have enough information to continue execution while silently losing intended correlation. 8.12.10. Architectural Implication These failure modes reinforce a central principle of this architecture: Correct correlation requires preserving sufficient information to maintain the relationships among an Activity's Dialogs, Tasks, and Resources. Such information may be maintained locally or selectively propagated between participants, depending on which associations need to be established and by whom. A propagation mechanism SHOULD therefore support detection or mitigation of missing, stale, inconsistent, or excessive correlation information without requiring every participant to maintain the complete Activity graph. In a protocol-managed scope, the architecture further recognizes the need to distinguish failures to maintain accepted correlations from interactions that were never included in that scope. Where supported by evidence, the affected managed step and its responsible participant should be identifiable. This does not imply complete visibility into undisclosed downstream interactions or perfect attribution of the underlying cause of failure. 8.13. Propagation Example The video-analysis example can be expressed as follows. Initial Dialog: Activity A1 D1: A <-> B Task TB1: V1 input-to TB1 Tool transformation: A -> Tool X T1 derived-from V1 T1 output-of the transcription Task in D3 Moussa & Akhavain Expires 20 May 2027 [Page 71] Internet-Draft Context Management Architecture November 2026 T1 enters D1: T1 input-to TB1 B creates a downstream Dialog: D2 delegated-from D1 TC1 delegated-from TB1 B projects: Activity correlation V1 T1 T1 derived-from V1 task objective into D2. C develops local context: T1 input-to TC1 T1 appears unnecessary C asks B for clarification. B uses locally retained lineage: D2 delegated-from D1 TC1 delegated-from TB1 to resolve the question upstream. The complete upstream Dialog does not need to be copied into D2, and the downstream Dialog does not need to be exposed to A. This is the intended meaning of context propagation in this architecture. 8.14. Relationship Taxonomy The following are examples of relationship types that are useful at the architecture level. They are illustrative, not an exhaustive or normative set; the dialog-management protocol defines the relationship types that are interoperable. Moussa & Akhavain Expires 20 May 2027 [Page 72] Internet-Draft Context Management Architecture November 2026 The table does not define a registry or a wire vocabulary. Endpoints are logical objects; where local identifiers are used, they are associated through the mappings described in "Binding to Protocol- Local Context". "Use" names the primary architectural purpose; application-specific interpretation remains outside the interoperable baseline. +=============+=================+=============+==============+==============+ |Relation |Endpoints |Direction and|Non- |Use | | | |meaning |implications | | +=============+=================+=============+==============+==============+ |belongs-to |Dialog→Activity; |Subject is |Does not imply|correlation | | |Task→Dialog; |grouped with |visibility, | | | |Resource→Activity|the |authorization,| | | | |referenced |or shared | | | | |Activity or |lifecycle. | | | | |contained by | | | | | |the | | | | | |referenced | | | | | |Dialog. | | | +-------------+-----------------+-------------+--------------+--------------+ |delegated- |Dialog→Dialog; |Subject |Does not |correlation; | |from |Task→Task |exists |transfer |application | | | |because work |authority, |interpretation| | | |from the |couple | | | | |referenced |lifecycles, or| | | | |object was |make the | | | | |delegated |upstream | | | | |into it. |responsible | | | | | |for downstream| | | | | |work. | | +-------------+-----------------+-------------+--------------+--------------+ |derived-from |Resource→Resource|Subject was |Does not prove|correlation; | | | |produced from|derivation or |provenance | | | |or derived |authorization;| | | | |from the |not transitive| | | | |referenced |by default. | | | | |object. | | | +-------------+-----------------+-------------+--------------+--------------+ |input-to |Resource→Task |Subject is |Does not imply|correlation; | | | |consumed as |the Task |application | | | |input by the |requires it, |interpretation| | | |Task. |or that the | | | | |Binding is |use is | | | | |local to that|authorized. | | | | |use. | | | +-------------+-----------------+-------------+--------------+--------------+ |output-of |Resource→Task |Subject was |Does not imply|correlation; | Moussa & Akhavain Expires 20 May 2027 [Page 73] Internet-Draft Context Management Architecture November 2026 | | |produced as |Task success, |provenance | | | |output of the|completion, or| | | | |Task. |authorization.| | +-------------+-----------------+-------------+--------------+--------------+ |continuation-|Dialog→Dialog |New Dialog |Does not by |continuity | |of | |carries |itself imply | | | | |forward work |taking over | | | | |associated |the earlier | | | | |with the |Dialog's | | | | |earlier |overall | | | | |Dialog, |objective, | | | | |including |auto- | | | | |not-yet- |terminating | | | | |started work;|it, | | | | |relevant |transitioning | | | | |context or |Tasks, or | | | | |correlations |transferring | | | | |may also |all | | | | |carry |correlations. | | | | |forward. | | | +-------------+-----------------+-------------+--------------+--------------+ |replaces |Dialog→Dialog; |New object |Does not auto-|continuity; | | |Task→Task |supersedes |terminate the |history | | | |the earlier |original, | | | | |one as |transfer Tasks| | | | |primary |or | | | | |pursuer of |correlations, | | | | |the earlier |or erase | | | | |Dialog's |historical | | | | |objective; at|associations. | | | | |Task level, | | | | | |supersedes a | | | | | |Task. | | | +-------------+-----------------+-------------+--------------+--------------+ |aggregated- |Dialog→Dialog |New Dialog |Does not imply|correlation; | |from | |was created |completion |application | | | |to aggregate |depends on |interpretation| | | |or consume |every source, | | | | |results |nor | | | | |produced |inheritance of| | | | |independently|authorizations| | | | |in multiple |or lifecycle. | | | | |upstream | | | | | |Dialogs; | | | | | |multi-parent.| | | +-------------+-----------------+-------------+--------------+--------------+ |related-to |Dialog→Dialog; |Weak |No delegation,|correlation | | |Task→Task |assertion of |dependency, | | Moussa & Akhavain Expires 20 May 2027 [Page 74] Internet-Draft Context Management Architecture November 2026 | | |correlation |authorization,| | | | |without |or lifecycle | | | | |delegation |coupling. | | | | |causality. | | | +-------------+-----------------+-------------+--------------+--------------+ Table 4 Endpoint lists are illustrative, not exhaustive; other logical associations may use the same relationship where its meaning applies. A companion protocol may initially standardize only the relationship types needed for its core use cases, for example delegated-from, while allowing new types to be introduced without changing the underlying correlation model. It must define how unsupported relationship types are handled; receiving an unfamiliar type must not silently impose lifecycle or application-execution effects. 8.15. Privacy and Administrative Boundaries Administrative boundaries separate participants operating under different policies, authorities, and retention practices. Correlation across such a boundary is constrained by identifier linkability, selective disclosure, and the need to translate or alias references, without requiring a common view of the Activity. These constraints are policy- and authorization-dependent; the architecture leaves their concrete treatment to the participating domains and protocol bindings. 8.16. Relationship to Dialog-Management Protocols A dialog-management protocol may standardize only the subset of the architectural model needed for interoperability. For example, a protocol may define interoperable representations for selected DMS information and related correlation assertions: Dialog-ID Dialog-Relationship Lifecycle State Participant-Membership State (where supported) Propagation State without defining: required-for optional-for application-specific planning semantics Moussa & Akhavain Expires 20 May 2027 [Page 75] Internet-Draft Context Management Architecture November 2026 This leaves application-specific semantics outside the interoperable baseline. 8.16.1. Functional Placement of Dialog Management A dialog-management protocol is a complementary management function, not a layer through which all application messages must pass. A logical management endpoint exchanges the information needed to establish and maintain authorized local DMS views and selected correlations. The endpoint is distinct from the agent, application, or principal it serves, even when implemented in the same process. The following illustrates one possible arrangement for a Dialog D1: Participant A / domain Participant B / domain +------------------------+ +------------------------+ | Application / agent |<------->| Application / agent | | application content | | application content | | | | | | | | Local binding | | Local binding | | | | | | | | Management endpoint |<------->| Management endpoint | | local DMS(D1) view | | local DMS(D1) view | +------------------------+ +------------------------+ application exchanges above; management exchanges below A management endpoint may serve several Dialogs and maintain local cross-Dialog assertions, enabling correlation across an Activity without requiring a centralized Activity-wide DMS. The implementation might use client-server, peer, or service-based arrangements; the architecture does not select among them. The companion protocol specifies endpoint roles, operations, and transport bindings. Application-protocol identifiers and management references are associated through local bindings. Such bindings may be realized in application libraries, sidecars, or management services; they do not require the dialog-management protocol to carry application payloads or define a new binding specification for every application protocol. The separation between Dialog management and application-level interactions is logical and does not require the use of separate protocols. A dialog-management protocol may operate alongside application protocols, such as A2A or MCP, through local bindings, or it may provide mechanisms for directly carrying application payloads associated with Events within a Dialog. Moussa & Akhavain Expires 20 May 2027 [Page 76] Internet-Draft Context Management Architecture November 2026 In the latter case, application payloads may be carried alongside management and correlation metadata while remaining semantically distinct from them. The handling and interpretation of application payloads remain the responsibility of the application runtime. The architecture supports both approaches without prescribing either. 8.16.2. Architectural vs. Protocol Surface The architecture defines Activities, Dialogs, Tasks, Resources, and typed Relationships. DMS is the logical per-Dialog management state, not a mandatory wire object or an application message log. The companion protocol determines both the information that needs an interoperable representation and the exchanges used to establish, modify, synchronize, and recover it. Optional Task, Event, Resource, and security-evidence references need not appear in every Dialog. The agentproto charter identifies Dialog identifiers, lifecycle semantics, and Dialog-context propagation as subjects for its standards-track protocol work. This information model examines related correlation concepts that may inform that work, including: * Dialog identity and identifier aliases; * Dialog lineage and other typed relationships (e.g., delegated- from, aggregated-from, continuation-of, related-to, replaces); * Dialog lifecycle and propagation assertions; * Activity and Task associations where cross-Dialog correlation needs them; and * Resource identity or provenance associations relevant to correlating interactions across modalities or tool invocations. Protocol design determines which information is exchanged, locally retained, or supported by application protocols. Resource Binding remains primarily an application interpretation. 8.17. Relationship to A2A A2A provides useful local constructs such as: contextId taskId artifactId messageId Moussa & Akhavain Expires 20 May 2027 [Page 77] Internet-Draft Context Management Architecture November 2026 These constructs may be associated with the architecture as an illustrative mapping: A2A contextId -> may be associated with a protocol-local Dialog context A2A taskId -> may be associated with a Task A2A artifactId -> may be associated with a local representation of a Resource The association is not required to be one-to-one. An application may use one construct for several architectural objects, several constructs for one object, or a partial correspondence, and its local identifiers may change while the logical Dialog persists. Relevant local identifiers can be associated with the logical Dialog where continuity or correlation requires it. This architecture does not replace those constructs. An A2A contextId identifies a protocol-local context; it is not, by definition, a DMS identifier or a complete DMS representation. Application-specific mappings can associate it with a logical Dialog and relevant management state without changing A2A's own lifecycle. It provides a model for correlating them with objects outside one A2A context. 8.18. Relationship to MCP and Tool Protocols MCP provides tools, resources, prompts, and callable tool interactions within its own protocol context. This model adds a way to associate those interactions with Dialogs, Tasks, and Resources, and to correlate them with work outside one MCP interaction. It leaves MCP message, tool, and resource semantics to MCP and does not replace them. 8.19. Relationship to Distributed Tracing Distributed tracing records execution spans and parent-child links for runtime observation. This model adds participant-visible Dialog identity, lifecycle, and typed relationships across independently controlled Dialogs; whether a participant is authorized to propagate a correlation remains distinct from the correlation itself. It leaves span formats, collection, and export to tracing work, and distinguishes runtime correlation state from Activity or application progress and from post-hoc audit or transparency evidence. Moussa & Akhavain Expires 20 May 2027 [Page 78] Internet-Draft Context Management Architecture November 2026 8.20. Relationship to vCon vCon represents conversational data such as recordings, transcriptions, parties, and analysis. This model adds cross-Dialog identity, lifecycle, and typed relationships so that conversations represented separately can be correlated. It leaves conversation representation, media handling, and vCon-specific analysis to vCon and its maintainers. 8.21. Architectural Considerations for Protocol Design The following capabilities inform protocol design; they do not each require distinct wire fields: 1. multiple Dialogs within one Activity; 2. independent protocol-local context identifiers; 3. stable Resource correlation where useful; 4. delegation lineage; 5. selective projection; 6. hidden downstream delegation; 7. cross-domain operation; 8. identifier translation; 9. provenance correlation; 10. privacy-preserving correlation; 11. correlation of lifecycle-affecting requests, resulting assertions, and dependency-driven consequences across Dialogs and Tasks; 12. distinction between the logical Activity scope and correlations established or maintained under a particular protocol; 13. selective extension of managed correlation, with responsibilities for maintaining the associations participants have accepted; and 14. detection or reporting of failures within managed correlation scope, with bounded identification of affected steps and responsible participants where supported by available evidence; Moussa & Akhavain Expires 20 May 2027 [Page 79] Internet-Draft Context Management Architecture November 2026 15. a distinct logical DMS for each Dialog, with distributed local representations and appropriately scoped shared correlation state; and 16. continuity of Dialog identity and DMS across authorized membership changes, with consistent management-state authority and recovery semantics to be defined by the implementing protocol. 8.22. Out-of-Scope This document does not define: * An agent's internal memory; * Prompts or retrieved documents; * Chain of thought; * Agent planning semantics; * Authorization decisions or enforcement mechanisms; * Delegated-authority mechanisms; * Trust establishment mechanisms; * Agent discovery mechanisms; * A wire format. 8.23. Open Questions 1. Activity and Task are architectural concepts, not baseline protocol objects. The exact protocol surface for optional Activity and Task lineage extensions is to be determined in the protocol draft. 2. Should Dialog lineage be visible downstream or remain local by default? 3. What is the minimum Resource correlation required for multimodal Dialog continuity? 4. Should Resource Binding semantics remain entirely application- defined? Moussa & Akhavain Expires 20 May 2027 [Page 80] Internet-Draft Context Management Architecture November 2026 5. How should logical Activity identity survive identifier translation? 6. How should partial resources such as video segments be represented? 7. Which relationships require integrity protection? 8. How should context-resolution questions be correlated across Dialogs? 9. How much lineage should cross administrative boundaries? 10. Which subset of this model belongs in a dialog-management protocol? 11. Whether a long-lived protocol-local context may be associated with more than one logical Dialog, and how such mappings relate to the model's rule that a Dialog belongs to exactly one Activity, is a question for protocol design and deployment. 12. How should the dialog-management protocol define authority, membership changes, authorized DMS views, consistency, and recovery of shared DMS state across participants, without mandating complete replication or disclosure of private correlations? 8.24. IANA Considerations This document requests no IANA actions. 8.25. Security Considerations Correlation metadata can reveal workflows, delegation, and Resource relationships. Implementations should minimize propagated information, avoid semantic identifiers, and treat correlation identifiers as non- authoritative. Possession of an identifier does not imply authorization. Similarly, Dialog membership does not authorize disclosure of participant- private correlations outside the shared DMS scope; admission and continued access to shared DMS views depend on applicable policy and authority. Relationship assertions may require separate integrity or provenance mechanisms. Moussa & Akhavain Expires 20 May 2027 [Page 81] Internet-Draft Context Management Architecture November 2026 See "Propagation of Assertions" (§8.8) for the distinction between an assertion and its authority or trustworthiness. The following dependencies are architectural; mechanisms are left to other work: +==============+============================+====================+ | Risk | Needed architectural | Left to other work | | | property | | +==============+============================+====================+ | Forged | Authenticity and integrity | Concrete signature | | lineage | of correlation assertions | or authentication | | | | mechanism | +--------------+----------------------------+--------------------+ | Wrong alias | Integrity and binding of | Specific mapping | | mapping | identifier mappings | protocol or | | | | storage | +--------------+----------------------------+--------------------+ | Unnecessary | Limited disclosure and | Specific privacy | | end-to-end | linkability control | technology | | tracking | | | +--------------+----------------------------+--------------------+ | Unauthorized | Authorization for | Authorization | | forwarding | propagation | protocol and | | | | policy evaluation | +--------------+----------------------------+--------------------+ | Lost or | Clear recovery and failure | Transport or | | intermediary | behavior | storage resilience | | state | | implementation | +--------------+----------------------------+--------------------+ Table 5 These properties depend on identity, authentication, authorization, integrity, and privacy building blocks developed elsewhere, notably by the WIMSE working group and in the OAuth framework. This architecture does not define those mechanisms or agent behavioral security. 8.26. Privacy Considerations A distributed Activity MUST NOT require a globally visible participant list or a globally stable identifier. Implementations should: * minimize propagated metadata; Moussa & Akhavain Expires 20 May 2027 [Page 82] Internet-Draft Context Management Architecture November 2026 * preserve participant opacity where possible; * translate identifiers at administrative boundaries; * avoid propagating private dialog history; * limit retention of correlation mappings. 8.27. Appendix A. Canonical Architecture Activity | +-- Dialog D1 --- DMS(D1) | | | +-- Task | | | +-- Event(s) (application interactions) | +-- Resource reference(s) | +-- Dialog D2 --- DMS(D2) | +-- Task | +-- Event(s) (application interactions) +-- Resource reference(s) Resource Layer: Resources may be referenced by multiple Dialogs/Tasks The DMSs in this diagram are logical per-Dialog management state, not additional correlation objects, Task containers, or a common Activity-wide repository. Correlation relationships among the shown objects may be maintained or disclosed selectively. Illustrative relationships: Dialog belongs-to Activity Task belongs-to Dialog Dialog delegated-from Dialog Task delegated-from Task Resource derived-from Resource Resource input-to Task Resource output-of Task Contributors Hesham Moussa Huawei Canada Email: hesham.moussa@huawei.com Moussa & Akhavain Expires 20 May 2027 [Page 83] Internet-Draft Context Management Architecture November 2026 Arashmid Akhavain Huawei Canada Email: arashmid.akhavain@huawei.com Authors' Addresses Hesham Moussa Huawei Canada Email: hesham.moussa@huawei.com Arashmid Akhavain Huawei Canada Email: arashmid.akhavain@huawei.com Moussa & Akhavain Expires 20 May 2027 [Page 84]