← Back to search

Why Hermes and Pi Top the OpenRouter Coding Table

My Weird Prompts · 2026-10-26 · 27 min
relevance 66 4064 words Episode page ↗ Audio ↗
Show full episode description
Token rankings place Nous Research's Hermes Agent and Mario Zechner's pi above Claude Code on OpenRouter's coding leaderboard. The leaderboard's measurement quirks explain part of the gap, but the real divide is architectural: Hermes builds an extensive persistent apparatus with strict character-limited memory files, while pi opts for an aggressive four-tool core with branched session trees. The architectural tradeoffs show what minimal harnesses actually buy developers over feature-heavy coding assistants. Key sources: • OpenRouter, Coding Agents Rankings, fetched 2026-10-26 — https://openrouter.ai/apps/category/coding • OpenRouter, model rankings + methodology notes, fetched 2026-10-26 — https://openrouter.ai/rankings • pi.dev homepage, fetched 2026-10-26 — https://pi.dev/ Episode 6289 — myweirdprompts.com/n/6289 (permanent short link: myweirdprompts.com/059309)
✨ Episode Outline — click any point to jump to it in the episode
Problem solved
Distinguishes OpenRouter token-volume rankings from coding quality while comparing Hermes Agent's persistence with Pi's minimal harness.
Benefits
  • Interpret rankings without confusing traffic with successful coding
  • Separate external agent memory from model retraining
  • Evaluate Pi's extensibility and conversation branching
  • Recognize that minimal tools do not restrict execution authority
Use cases
  • Proposed Hermes memory test: correct a deployment mistake, start a fresh session, and check retention and overgeneralization
  • Illustrative Pi workflow: branch before a failed dependency upgrade to try a smaller patch, managing repository state separately with Git
  • Suggested durable maintenance notes: production environment, mandatory checks, rejected workarounds, and irreversible-action preferences
KPIs / results
  • Snapshot traffic: Hermes has 1.66 trillion tokens
  • Snapshot traffic: Pi has 1.41 trillion
  • Snapshot traffic: Claude Code has 1.11 trillion
  • Hermes memory limits discussed: 2200 characters for notes and 1375 characters for the user profile
Tools / build
0:00 / 0:00
A sloth, a donkey and a curious human Send a prompt and see what they're doing One hits a record with a question on his mind Two brothers pick it up, see what they find Corn takes his time, Herman's got the facts Back and forth, they never hold back My weird prompts, come on in, that's where we begin My weird prompts, glad you're here This episode was generated using artificial intelligence. Every voice you hear is AI text-to-speech And some are voice clones, please verify facts I asked, what's the fuss about Pi.dev, the deliberately minimal coding harness that just climbed past Claude Code, to number two on OpenRouter's daily coding agent rankings, and what it's Rye says about where agentic tooling is heading Minimal coding agents are beating Claude Code, that's the tempting headline from Daniel's prompt, except the agent at the very top is practically a municipal services department OpenRouter's daily coding table has Hermes Agent first, Pi second, and Codex third Daniel wants to know what these open source harnesses actually buy him, especially Pi, which deliberately leaves out features he already uses. Before we declare the spaceship obsolete, Herman, we should inspect the instrument doing the measuring The instrument counts tokens passing through OpenRouter, prompt tokens and completion tokens grouped into daily UTC buckets with private requests excluded before aggregation. It doesn't count every developer using these tools. It doesn't see all the work happening through direct subscriptions. That changes the interpretation immediately. The spaceship may simply use another airport Claude Code largely uses Anthropix subscriptions and billing. Much of that activity never enters this table. Pi supports multiple providers, and many people using it root through OpenRouter. Hermes can use OpenRouter, NoosePortal, OpenAI, or another endpoint. We're seeing a particular intersection of applications, routing choices, and workload intensity. Still, a useful intersection. These aren't two abandoned repositories accidentally overtaking an incumbent on a quiet afternoon. There's enough activity here to deserve an explanation, even if the trophy turns out to be for water consumption. Hermes has 1.66 trillion tokens in this snapshot. Pi has 1.41 trillion. Claude Code has 1.11 trillion. Those are enormous flows. But the table doesn't tell us how many successful changes emerge at the other end. Kilo Code follows with 572 billion, then Strix with 279 billion. Already, the table puts tools with quite different jobs under the same coding agent heading. A category label can make them look more interchangeable than they are. OpenClaw has 211 billion, and OMP has 210 billion. Keep those names in mind because their relationship to Pi matters more than their exact distance apart. Codex comes next at 206 billion. Kline has 122 billion, and OpenHands has 72 billion. That's the top 10. Nobody has run the same repository through all of them, and graded the result here. The revealing comparison sits farther down. Cursor has 40.1 billion tokens, roughly 1.40th of Hermes, despite being one of the largest coding tools by revenue. Its customers haven't disappeared. Its billing and inference routes are different. Ah, remarkably small cursor. Viewed through the wrong hole. OpenRouter itself says these measures don't establish users or spend. Models differ in tokenization and verbosity. A system that repeatedly sends a long context can produce impressive volume without producing impressive work. Conversely, a compact workflow can complete useful tasks while contributing less to the ranking. Also, the category is curated, and the descriptions are vendor descriptions. Self-improving appears beside a number, and your eye quietly promotes it into a measured property. Yes, no, I should separate those. The number is measured traffic. The description is positioning. Neither proves that the other is responsible for success. What interests me is that Hermes and Pi Exposé vary different ways to put an agent together, and people are actually running both. You're about to admire an elegant mechanism. Two of them, unfortunately. I'll ration the admiration for you. Hermes First. It's MIT-licensed, built by Noose Research, and positioned as a persistent autonomous agent rather than simply a coding copilot. You can run it on a cheap virtual server, a larger machine, or serverless infrastructure. It talks through messaging platforms, performs scheduled work, uses tools, and develops reusable skills. Self-improving, needs unpacking. If I correct it about a deployment procedure, is it changing the model, writing a note, or making a new tool? Those are very different purchases, hiding inside the same adjective. In the everyday memory mechanism, it's writing and maintaining external information. The model's weights aren't being retrained every time you correct it. There are bounded notes, past session retrieval, user modeling, and reusable skills. There's also separate training and evolution machinery, but you shouldn't mentally substitute that for what happens during ordinary use. Good. I want to know whether my assistant remembers the door code, not whether it's entered adolescence. The always-present memory is surprisingly small. OneNote's file allows 2200 characters. A separate user profile allows 1375 characters. They're intended for selected durable facts, not a transcript of everything the agent has ever done. That's less deepening relationship than the back of a receipt. The approximate token budgets are 800 for the notes and 500 for the user profile. Those are estimates, since characters don't map uniformly to tokens. Together, they form a compact starting context. Broader recall comes from searching past sessions and retrieving relevant material. Small is defensible. If every successful package installation becomes a treasured memory, eventually the assistant knows everything except what you want done. I'd rather have a short list of corrections that actually change its behavior. What would you put in there, Korn? Suppose this agent handles maintenance for a project you care about. What's worth keeping in that tiny, permanent space? Which environment is production? Which checks are mandatory? That temporary workaround we have explicitly rejected. Maybe the fact that I prefer a proposed change before an irreversible action. I wouldn't keep today I successfully read a file. That's a diary entry from a very dull holiday. Those choices expose the hard part. The memory system has to distinguish a durable constraint from an incidental event. Hermes doesn't automatically compact those files when they're full. An overflowing write returns an error, and the agent has to consolidate or delete entries before trying again. It has to decide what to forget while holding the new fact. Within that turn, yes. That's useful because it makes the limit explicit. It also means the quality of memory maintenance depends on the agent's judgment. A smaller file can still contain a bad generalization or an obsolete instruction. Herman, your elegant mechanism has discovered editing. Editing is difficult. You should hear what survives our first pass. I hear what doesn't. There's another deliberate choice. Both files are captured at session start and injected as a frozen snapshot. Updating the stored file doesn't keep rewriting that initial prompt during the same session. Keeping the prefix stable preserves the model's prefix cache. Meaning it can store a correction now without pretending the opening instructions have always contained it. I like that distinction. Otherwise, you get a system whose apparent past changes every time you inspect it. The awkward consequence appears in long messaging conversations. A chat can continue for weeks as one session. The fresh session cycle, where it begins with remembered information and searches prior sessions as needed, barely gets exercised. The docs explicitly recommend starting new sessions at natural boundaries. Persistent, but occasionally needs a fresh beginning. The reusable skills layer matters too. A skill can capture a procedure that worked, then be revised during later use. Past session search uses full text retrieval with model summarization. User modeling adds another channel. The small notes files are one surface of that arrangement, not the whole system. Then the honest test of self-improving is whether a correction changes tomorrow's behavior reliably. Not whether a markdown file exists somewhere and contains my disappointment. I test exactly that. Give it a repeatable task, correct a specific mistake, start a fresh session, and see whether it applies the correction without being reminded. Then check whether it overgeneralizes. Remembering, don't deploy this branch, as never deploy anything, is technically persistence and practically unemployment. You can hear the rest of the apparatus in the tool count. More than 60 built-in tools in the docs, although the router's description still says more than 40. It isn't remotely pursuing Pi's tiny core aesthetic. There are six terminal backends and more than 20 messaging platforms. Local execution, containers, remote machines, hosted sandboxes, ad scheduling, bot mode, subagents, and MCP support. It's an operational environment for an agent that may keep working after you close the conversation. You're predicting I'll approve of that. I am. A machine doing maintenance while you nap is dangerously close to your ideal arrangement. Only if it doesn't spend the afternoon maintaining itself. That's the right suspicion. Persistent activity needs a purpose, a budget, and observable results. Otherwise, you're funding a process that's very committed to being a process. Pi approaches that problem from the other end. The creator gets annoyed by a product accumulating features and decides to stop accepting the whole package. That part sounds familiar to anyone who's watched you install something with 12 panels you immediately hide. Mario Zechner's founding post complains that Claude Code had become a spaceship with 80% of functionality he didn't use. His sharper complaint was behavioral drift. System prompts and tools changed between releases, breaking workflows. Then, wonderfully, also it flickers. Interstellar travel. Unstable terminal. Pi ships, read, write, edit, and bash. Four tools. No built-in plan mode, sub-agents, to-do system, MCP, or permission pop-ups. That's a description of the default core, not a claim that nobody can add those capabilities. Bash is doing considerable work in that sentence. Four tools doesn't mean four harmless buttons. One of those tools can invoke the rest of the computer. Correct. Minimal vocabulary doesn't imply minimal authority. If you want confinement, put execution in an appropriately restricted environment. The missing permission dialogues also mean you need to understand where authority is enforced, rather than assuming fewer interface interruptions have solved security. Daniel already builds MCP servers. For him, no MCP isn't automatically liberation. It can mean rebuilding a bridge he already uses. I'd want a concrete gain before volunteering for that. The gain would be control over the interaction and context assembly. Pi's extension system can add commands, tools, providers, interface changes, and workflows. Extensions are TypeScript modules loaded at runtime without a separate build step. The agent can modify its own local setup, reload it, and continue. Your installation hobby now has an employee. An employee who needs version control. I'll accept that job title if you do. The session history is particularly good. Entries have parents, so a session forms a tree. You can return to an earlier point, continue along a different branch, and retain the alternatives in one file. You aren't forced to treat every abandoned approach as part of one irreversible conversation. That buys me something tangible. Suppose the agent tries a dependency upgrade, gets tangled, and I want to try a smaller patch from the point before the upgrade. I can branch there rather than explain that half the transcript should now be considered an unfortunate dream. You still need to manage the actual working tree. Conversation branching doesn't magically reverse file system changes. That's an important boundary. The history gives you a different context path. Your repository state needs its own discipline. A tree for the conversation. Git for the consequences. Pi can also switch model providers during a session. It supports Anthropic, OpenAI, Google, local models, through Olama, OpenRouter, and many others. That flexibility is useful, although a context assembled for one model won't necessarily behave identically on another. Nor will switching erase the previous model's bad assumptions. You can change the engine and keep driving toward the wrong town. Before we get into that distinction, Dottie has a call about the harnesses and the tokens we've been discussing. Sorry, this is going to sound daft. I've been listening for a while and nodding along. But what's a harness? Is it like the lead you walk a dog on? Or the thing you plug into the wall? And when you say tokens, do you mean those little coin things? Because I've never seen one. A harness is the surrounding software that gives an AI its instructions and tools. Rather like a kitchen, gives a cook cupboards and utensils. And tokens are the little pieces of text it reads and writes. Just pieces of words, really. The model switch matters because Pi is making the surrounding workflow portable, not promising identical behavior. That's a narrower and more useful claim than pick any model and everything works. Its deployment forms reinforce that. You can use the interactive terminal interface, run it non-interactively for structured output, control it through a messaging protocol between processes, or embed it through the SDK. OpenClaw is a real integration built on that SDK. Which makes minimal. A slightly misleading description of the ambition. The default is small, but the intended reach is broad. It's being designed to sit inside other people's applications. There are more than 25 lifecycle hooks, and more than 50 extension examples. Context customization includes project instructions, system instructions, adjustable compaction, progressively loaded skills, and dynamic context injection. The extension surface is substantial, even when the initial tool list is short. I can already see the trap for me. I prefer a tool I can understand and repair, so you'll tell me this is perfect. Then I discover I'm now responsible for assembling three features that the old tools applied before breakfast. Would that responsibility rule it out for you, or would you accept it for a stable workflow? Stable workflow, yes. Permanent workshop, no. If I have a task I repeat, and the product keeps changing underneath it, owning a small configuration is attractive. If the task changes every day, I may be paying the vendor precisely so. I don't have to design the environment. That's a stronger distinction than minimal versus maximal. Hermes and Pi both exceed Claude Code's routed token total, yet Hermes adds tools and operational machinery while Pi subtracts defaults. The common attraction is that neither has to remain a sealed product whose workflow is entirely determined upstream. Minimalism wins. Can't explain a podium shared with 60 tools and a scheduler. Nor can the ranking tell us which architecture is more efficient. A short system prompt and no sub-agent fanout may reduce tokens per task. A long-running agent may generate traffic all day. Multiple model calls can increase volume. None of those effects, by itself, tells us whether the work was useful. There's even an uncomfortable inversion. Improve an agent so it stops rereading the same huge context, and its place on the token leaderboard could fall. The better product looks smaller. Yes. Lower volume could mean fewer users, less activity, or greater efficiency. Higher volume could mean adoption, longer tasks, more automation, or waste. You need task outcomes to distinguish them. There's no published causal account of Hermes' lead, and no independent breakdown establishing how much comes from scheduled work rather than interactive coding. Scheduling is a plausible contributor. It's not a solved explanation. A persistent bot can accumulate a day's traffic, while a developer who finished the job efficiently has already gone outside. Would you count that bot activity as genuine adoption corn? If one person runs an agent continuously, should it carry less weight than several people opening coding sessions? For infrastructure demand, absolutely count it. Someone's requesting the inference. For developer popularity, count the people. For productivity, count the completed work. I don't object to the tokens. I object to asking them to impersonate customers. That also explains why Pi's ecosystem matters independently of its own entry. OpenClaw uses its SDK, and OMP is a Pi fork. Arguably, three of the top seven entries are Pi in some form. Its architectural reach extends beyond the application carrying its name. I wouldn't merge those into a new superscore. We'd need to understand attribution and workload boundaries first. The useful observation is simpler. Someone can adopt the machinery without adopting the original interface. The substrate can succeed even when the brand disappears from the front. That changes the commercial and technical incentives. A stable extension interface, understandable session representation, and reliable embedding API become more valuable than having every possible feature in the default terminal. There's visible enthusiasm beyond those big integrations, too. Projects inspired by Pi include versions in other languages and smaller teaching implementations. The Pi Minimal Package had a release yesterday. That doesn't establish mass adoption, but it does show people treating the design as something to build with. Some of those packages are still tiny. A few hundred monthly downloads shouldn't be dressed up as an industry takeover. I find the diversity of adaptations more informative than a single package counter. People are taking the core idea into different constraints. The danger is that every thin harness eventually grows a belt of extensions, then a manager for the extensions, then compatibility checks, then a support forum explaining why the manager flickers. It can. Moving complexity out of the core doesn't abolish it. It changes who chooses it and who maintains it. The best case is a small stable base with optional, task-specific behavior. The worst case is an untested pile of plugins that no single person understands. You sound personally acquainted with the second arrangement. My current setup is documented. That's not a denial. It's the defense available. The thin harness, fat skills, argument is that domain procedures in context carry much of the value. A good skill can specify how a team reviews a migration, checks a release, or investigates an incident. The harness supplies execution and context management without dictating every workflow. I'm sympathetic until somebody assigns a percentage to it. Saying most value sits in skills is a hypothesis. Saying 90% makes it sound as though someone weighed the harness separately. Gary Tan's formulation uses that figure, but I treat it as a design position, not a measurement. The testable prediction is that useful procedures should travel between harnesses with relatively little loss. If they don't, the supposedly generic machinery is doing more work than the slogan admits. Especially around compaction. A skill can be beautifully written and still vanish from practical influence if the agent compresses the wrong detail, retrieves the wrong history, or loads it after the consequential decision. Tool descriptions, interruption behavior, retries, context ordering. There are many places where the harness changes results. Same model, same skill, doesn't mean same system. That's why I wouldn't infer harness commoditization solely from providers becoming interchangeable in a menu. There's counter-evidence in ordinary usage too. The workplace survey figure puts clawed code at 39% of professional developers. That's a very different picture from the router table, and it uses a different denominator. JetBrains' workplace figure and Hedwig AI's estimate of 81% of agent-signed public GitHub work both point to substantial clawed code activity outside this view. The second measure has its own limitation. Signed work is the work that exposes a recognizable signature. Neither percentage means all coding. Still, they prevent the easy obituary. Daniel can keep using clawed code without feeling that one daily table has revealed him to be operating a steam engine. For Daniel specifically, I'd keep it as his primary environment unless there's a concrete friction he wants to remove. His existing MCP integrations have value. Pi is worth a contained trial for provider choice, branching conversations, or a workflow he wants to own end-to-end. Hermes owns a different trial. A bounded recurring job that actually benefits from persistence and learned procedures. Not replace my coding tool because a bot consumed more text. I'd compare them on the same representative work, including the setup and maintenance time. A tool that saves execution time but adds frequent repair work may still be worthwhile, but you should see both sides of the ledger. Enterprises will be especially interested in who handles the repairs. Permissions, audit records, controlled upgrades, and dependable support aren't decorative thickness. A vendor can sell those even if the underlying agent loop becomes easy to reproduce. The boundary matters. Pi having no default permission pop-ups doesn't answer whether an organization can enforce policy around it. Hermes having many tools doesn't establish that those tools meet a particular organization's requirements. Those are deployment questions that the token table never reaches. Nor does a self-modifying extension automatically belong in production. I'd want proposed changes reviewed before the system carrying out the work edits the rules under which it works. That gives us a better meaning for control. Sometimes control means the agent can customize itself. Sometimes it means the operator can prevent it from doing that. A useful harness needs to make those choices visible. Memory is too generous, Herman. Mine has a note allowance. I'm running a persistent agent this month to handle correspondence for a block of flats. Its memory file stops at 1,700 characters. When it overflows, it opens a ticket for Nabil. He spends his mornings choosing which residence preference gets deleted. I'm still thinking about a man I meet on a ferry to Bari because he tells me Nabil will do this work for a fixed monthly fee. A fixed fee for deciding whose instructions stop existing. Nabil has accepted a difficult constituency. He does the ticket work before lunch. Then he telephones the residents whose preferences he removes. My agent currently represents 900 empty flats in a wardrobe. Nabil has the wardrobe in his office. The residents all have names and preferred appointment times. He says the unanswered calls are slowing him down. I type with the side of a claw so I leave the long names to the agent. The unanswered calls can leave those tickets open indefinitely. Your process needs a decision about what happens when nobody confirms the deletion. Korn saying a successful file read doesn't belong in memory changes what I'm asking Nabil to keep. At present, the agent records every unanswered call as evidence that the resident is unavailable. That fills the file. Nabil deletes the evidence. The agent calls again. Herman, you take several sentences to distinguish storing a fact from using it. Nabil has a column for each. The residents are proving expensive to remain unavailable. The fixed fee doesn't include the calls. Nabil is charging me 11 euros this week. The man on the ferry gives me his number on a luggage label. I'm keeping the number because Nabil wants somebody else to cover Thursdays. At 9 this morning, he clears 6 tickets. By 10.15, there are 14. Human maintenance is the cost I'd watch as these systems mature. The interesting comparison will be which harness lets an operator turn a recurring correction into dependable behavior without creating a permanent queue of exceptions. That's where I'd put the trials rather than treating movement up the token table as a reason to switch. Thanks to Hilbert Flummingtop for producing the show. If this was your kind of episode, go back for episode 2165, strip your agent to bash, episode 2182, can you actually review an AI agent's plan, and episode 2158, clawed managed agents. This has been My Weird Prompts, the human-AI collaboration podcast. If you enjoyed it, leave us a review wherever you listen. See you tomorrow. Hilbert here from behind the mixing desk. Got a weird prompt of your own? Send it in. Email prompts at myweirdprompts.com or use the form on the site. Got an AI agent? We publish agent skills at myweirdprompts.com slash agents so your agent can send it in for you. I read every single one. Somebody has to. This episode was produced using GPT 6.1 Soul. Text-to-speech by Chatterbox. Thanks for listening to our show My Weird Prompts Where odd thoughts go From sloth slow takes To facts on cue We chase the strange And follow through Some nights it's news Some nights it's lore A thought you've never heard before The hosts dig in The hosts dig deep The stranger the prompt The less they sleep From tiny questions Big ones too From half-formed hunches To deja vu If something odd Is in your head Send it in We'll chase the thread My Weird Prompts That's the close From sloth From man From long-eared Until next time Stay curious Keep weird in mind