DEV Community

Shouvik Palit
Shouvik Palit

Posted on

I Added a Live Dashboard to My LLM Proxy. Zero Instrumentation. Just a URL Change.

#ai #api #llm #showdev

I built Trooper as a fallback proxy. Claude hits quota → falls back to Ollama. Useful but passive. It sat in the background, invisible, doing its job silently.

Today it became something different.

The Original Problem

When you're building with LLMs, quota hits are inevitable. Claude's free tier is generous until it isn't. A mid-session 429 kills your context, your workflow, your train of thought.

Trooper solved that. Point your app at http://localhost:3000 instead of the Claude API. When Claude fails, Trooper catches it, preserves the full session context via a 3-layer compaction system (Anchor + SITREP + Tail), and continues on local Ollama. Your app never knows anything happened.

That's still there. But it was passive. Useful when things broke. Invisible when they didn't.

The Problem With Passive

Passive infrastructure has an adoption problem. Developers install it, forget about it, and only notice it when something breaks. That's not a product — that's a safety net.

The question I kept asking: what does Trooper do that has daily value, not just failure value?

The answer was sitting in the code the whole time.

What Was Already There

Trooper captures every message in every session. It runs a classifier on each one — extracting intent, entities, open loops, completed steps, recent actions. All rule-based, zero LLM calls, zero latency.

This is what powers the fallback context preservation. When Claude fails and Ollama picks up, Ollama doesn't start blind — it receives a SITREP (Situation Report) that tells it what the session was about, what was completed, what's still pending.

That data exists for every session. It was just never visible to the developer.

The Dashboard

I added a live dashboard at localhost:3000/dashboard.

Point any agent at Trooper — just change your base URL:

export ANTHROPIC_BASE_URL=http://localhost:3000
# or
export OPENAI_BASE_URL=http://localhost:3000
Enter fullscreen mode Exit fullscreen mode

Open the dashboard. Keep it on a second monitor while your agent runs.

From a single message, it already shows:

  • Intent — what your agent is trying to do, extracted automatically
  • Open Loops — what it's stuck on, highlighted in red
  • Completed Steps — what it finished, tracked as it happens
  • Entities — the key things being referenced
  • Session Transcript — every message, colour coded by role

Auto-refreshes every 5 seconds. No page reload needed.

What It Looks Like In Practice

I ran a 3-turn agent session simulating a database debugging workflow:

Turn 1: "I am building a Go API server. The database connection is failing with connection refused errors on port 5432."

Turn 2: "Checked the config. Postgres is running on port 5433 not 5432. Fixing the connection string now."

Turn 3: "Fixed the port. Database connection is working. API server is running successfully."

After Turn 1, the dashboard immediately showed:

  • Intent: "building a go api server. the database connection is failing with connection refused errors on port" (100% confidence)
  • Entities: Postgres, network
  • Open Loops: "fail with connection refused error on port"

After Turn 3:

  • Completed Steps: "successfully fixed the port"
  • Open loops cleared

Zero instrumentation. No SDK. No code changes to the agent. Just a URL change.

Why This Matters

Every observability tool requires you to instrument your code:

  • LangSmith — wrap your agent in LangChain
  • Langfuse — add their SDK
  • AgentOps — add @observe decorators

Trooper requires nothing. Your agent already communicates over HTTP to an LLM. Trooper sits in that path and observes everything automatically.

Helicone was the closest — proxy-based, zero instrumentation. But it went into maintenance mode in March 2026 and was cloud-only. Your data went to their servers.

Trooper is open source, local-first, and free forever. Your data never leaves your machine.

The Sessions Endpoint

Not sure which session to look at? Hit /sessions:

curl http://localhost:3000/sessions
# {"sessions":["agent-debug-123","agent-debug-456"],"count":2}
Enter fullscreen mode Exit fullscreen mode

Click any session in the dashboard home page at localhost:3000/dashboard to open it.

The Recovery Endpoint

Still there. When an agent fails mid-task:

curl http://localhost:3000/recovery/{session_id}
Enter fullscreen mode Exit fullscreen mode

Returns exactly what completed and where to resume. The dashboard makes this visual — completed steps are tracked in real time.

The Pivot

Trooper started as: "Claude failed. Trooper caught it."

Trooper is now: "Your agent communicates over HTTP to an LLM. Trooper can observe it."

The fallback is a feature. Observability is the product.

Your agent was always talking. Now you can hear it.

Get Started 

git clone https://github.com/shouvik12/trooper
cd trooper
export CLAUDE_API_KEY=sk-ant-...
go run .
Enter fullscreen mode Exit fullscreen mode

Open http://localhost:3000/dashboard in your browser.

Point your agent at Trooper:

export ANTHROPIC_BASE_URL=http://localhost:3000
Enter fullscreen mode Exit fullscreen mode

That's it. Zero dependencies. Pure Go. Runs in under 60 seconds.

GitHub: github.com/shouvik12/trooper

Tags: llm, agents, observability, ollama, go, opensource

Top comments (0)