Internet-Draft Context Management Architecture November 2026
Moussa & Akhavain Expires 20 May 2027 [Page]
Workgroup:
agentproto
Internet-Draft:
draft-agentproto-context-management-architecture-01
Published:
Intended Status:
Informational
Expires:
Authors:
H. Moussa
Huawei Canada
A. Akhavain
Huawei Canada

Context and Correlation Management Architecture for Distributed Agentic Activities

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.

▲

Table of Contents

1. Introduction

Distributed agentic systems are increasingly composed of multiple independently operated participants.

A single Activity can involve:

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

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.

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

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:

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

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)

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:

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

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:

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.

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

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

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

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:

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

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:

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.

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:

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.

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.

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.

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

Table 1
Case Logical Dialog Mapping state What to examine
Reconnect Same Dialog D Preserved Whether participants can resume the existing correlation.
Reconnect with state loss Same intended Dialog D Lost Whether they can detect or re-establish the association.
Continue New Dialog D′ (continuation) Reference to the earlier Dialog available Whether D′ is clearly related but distinct.
Replace New Dialog D″ (replacement) Earlier state partly available What remains related and what is explicitly superseded.
Continue and replace New Dialog D′ Reference plus partial earlier state Whether D′ both carries work forward and supersedes the earlier Dialog.
Peer unreachable D or successor unknown Possibly stale What can be reported without inferring the root cause.

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.

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.

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;

  • 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

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.

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

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.

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.

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.

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

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

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

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:

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.

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

           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:

            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.

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:

Table 2
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").

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.

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

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.

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.

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:

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:

Table 3
Information Role Typical propagation
Activity-ID Stable identity of the Activity When cross-Dialog Activity correlation is needed
Dialog lineage Causal or delegation relation between Dialogs Retained where needed; selectively propagated
Task identifiers Protocol-local unit-of-work tracking Selectively referenced for cross-Dialog correlation
Event identifiers Optional references to application interactions Only where fine-grained correlation is needed
Resource-ID Stable identity of a logical Resource When cross-Dialog Resource correlation is needed
Resource provenance How a Resource was produced or derived When needed for correct interpretation
Resource Binding Local role of a Resource Primarily local; selectively carried

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.

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;

  • 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;

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

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:

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.

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.

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:

            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

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:

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

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

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

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.

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.

Table 4
Relation Endpoints Direction and meaning Non-implications Use
belongs-to Dialog→Activity; Task→Dialog; Resource→Activity Subject is grouped with the referenced Activity or contained by the referenced Dialog. Does not imply visibility, authorization, or shared lifecycle. correlation
delegated-from Dialog→Dialog; Task→Task Subject exists because work from the referenced object was delegated into it. Does not transfer authority, couple lifecycles, or make the upstream responsible for downstream work. correlation; application interpretation
derived-from Resource→Resource Subject was produced from or derived from the referenced object. Does not prove derivation or authorization; not transitive by default. correlation; provenance
input-to Resource→Task Subject is consumed as input by the Task. Binding is local to that use. Does not imply the Task requires it, or that the use is authorized. correlation; application interpretation
output-of Resource→Task Subject was produced as output of the Task. Does not imply Task success, completion, or authorization. correlation; provenance
continuation-of Dialog→Dialog New Dialog carries forward work associated with the earlier Dialog, including not-yet-started work; relevant context or correlations may also carry forward. Does not by itself imply taking over the earlier Dialog's overall objective, auto-terminating it, transitioning Tasks, or transferring all correlations. continuity
replaces Dialog→Dialog; Task→Task New object supersedes the earlier one as primary pursuer of the earlier Dialog's objective; at Task level, supersedes a Task. Does not auto-terminate the original, transfer Tasks or correlations, or erase historical associations. continuity; history
aggregated-from Dialog→Dialog New Dialog was created to aggregate or consume results produced independently in multiple upstream Dialogs; multi-parent. Does not imply completion depends on every source, nor inheritance of authorizations or lifecycle. correlation; application interpretation
related-to Dialog→Dialog; Task→Task Weak assertion of correlation without delegation causality. No delegation, dependency, authorization, or lifecycle coupling. correlation

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

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.

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

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.

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;

  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?

  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.

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:

Table 5
Risk Needed architectural property Left to other work
Forged lineage Authenticity and integrity of correlation assertions Concrete signature or authentication mechanism
Wrong alias mapping Integrity and binding of identifier mappings Specific mapping protocol or storage
Unnecessary end-to-end tracking Limited disclosure and linkability control Specific privacy technology
Unauthorized forwarding Authorization for propagation Authorization protocol and policy evaluation
Lost or intermediary state Clear recovery and failure behavior Transport or storage resilience implementation

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;

  • 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
Arashmid Akhavain
Huawei Canada

Authors' Addresses

Hesham Moussa
Huawei Canada
Arashmid Akhavain
Huawei Canada