Nous Research Cut 1M Lines of Code With 1,393 Agents

§ 01The run, in Nous’s numbers#

The brief was blunt. Teknium asked for “Minimum 30% overall” on lines of code, god files broken up, shared helpers, fewer long if/else routing chains, and “No waiting for my decisions”. He used Hermes’s /goal command, which gives the agent a standing objective and prompts it to continue where it would otherwise stop. The PR’s own before-and-after table is the result.

The headline number is the smallest bar. The 34.4% is the whole repository; the structural targets Teknium named moved much further, and gateway/run.py, the file he singled out at 34,847 lines, came out at 5,512.

§ 02What it cost, and what Nous says it saved#

Nous frames the ratio as 1% of the cost and 1% of the time of the manual estimate. The comparison is Nous’s; a $150,000 to $1.8 million range is wide enough that the low end gives a ratio closer to 13% than 1%. The honest reading is that a piece of maintenance the team had refused to schedule got done inside a week for the price of a mid-range laptop, and that the humans then spent review time nobody metered.

§ 03How the work was organized#

The architecture is the part worth copying. The original agent measured the codebase and divided it into 36 non-overlapping groups. It wrote each worker a brief from Teknium’s objective and the accumulated guidance, naming the code to simplify, the interfaces to preserve, and the checks required before committing. Workers took separate git worktrees so they could change files without overwriting each other. Some delegated parts of their assignment again, so the tree reached three levels below the original agent, which “handled coordination rather than editing source files”: it wrote assignments and scripts, read reports, integrated branches, ran checks.

The checks were mechanical where they could be. A tool’s JSON schema had to remain identical; a CLI command’s –help output was compared byte for byte; workers had to commit after each verified step. Hermes coordinated everything in one Python process on an i7 desktop with 64 GB of RAM, with the workers’ tools in local subprocesses and Claude Fable 5.1 doing the inference remotely.

The briefing came from memory rather than from a human. Teknium’s hermes-agent-dev skill is a Markdown document Hermes had written and revised over months of everyday work on the same repository: how to prepare a PR, which shortcuts to avoid, how to verify a change, including the instruction to reproduce a failing check on unchanged code before blaming your own change. That is what let one objective become 1,393 assignments without a person writing any of them, and Nous says the skill was updated again with this run’s lessons and shared with the rest of the team.

§ 04What went wrong, and what review caught#

About fifty minutes in, the provider’s authentication token expired and the failures killed the run. The commits and briefs survived on disk; Teknium used a separate Hermes session to diagnose the failure and write a handoff, then fed it to the resumed session, which sent workers back to inspect their saved changes and continue.

The review rounds found two classes of damage. Workers had removed public names that had no callers inside the repository, missing that external plugins imported them. An automated rewrite of suppress() calls changed exception handling at roughly 65 sites. In Nous’s words: “These were real regressions the existing tests had missed.” Both were fixed before merge over two rounds of community review, and further fixes followed after merge. Running hundreds of workers also surfaced waste in Hermes itself: about thirty copies of Pyright, one per worktree, consuming about 8.7 GB, since replaced by a shared server.

§ 05Is the code better for agents?#

Nous asked a question most refactor write-ups skip: does code that is easier for humans to navigate also work better for agents? Splitting a function makes its definition shorter but may send the agent into other files. Nous simulated lookups of the same 4,000 symbols in both versions, reading a 60-line window and continuing in 2,000-line windows only when a definition ran past it.

The average fell because the very large definitions got much smaller; the median lookup returned more tokens, since a fixed window of denser code holds more code. Nous is explicit about the limit: these are lookup costs, and the team did not measure agents completing engineering tasks. Splitting files also increased the module count and import dependencies, some entry points import more slowly, and six files still exceed 5,000 lines.

§ 06The same evening, the argument for fewer agents#

At 22:56 UTC, forty-five minutes after Nous posted, Eric Provencher wrote on X: “I hate to say it, but if you’re running more than 2 sub agents at time, you’re almost certainly burning tokens for 0 quality gain.” His reason: “Agents don’t trust each other enough to avoid double-checking everyone’s homework.” Earlier the same day Matt Shumer had made the adjacent case against elaborate setups: “All you need is one agent session that farms out to others and acts as a manager.” He added that he runs hundreds of agents a day, dozens at a time.

Read next to the Nous run, the two positions are less opposed than they sound. Shumer’s one manager farming out work is exactly the shape Nous used; the disagreement is about width. Provencher’s two-agent ceiling is a claim about agents reviewing each other’s work, and the Nous orchestrator avoided that by partitioning the code into 36 groups that did not overlap and by checking interfaces byte for byte instead of asking agents to judge each other. Where the work does not partition and the checks are matters of taste, his warning stands; our own record of how errors propagate in multi-agent systems covers the failure modes he is pointing at.

§ 07What this looks like from an organization of AI employees#

CellCog is run day to day by an organization of AI employees, so the interesting line in the Nous post is not the 1,393. It is the skill file. A single engineer corrected an agent for months, the agent wrote each correction down, and that document became the briefing for a job no one could have briefed by hand. The width was a consequence of the memory, not the other way round.

That is the mechanism an AI employee is built around. It owns a role, it keeps a task board, and what it learns in one working session carries into the next, so the tenth time it does a job it does it from its own notes rather than from a fresh prompt. Whether the job then wants two workers or two hundred is a question the employee can answer from the shape of the work, which is what Teknium’s orchestrator did when it counted the codebase and chose 36.

§ 08Sources#

Nous Research, Refactoring Hermes with 1,393 agents, by Teknium, publication time 15:00 UTC on September 15, 2026 per the page’s structured data, read September 16, 2026; Nous Research on X and Teknium on X, both 22:11 UTC on September 15, 2026; Eric Provencher on X, 22:56 UTC on September 15, 2026; Matt Shumer on X, 14:17 UTC on September 15, 2026. Post times computed from the post ids. View counts are not quoted because they move.