AgentHalo: The Tri-Processor Agentic Benchmark

AgentHalo is a cutting-edge benchmarking suite designed to expose the true hardware bottlenecks of autonomous AI workflows. While legacy AI inference was purely GPU-bound, Agentic AI demands a sophisticated orchestration pipeline that heavily stresses the CPU, NPU, and Unified Memory architectures.

Designed explicitly for ClawRig workstations powered by AMD Strix Halo (Ryzen AI MAX), AgentHalo proves that a balanced, massive-core CPU architecture paired with discrete-class iGPUs (RDNA 3.5) and NPUs (XDNA) over unified LPDDR5X memory is the only way to scale enterprise AI swarms.

🚀 The Three Workloads

AgentHalo runs three distinct paradigms to map hardware utilization:

1. A: The Legacy Chatbot (GPU Bound)
   A standard llama-server inference stream. Proves that old-school prompt-in/answer-out AI leaves powerful CPUs completely idle while starving the GPU.
2. B: The MCP Sandboxed Agent (CPU Orchestration)
   A smolagents loop connects to an official Model Context Protocol (MCP) server via FastAPI/Uvicorn. The agent executes SQLite database tool calls and performs AST-parsed subprocess sandboxing. This visualizes the massive CPU context-switching tax that chokes undersized systems.
3. C: The Swarm Handoff Pipeline (LPDDR5X Bandwidth)
   Simulates a multi-agent pipeline (Router -> Database Agent -> Security Agent). Passing massive LLM context windows between agents proves the necessity of Strix Halo's Unified Memory, eliminating slow PCIe bottlenecks.

🛠 Features

• Official MCP SDK Integration: Native smolagents MCPClient mapping to high-performance async ASGI endpoints.
• Live TUI Dashboard: Real-time hardware telemetry (psutil + drm/sysfs) rendered beautifully via rich.
• Latency Tracking Breakdown: Explicitly tracks Time in Sandbox vs Time in GPU, proving where the actual pipeline delays occur.
• Telemetry Export: Generate raw CSV/JSON dumps of hardware utilization for integration into broader hardware review pipelines (e.g., Phoronix, PugetBench).
• Auto-Scaling Stress Test: Pushes the CPU to 100% by recursively scaling concurrent agent swarms to find the maximum throughput score.

📊 Architectural Schemes

1. The Bottleneck: Legacy vs. Strix Halo Unified Architecture

In legacy systems, passing large context windows between the CPU (doing tool logic) and the GPU (doing inference) requires slow PCIe bus transfers. ClawRig's Strix Halo architecture leverages LPDDR5X Unified Memory, allowing zero-copy handoffs between the NPU, GPU, and CPU.

graph TD
    subgraph Legacy [Legacy AI Box]
        direction TB
        LCPU[Low-Core CPU
Orchestration] -->|PCIe Bottleneck| LGPU[Massive GPU
Inference]
        LGPU --- LVRAM[(GDDR6 VRAM)]
    end
    
    subgraph Strix [ClawRig Strix Halo Architecture]
        direction TB
        Mem[(Massive LPDDR5X Unified Memory)]
        NPU[XDNA NPU<br/>Intent Routing] --- Mem
        GPU[RDNA 3.5 GPU<br/>Heavy Inference] --- Mem
        CPU[Zen 5 CPU Swarm<br/>MCP & Sandboxing] --- Mem
    end

Loading

2. Workload Flow: The Agentic Pipeline

Here is exactly how AgentHalo's Workload C (Swarm Handoff) stresses the Tri-Processor architecture. Notice how the Zen 5 CPU is constantly engaged in IPC (Inter-Process Communication), SQLite DB querying, and isolated Python subprocess execution, preventing the GPU from doing all the work.

sequenceDiagram
    autonumber
    participant NPU as XDNA NPU (Power Efficiency)
    participant GPU as RDNA 3.5 GPU (LLM Inference)
    participant Mem as LPDDR5X (Unified RAM)
    participant CPU as Zen 5 CPU (MCP Sandbox)

    Note over NPU: Always-On Intent Routing
    NPU->>GPU: Wake & Route Request
    
    Note over GPU: Router Agent evaluates request
    GPU->>Mem: Write Context (Zero-Copy)
    Mem->>CPU: Trigger MCP Tool Call
    
    Note over CPU: SQLite Database Joins
    CPU->>Mem: Write Query Results
    Mem->>GPU: Prompt Security Agent
    
    Note over GPU: Security Agent analyzes DB Results
    GPU->>Mem: Write Raw Unsafe Output
    Mem->>CPU: Trigger MCP Security Eval
    
    Note over CPU: AST Parsing & Subprocess Sandbox
    CPU-->>GPU: Sandbox Validation Passed

Loading

📦 Setup & Diagnostics

Requirements: AMD Strix Halo / Ryzen AI Max | Linux (ROCm capable) | Python 3.10+ | llama-server on PATH

python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

Memory Diagnostics: Strix Halo's performance requires correct BIOS UMA/VRAM reservations and Linux TTM limits. AgentHalo includes a built-in diagnostic tool to verify your setup:

python run_poc.py --hardware-check

Model Setup: AgentHalo targets high-efficiency Qwen3.6 instruct models by default:

python download_model.py

🏎 Running the Benchmark

1. The Standard Visual Benchmark

Launch the beautiful 3-panel live dashboard to watch the hardware bottleneck shift in real-time.

python run_poc.py --model-path models/Qwen3.6-27B-Q4_K_M.gguf --concurrency 2

2. Auto-Scaling Stress Test

Bypass the dashboard and recursively launch massive agent swarms (1, 2, 4, 8, 16) until the Strix Halo CPU reaches a hard bottleneck.

python run_poc.py --model-path models/Qwen3.6-27B-Q4_K_M.gguf --stress-test

3. CI/CD Telemetry Export

Dump the hardware profile to raw data formats for external analysis:

python run_poc.py --model-path models/Qwen3.6-27B-Q4_K_M.gguf --export-csv run1.csv --export-json run1.json

---

AgentHalo was built to demonstrate that you can't solve Agentic AI by just buying a bigger GPU. You need a balanced machine. You need ClawRig.