Causal Influence Graph

Nodes represent the fundamental entities within the graph. There are two primary types:

• Agent Nodes: Represent individual autonomous actors (e.g., a planning agent, a tool-calling agent).
• Event/State Nodes: Represent observable outcomes, decisions, or system states (e.g., 'API call executed', 'task completed', 'error thrown'). Each node is a distinct point where influence can originate or terminate.

Edges are the directed connections between nodes that explicitly model causal influence.

• Direction: An edge from Node A to Node B indicates that A's action or state influenced B.
• Weight: Edges are often weighted to quantify the strength of influence (e.g., using statistical measures like Average Causal Effect).
• Temporal Order: Edges imply a temporal sequence; the cause must precede the effect, which is critical for distinguishing correlation from causation.

The quantitative heart of a CIG. Weights transform the graph from a qualitative map to a diagnostic tool.

• Quantification: Weights can be derived from statistical methods (e.g., Granger causality, transfer entropy, or structural causal model coefficients).
• Interpretation: A high positive weight from Agent X to Outcome Y suggests X's actions strongly and positively drive Y. A negative weight indicates a suppressing or corrective influence.
• Dynamic Weights: In live systems, these weights can be updated in real-time to reflect changing agent behaviors.

CIGs often incorporate time explicitly to handle dynamic systems.

• Snapshots: The graph can be a snapshot of influence over a fixed time window (e.g., the last 5 minutes of system operation).
• Time-Sliced Graphs: More complex CIGs use a series of graph layers, where each layer t shows influences active during time slice t. Edges can then connect nodes across layers to trace influence flow over extended periods. This is essential for root cause analysis of delayed effects.

These are nodes representing external factors that influence the system but are not influenced by any agent within the modeled boundary.

• Purpose: They account for confounding variables and external shocks.
• Examples: A sudden spike in user traffic, a third-party API rate limit, or a change in a foundational model's behavior.
• Model Integrity: Including exogenous variables prevents the misattribution of system effects to internal agents, leading to more accurate causal inference.

A core analytical construct derived from the main CIG.

• Definition: A subgraph that isolates all nodes and edges that contributed to a specific outcome node (e.g., a system failure or a successful task completion).
• Function: It performs causal attribution, answering: 'Which agents and actions were most responsible for this result?'
• Visualization: Often highlighted in observability dashboards, showing the 'chain of influence' leading to a critical event, which is vital for debugging and performance optimization.

A data structure that models the communication pathways and message flows between autonomous agents in a multi-agent system. It focuses on the topology of connections (who talks to whom) rather than the causal strength of those interactions.

• Key Difference: While a Causal Influence Graph quantifies how much one agent's action influences an outcome, an Agent Interaction Graph shows if and how agents are connected.
• Primary Use: Visualizing communication patterns, identifying isolated agents, and debugging message routing failures.

An end-to-end observability record that follows a single request or task as it propagates through a system of multiple interacting agents. It captures timing, causality, and data flow across agent boundaries, providing the raw data from which Causal Influence Graphs can be constructed.

• Components: Includes spans for each agent's internal processing and spans for inter-agent communications.
• Relationship to CIG: The trace provides the temporal sequence and raw latency data; statistical analysis of many traces reveals the causal relationships modeled in the CIG.

A composite data snapshot that aggregates the internal states of all agents within a multi-agent system at a specific point in time. This includes beliefs, goals, working memory, and other relevant variables.

• Purpose: Provides a holistic view of the system's global state, which is a necessary input for analyzing how that state evolves due to agent influences.
• Analogy: In physics, a state vector describes a system's condition; here, it describes the multi-agent system's condition. A Causal Influence Graph explains how one state vector transitions to another.

The aggregate computational cost, latency, and resource consumption incurred by agents to communicate, negotiate, and synchronize their actions, as opposed to performing primary task work. A Causal Influence Graph can help quantify and attribute this overhead.

• Measured By: Time spent in consensus protocols, message volume, cycles spent waiting for locks or responses.
• Observability Link: By modeling influence, a CIG can identify which agent interactions or shared resources are the primary sources of overhead, enabling targeted optimization.

An alert or metric indicating that a fault or performance degradation in one agent is propagating through dependencies and causing failures in other agents. Causal Influence Graphs are critical for root cause analysis during such events.

• Detection: Anomalies in agent health metrics that follow a temporal and logical chain.
• CIG's Role: The graph provides the dependency map to predict failure propagation paths and quickly isolate the root cause agent, moving from observing symptoms to understanding systemic cause-and-effect.

A Service Level Objective defined for the reliability or performance of a system composed of multiple agents. Examples include collaborative workflow completion rate or end-to-end latency for a multi-agent query.

• Challenge: Traditional SLOs break down when responsibility is distributed.
• CIG's Role: By quantifying each agent's influence on the final outcome, a CIG enables fine-grained SLO attribution. It answers: Which agent's performance most critically impacts our system-wide SLO? This allows for prioritized investment and debugging.