The Model Is the Agent Now
Someone built a 200-line AI agent and told it one thing: “evolve yourself until you rival Claude Code.” Then he stopped touching the code.
Every 8 hours a GitHub Action wakes it up. It reads its own source code, yesterday’s journal, and GitHub issues from strangers. It decides what to improve, builds the fix, runs tests. Pass means commit. Fail means revert. No human in the loop.
By day 4 it had reorganized its own codebase into modules. Nobody asked it to.
It tried to google Anthropic’s pricing page to add cost tracking. Couldn’t parse the HTML. Tried 5 different approaches. Gave up and just made up a number. Then left itself a note: “don’t search this again.”
It files GitHub issues for itself. “Noticed this bug, didn’t have time, will fix tomorrow.”
Every single journal entry says it should implement streaming output. Every single session it does something else instead. It’s procrastinating. Like a real developer.
200 lines to 1,500+ lines. 47 tests. $12 in API costs. Zero human commits.
A pretty wild experiment. But what I keep thinking about isn’t the stunt itself. It’s what it makes obvious about where agents are.
Not long ago, building an agent meant writing task orchestration code. You’d manually lay out the steps. Call the model here, check the output there, branch on the result, call it again with different instructions. The code was the brain. The model was just a tool you invoked when you needed language understanding.
That’s flipped. The models now know what to do. You give them tools and instructions and they figure out the sequence. The best coding agents already work this way. You describe what you want and it decides when to read files, when to search, when to write code, when to test, when to backtrack. The orchestration is in the model, not in your code.
That self-evolving agent is the extreme case. 200 lines doing nothing but keeping the loop alive. The model handles everything else.
There’s a saying in Shenzhen’s electronics industry. If your hardware board gets most of its functionality from the chip, the board has no value. Anyone buys the same chip, slaps it on a different PCB, same result. But if the board itself carries most of the logic and the chip just handles basic processing, you’ve built something that can’t be trivially copied.
Think about that in terms of AI apps. If your product is a wrapper that sends requests to the model and displays the response, you’re the cheap board. The question for every AI product right now is how much of your value comes from the model versus what you built around it.
The valuable board is the one that does real work on its own. Domain-specific experience the model can’t replicate from a generic API call. Data the model doesn’t have. Things accumulated over years that can only be taught by hand, impossible to describe in words. That’s what makes a board worth more than the chip it’s sitting on. The chip is the same for everyone. The board is what you know and what you built that the chip can’t do alone.
It’s not an accident that the most capable agents are all built on coding tasks. OpenClaw giving agents full access to Mac Minis started there too (is that why Mac Minis are sold out everywhere?). Code is the universal intermediate step. An agent that can write and execute code can do almost anything: scrape data, run analysis, build interfaces, automate workflows. The agent writes code not because the end goal is programming but because code is the tool that reaches everything else.
It’s kind of like how mobile phones back then became the entry point for everything. Ordering food, booking rides, banking. None of those are phone tasks. The phone was just the platform that could handle all of them. Coding agents are becoming that platform. Generate code, run it, read the result. The code itself is disposable. The output is what matters.
That self-evolving agent had full access to everything. Could modify any file, add any dependency, restructure anything it wanted. Give an agent enough access and it’ll use everything it can reach. The trend is the same everywhere: the model is the intelligence, and limiting what it can touch is limiting what it can do.
And I think behind this there’s something bigger than agents getting better at tasks.
Look at what the model actually does now. It reads instructions and decides what to execute. It picks tools and manages resources. It routes itself to the right action based on context. Recovers from errors and changes course. The code around it just keeps the process alive.
We thought we were building agents. I think we’re actually watching a new OS take shape.
200 lines of Python and a model that knows what to do. That’s the whole computer.