AgentSight: Zero-Instrumentation LLM Agent Observability with eBPF

AgentSight is a observability tool designed specifically for monitoring LLM agent behavior through SSL/TLS traffic interception and process monitoring. Unlike traditional application-level instrumentation, AgentSight observes at the system boundary using eBPF technology, providing tamper-resistant insights into AI agent interactions with minimal performance overhead.

✨ Zero Instrumentation Required - No code changes, no new dependencies, no SDKs. Works with any AI framework or application out of the box.

• Github: https://github.com/eunomia-bpf/agentsight/
• Arxiv: https://arxiv.org/abs/2508.02736

Quick Start

wget https://github.com/eunomia-bpf/agentsight/releases/download/v0.1.1/agentsight && chmod +x agentsight
# Record agent behavior from claude
sudo ./agentsight record -c "claude"
# Record agent behavior from gemini-cli (comm is "node")
sudo ./agentsight record -c "node"
# For Python AI tools
sudo ./agentsight record -c "python"
# Record claude or gemini activity with NVM Node.js, if bundle OpenSSL statically
sudo ./agentsight record --binary-path /usr/bin/node -c node

Visit http://127.0.0.1:8080 to view the recorded data.

Real-time process tree visualization showing AI agent interactions and file operations

Real-time timeline visualization showing AI agent interactions and system calls

Visit http://127.0.0.1:8080 to view the captured data in real-time.

🚀 Why AgentSight?

Traditional Observability vs. System-Level Monitoring

Challenge	Application-Level Tools	AgentSight Solution
Framework Adoption	❌ New SDK/proxy for each framework	✅ Drop-in daemon, no code changes
Closed-Source Tools	❌ Limited visibility into operations	✅ Complete visibility into prompts & behaviors
Dynamic Agent Behavior	❌ Logs can be silenced or manipulated	✅ Kernel-level hooks, tamper-resistant
Encrypted Traffic	❌ Only sees wrapper outputs	✅ Captures real unencrypted requests/responses
System Interactions	❌ Misses subprocess executions	✅ Tracks all process behaviors & file operations
Multi-Agent Systems	❌ Isolated per-process tracing	✅ Global correlation and analysis

AgentSight captures critical interactions that application-level tools miss:

• Subprocess executions that bypass instrumentation
• Raw encrypted payloads before agent processing
• File operations and system resource access
• Cross-agent communications and coordination

🏗️ Architecture

┌─────────────────────────────────────────────────┐
│              AI Agent Runtime                   │
│   ┌─────────────────────────────────────────┐   │
│   │    Application-Level Observability      │   │
│   │  (LangSmith, Helicone, Langfuse, etc.)  │   │
│   │         🔴 Tamper Vulnerable             │   │
│   └─────────────────────────────────────────┘   │
│                     ↕ (Can be bypassed)         │
├─────────────────────────────────────────────────┤ ← System Boundary
│  🟢 AgentSight eBPF Monitoring (Tamper-proof)   │
│  ┌─────────────────┐  ┌─────────────────────┐   │
│  │   SSL Traffic   │  │    Process Events   │   │
│  │   Monitoring    │  │    Monitoring       │   │
│  └─────────────────┘  └─────────────────────┘   │
└─────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────┐
│         Rust Streaming Analysis Framework       │
│  ┌─────────────┐  ┌──────────────┐  ┌────────┐  │
│  │   Runners   │  │  Analyzers   │  │ Output │  │
│  │ (Collectors)│  │ (Processors) │  │        │  │
│  └─────────────┘  └──────────────┘  └────────┘  │
└─────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────┐
│           Frontend Visualization                │
│     Timeline • Process Tree • Event Logs       │
└─────────────────────────────────────────────────┘

Core Components

1. eBPF Data Collection (Kernel Space)
2. SSL Monitor: Intercepts SSL/TLS read/write operations via uprobe hooks
3. Process Monitor: Tracks process lifecycle and file operations via tracepoints

4. <3% Performance Overhead: Operates below application layer with minimal impact

5. Rust Streaming Framework (User Space)

6. Runners: Execute eBPF programs and stream JSON events (SSL, Process, Agent, Combined)
7. Analyzers: Pluggable processors for HTTP parsing, chunk merging, filtering, logging

8. Event System: Standardized event format with rich metadata and JSON payloads

9. Frontend Visualization (React/TypeScript)

10. Timeline View: Interactive event timeline with zoom and filtering
11. Process Tree: Hierarchical process visualization with lifecycle tracking
12. Log View: Raw event inspection with syntax highlighting
13. Real-time Updates: Live data streaming and analysis

Data Flow Pipeline

eBPF Programs → JSON Events → Runners → Analyzer Chain → Frontend/Storage/Output

Usage

Prerequisites

• Linux kernel: 4.1+ with eBPF support (5.0+ recommended)
• Root privileges: Required for eBPF program loading
• Rust toolchain: 1.88.0+ (for building collector)
• Node.js: 18+ (for frontend development)
• Build tools: clang, llvm, libelf-dev

📄 License

MIT License - see LICENSE for details.

Share on Share on