OpenClaw Session Analyzer — A "Session X-Ray" for Agentic Tooling

The "Competition" Excuse… and the Real Reason

I'll be honest: I built this because Myles had already submitted his competition entry and I wasn't about to let more time slip by without shipping something myself.

But the real reason is more practical:

"If you use agentic tooling long enough, you eventually ask the same question: 'Is this predictable… or am I one bad run away from lighting money on fire?'"

Session logs contain the answer. The problem is that reading raw JSONL is like trying to understand your finances by staring at bank statement bytes.

So I built a lens.

What It Does (In Plain English)

You upload your session JSONL files and the app gives you:

• Token usage over time (including cumulative growth)
• Cost estimates (using configurable pricing)
• Latency breakdowns (distributions and slow-turn detection)
• Model / provider / role mix (what's actually generating the spend)
• Turn-level drilldowns so you can find outliers
• Exports (CSV/JSON) so you can keep the data or graph it elsewhere

And because it's client-side, this is the "long tail" friendly version: most people aren't running Open Claw at massive scale. They just want answers without setting up a pipeline.

The First Surprise: My "Average Tokens Per Turn" Was Obscene

I expected some waste. I didn't expect a crime scene.

My peak for a single turn hit about 250,000.

Let that sink in. 40k tokens per turn isn't "chatting." That's "I accidentally strapped a leaf blower to my context window."

And the 250k spike? That's the kind of single turn that makes you open the billing dashboard the way you open a credit card statement after a Vegas weekend.

Why This Matters

Most cost blowups aren't mysterious. They're structural:

• Tool calls dumping huge payloads back into the conversation
• Context that never gets compacted
• Retrieval that keeps re-inserting giant chunks
• Agents looping with increasingly bloated state

The problem is you don't feel it while it's happening. You just feel "the system got slower" or "this seems expensive."

Logs don't lie.

When you can see which turn spiked, which model did it, how latency changed, and whether context was ramping… you stop guessing. You start fixing.

"Everything Happens Locally" Was the Design Constraint

This was non-negotiable.

I wanted something I'd personally use without hesitation—which means:

• No backend
• No uploads to a server I control
• No database
• No account
• No keys

Just: open the app, upload JSONLs, see the truth, close tab.

That constraint also makes it easier for other people to try. If you're worried about your data (you should be), you don't have to trust me.

How I Built It (The Real Workflow)

I had the idea while driving home and decided I'd ship something fast rather than "plan" it to death.

I tossed it onto Vercel, let ChatGPT 5.2 generate the first pass, and then I tweaked the parts that mattered—structure, UX, the specific breakdowns I wanted, and the little sharp edges you only notice when you run your own logs through it.

This is one of those projects where speed matters more than perfection. The first version doesn't need to be everything. It just needs to be useful.

And it was.

What I'll Add Next

The obvious next feature is what I'd call a Blowup Inspector:

• Show the top outlier turns by tokens / cost / latency
• Highlight what changed from the previous turn
• Tag likely causes (huge tool output, runaway retrieval, no compaction, etc.)

Because once you see a 250k token spike, the next question is: "What exactly caused that, and how do I prevent it?"

If You Use Open Claw, You Should Run This Once

Even if you never open it again, it's worth doing a single "health scan" of your sessions:

• Do you have outlier turns?
• Is context trending upward without bound?
• Is a specific tool or pattern doing most of the damage?
• Are you paying for behavior you didn't intend?

If you do, you can fix it. If you don't, you can relax. Either way, you stop guessing.