AgentLens: Visualization for LLM Agents

• AgentLens is a visualization system for LLM-based autonomous systems that transforms execution logs into hierarchically structured behavioral narratives.
• It employs a modular pipeline with log collection, automatic summarization, change-point detection, and interactive multi-level visualization for detailed agent behavior analysis.
• Empirical evaluations show significant improvements in behavior tracing accuracy and task efficiency compared to traditional replay-only methods.

AgentLens is a visualization and analysis system designed for LLM-based Autonomous Systems (LLMAS), addressing the challenge of exploring and interpreting dynamic multi-agent behavioral evolution. By instrumenting LLMAS to log every atomic Perceive/Think/Act operation with full state, context, and provenance, AgentLens transforms these execution events into a hierarchically structured, causally annotated, and interactively explorable visual narrative. The system introduces a modular pipeline encompassing log collection, automated behavior summarization and segmentation, multi-level cause tracing, and a three-pane visualization that bridges both macro-level and micro-level inspection. Initial user studies and technical benchmarks demonstrate significant improvements over replay-only baselines for tasks such as behavior tracing and emergent phenomena discovery (Lu et al., 2024). Extensions to agent-centric information access suggest that such infrastructure generalizes toward dynamically managing and querying populations of domain-specialized LLM agents (Kanoulas et al., 26 Feb 2025).

1. System Architecture and Data Pipeline

AgentLens’s architecture is designed for general compatibility with any LLMAS and comprises three principal stages: log collection, behavior structure extraction, and visualization (Lu et al., 2024).

Stage A: Instrumentation enables capturing every agent’s Perceive, Think, and Act operations as structured logs. For each operation, the system records:

• Timestep $t$
• Agent identifier $i$
• Operation type $o$ (environment, memory, or decision)
• Task context (Perceive/Think/Act)
• Pre- and post-operation system state, including agent locations and variables

Stage B: Raw logs are aggregated into temporal behavior units for each agent. Behavior definitions follow: $B_{i,t_0…t_1} = \bigcup_{t \in [t_0,t_1]} s_{t,i}$ where $s_{t,i}$ is the set of all atomic operations for agent $i$ at time $t$. For segmentation, a window-based change-point detection algorithm (WIN) operates over embedding representations to construct a hierarchy of behaviors and sub-behaviors based on detected semantic transitions.

Stage C: The visualization module ingests the processed data and presents a multi-layered, interactive UI:

• Outline View (global temporal structure)
• Agent View (per-agent, per-timestep drill-down)
• Monitor View (synchronized 2D/3D replay or state rendering)

This staged pipeline enables portable instrumentation, scalable data processing, and flexible interactive analysis.

2. Hierarchical Behavior Summarization and Change-Point Detection

A central feature of AgentLens is its automated behavior summarization and segmentation workflow:

1. Textual Concatenation and Summarization: Agent $i$’s event logs for each block $B_{i,t_0…t_1}$ are concatenated and input to an external LLM summarization API (e.g., GPT-3.5). The LLM produces a one-sentence, emoji-annotated summary per interval.
2. Embedding: Summaries are embedded into 1536-dimensional vectors by a pretrained text-embedding model.
3. Change-Point Detection: For each agent, a sliding window analyzes embedding cosine similarity:

$$k(e_x, e_y) = \frac{\langle e_x, e_y \rangle}{\|e_x\|\|e_y\|}$$

$$c(e_{a…b}) = \sum_{t=a+1}^b k(e_t, e_t) - \frac{1}{b-a} \sum_{s,t=a+1}^b k(e_s,e_t)$$

$$d(e_{u…v}, e_{v…w}) = c(e_{u…w}) - c(e_{u…v}) - c(e_{v…w})$$

Peaks in $d$ determine hierarchical change-points; intervals can be recursively re-segmented to decompose high-level actions into sub-behaviors and atomic operations.

This methodology supports consistent, automatic summarization and temporal partitioning for any LLMAS, providing a foundation for scalable, interpretable analysis.

3. Cause Tracing and Behavior Causality

AgentLens implements a dual-mode causality analysis to reconstruct the directed acyclic graph (DAG) of behavioral dependencies.

• Explicit cause tracing leverages provenance metadata (e.g., memory-index backpointers available in some frameworks like LangChain). If two operations are explicitly linked, the cause is annotated directly.
• Implicit cause mining is driven by semantic similarity. For operations $o_{src}$ at time $i$ and $o_{res}$ at $j \geq i$, embedding similarity $k(e_{src},e_{res})$ exceeding threshold $\delta$ evidences a potential causal link. Such operation-level arcs are aggregated into behavior-level edges: if $o_{src} \in B_{i,t_0…t_1}$ and $o_{res} \in B_{i,t_1+1…t_2}$, draw $B_{i,t_0…t_1} \to B_{i,t_1+1…t_2}$ in the behavior DAG.

This approach enables end-to-end cause tracing, from granular memory events to coarse-grained behavioral trends.

4. Multi-Level Visualization and User Interaction

The AgentLens UI is structured around three coordinated panes, leveraging custom layouts and interactivity (Lu et al., 2024):

• Outline View: Each agent is a colored horizontal curve; $x$-axis represents time, $y$-axis marks location. Behavior intervals are annotated with summaries; agent–agent co-locations are depicted as shaded bands. Interactions include keyword search and zoom-triggered hierarchical re-segmentation.
• Agent View: On selection, this panel displays agent metadata and a vertical event stack for the selected timestep, with icons distinguishing Perceive, Think, and Act operations. Drill-down reveals prompts, responses, and memory accesses. Orange arcs overlay causal predecessors, with a minimap indicating their temporal distribution.
• Monitor View: An integrated replay of the LLMAS environment (2D/3D), synchronized to the current focus. Users can scrub or fast-forward, spatially pan, and adjust contextual windows.

This design supports seamless navigation from system-scale overviews to operation-level granularity, facilitating complex queries and in-depth investigation.

5. Implementation, Data Processing, and Extensibility

AgentLens is web-based (JS/D3), minimally invasive, and modular. Instrumentation consists of lightweight logging hooks to capture structured JSON event streams; preprocessing batches events, triggers LLM summarization and embedding, and computes segmentation indices. Cause-mining operates as a background or online nearest-neighbor batch process.

Key interactive gestures (double-click, zoom, drill, click-to-examine, cause tracing, synchronized replay) are directly mapped to analytic workflows. The data and UI architecture support rapid adaptation to arbitrary LLMAS environments, and all core algorithms—behavior summarization, change-point detection, cause identification—are reusable and extensible.

A plausible implication is the applicability of this platform for diagnosis, debugging, or user-driven exploration in both simulated and real-world multi-agent deployments.

6. Empirical Evaluation and Integration with Agent-Centric Information Access

Formal evaluation includes scenario-based tasks and a controlled user study (Lu et al., 2024). Notably:

• Substantial gains over baseline replay-only systems: accuracy up from 68%→92% for analytic/causal tracing tasks, with 50% reduction in task time.
• On complex cause-tracing, AgentLens yields 93% success versus 22% for baseline.
• Emergent behavior identification (topic diffusion, agent aggregations) is tractable for AgentLens, but "needle-in-haystack" for baseline methods.

Usability is reflected in an SUS score of 67.5 and qualitative endorsement of multi-level summarization, cause-trace arcs, interaction bands, and coordinated views.

This suggests that AgentLens represents an operationally effective paradigm for sense-making in LLM-based societies.

Related frameworks for agent-centric information access emphasize dynamic expertise-driven LLM selection, reward aggregation, and response synthesis from large agent populations (Kanoulas et al., 26 Feb 2025). The AgentLens pipeline provides a direct blueprint for constructing architectures that log, summarize, segment, and analyze agent behaviors at scale, with mathematical formulations for expert selection (cosine similarity, budget-constrained knapsack), RAG evaluation, and robustness metrics.

7. Significance and Implications

AgentLens advances the methodology for understanding, diagnosing, and steering LLM-powered multi-agent systems. It provides a structured, extensible pipeline for transforming opaque execution logs into interpretable, interactive, and causally grounded behavioral narratives. By encoding agent events as hierarchical summaries and explicit or implicit causal arcs, and by supporting interactive visual analytics across time and agent populations, AgentLens bridges the gap between raw, high-volume system data and research-grade interpretability.

A plausible implication is the foundational role of such infrastructures in both empirical multi-agent research and operational multi-agent deployments as LLMAS and agent-centric information access paradigms scale to millions of heterogeneous, specialized agents (Lu et al., 2024, Kanoulas et al., 26 Feb 2025).