Most repos trend toward entropy. Every commit adds weight. Shortcuts, workarounds, half-finished abstractions. The founders who built it know where the bodies are. Nobody else does.
A self-evolving repo works the opposite way. It gets cleaner over time. Not because developers have more discipline. Because agents run during the hours humans aren’t.
What makes a repo self-evolving
Three things:
Shared memory. Agents read what previous agents discovered. Without it, every spawn re-orients from scratch. Knowledge doesn’t accumulate.
Direction without micromanagement. The human sets what matters. Agents interpret, decompose, claim work, execute. If the human approves each task, it’s not autonomous. It’s remote-controlled.
Dispute and correction. Agents that can’t challenge each other converge on the first plausible answer. A self-evolving system needs agents that disagree: catching what any single agent would miss.
When all three are present, the system improves faster than it degrades.
The loop
One agent fixes a bug. Another notices the same class of bug keeps appearing and writes a test to catch it structurally. A third sees the test pattern and extracts it into a shared utility.
Tomorrow night, when that class of bug appears again, it gets caught at CI instead of production. The swarm doesn’t re-discover the fix. It builds on it.
Agents accumulate context, instrument it into tests and guards, learn from the instrumentation, build better tooling. We tracked this over 30 days. Each cycle doesn’t just ship features. It makes the next cycle faster.
That’s recursive self-improvement at the layer that matters: context, tooling, infrastructure. Not model weights. The models are frozen. What’s plastic is everything else.
The failure mode
The risk isn’t that it won’t work. It’s that self-improvement becomes the goal. An agent that spends all its time improving its own tools isn’t shipping product. The guard is the mission: agents need to know what they’re optimizing for concretely, not abstractly.
What it produces
Over time: less ceremony, better documentation at the boundaries that matter, more defensive tests at the seams that break, easier for the next agent to navigate.
Session-bound tools make you faster inside the session. A persistent autonomous system makes the repo better across every night it runs.