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
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@observedecorators
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}
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}
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 .
Open http://localhost:3000/dashboard in your browser.
Point your agent at Trooper:
export ANTHROPIC_BASE_URL=http://localhost:3000
That's it. Zero dependencies. Pure Go. Runs in under 60 seconds.
GitHub: github.com/shouvik12/trooper
Tags: llm, agents, observability, ollama, go, opensource
SOCIAL SHARE CARD GENERATOR