gvrnr

A group chat with my friends (agents)

gvrnr is my own app for running coding agents. One Rust engine, up to four Codex, Claude Code or Cursor agents at once, and the whole thing is built around actually reading what they write.

I’ve always found digesting LLM responses tiresome, especially with Opus 5 (thank goodness for Opus 5.5). Overly verbose, lots of fluff, and plenty of pain. I’d frequently find myself asking for a summary of a summary of an explanation’s summarised explanation. This drove me nuts. There had to be a better way.

Alas, what platforms do I use on the daily where I read constantly and type constantly? Well, that’d be chat interfaces! iMessage, Discord, and so on. This isn’t a new solution, as most harnesses already use a chat UI. But I figured I’d take it a step further.

Creating a custom humanisation layer over top of the pre-existing conversation allows for what can often feel like a proper interaction. In the past, skills like ADHD and Caveman were great in concept but poisoned context. This approach is totally separate, so the LLM’s thinking is unaffected!

Thanks to Jev, I can cherry-pick key details from the LLM’s realtime thinking and turn them into text updates, like an actual human texting you updates as they work, rather than a gigantinimanorous wall of text. Important details aren’t lost, and all of it can be skimmed. Here’s a real one. Flip between the full reply and the Brief and feel the difference:

The initial benchmark disagreed with me

My original thinking was that I had to be as fast as possible. Jev launched, I got early access, and I needed to blow some minds. Initially, I figured having an ultra-fast and ultra-cheap model skimming text to optimise unnecessary usage would dramatically cheapen work.

As an added benefit, I began work on my own Tauri harness for maximum performance. I wanted to pair fast with fast.

So I put it to the test: 12 frozen coding tasks with hidden graders, each run three ways (the plain agent, the agent with my own checks, and the agent with Jev). 54 runs in all.

Turns out, the folks working on these models already do that and are quite smart!

The checks added 6 to 11% time for no extra wins. Making the tasks harder until Jev looked useful would have been confirmation bias, and we hate that guy. What actually slowed me down was reading, so that’s what I built for.

Jev didn’t get fired, though. It got a quieter job in the background, keeping an eye out for when an agent wanders off. Here’s what it watches for, acted out (an illustration, not a real run):

The crew

Agents can also bring in helpers. There are 29 of them, each with their own little face and personality. Here are three on one job. Switch someone’s personality off and the facts stay put; only the voice goes.

Charts that can’t lie

The last stretch was components. Agents can drop little widgets into a message: figures, before-and-after bars, checklists, one-tap choices. The catch is they can only use numbers already in the message, so a chart can’t invent a stat the text never mentioned. Same rule as the Brief: the presentation can change, the facts can’t.

Conveniently, OpenAI released Intelligent UI a week after I did this, so I think it was a good idea. Go on, tap a choice:

Still going

The benchmark was right: my agents didn’t need a judge. It was measuring the wrong problem. The real one was reading, and I genuinely think I’m onto something with this text formatting approach.

gvrnr isn’t my daily driver yet, but that’s the goal, so I’ll keep chipping away at it in the background until it is, and share what I find along the way. And fast with fast happened after all, just not how I planned: the Tauri harness stuck around, restoring 5,002 history records in 0.43 ms and launching in 0.70 s.