The bluster of agent swarms writing code
Agent swarm systems produce a lot of code but not much more working software.
There's a lot of talk online, particularly on X, about how people have set up a systems where bots orchestrate N agents to write a ton of code, emitting hundreds or thousands of PRs towards some goal.
The problem that I see with this is that, at the end of the day, there just isn't a whole lot more wonderful software coming out the other end.
The post about making Grok Bot
Lauren Tan is, by all accounts, a genuinely talented software engineer who has built a lot of cool stuff in her career.
She posted about how she (and to an extent the Grok Bot team) ship thousands of PRs a month. The crux of it all is that you can't possibly keep up with all of that code, so you instead build a validation system at a higher level of abstraction, and the "diffs" you review are more about "is this doing what it should?" than the actual code.
This is actually pretty cool once you get past the initial feeling of being uncomfortable with that much code flying around. I've believed myself for a few years now that validation is the bottleneck, and it's actually quite hard, and software teams of the future will build validation systems more than anything else.
The problem is that Grok Bot is just not very good yet:
- A significant drop-off in quality for "at work"-style assistant flows
- All of a user's bots currently share one computer
- Sensitive data leakage (the infamous dude whose bot posted his personal finances to his company slack)
- Many reports of mobile issues, be it general stability or just draining the battery
- Failed or incomplete runs still charge you money
- Tons of examples online of people complaining about having to babysit it through instructions
- Marking things as done when they're not done
FWIW I don't think Grok Bot is especially bad compared to other assistants. I've had nothing but trouble with Muse for really basic stuff as well, and if I think about it for all of ten seconds it's obvious there's very hard problems here.
But what I'm getting at is: thousands of PRs a month doesn't seem to achieve a really great product. I can't help but feel a strong discordance with the excitement around flinging around so much code when the product it's all in service towards just doesn't work very well yet. This is valuing outputs over outcomes all over again.
Anecdotes from work
Things are still very early, but we're trying this too.
The platform I work on has some bugs. About a thousand or so are explicitly filed, with easily another 10k or so hidden and not discovered yet. It is what it is.
You'd think that with a thousand+ legit bugs, many of them related, you could sic a fleet of agents on them and get all the bugs fixed, right?
Well, you can. And many tokens can be burned in the process. And yet, some of the core problems that we care about still seem unsolved weeks later. If you were a user of a client connecting to the platform I work on, you'd still have the same issues that you had about three weeks ago.
Maybe on our end we're just not trying hard enough. I know that our own validation systems aren't good enough and we have much improvement to make on having robust SLOs and other telemetry that we can fully trust and hand off to agents for most things.
But so far, the bottom line hasn't changed much.
The work that counts but doesn't count
Often you'll see some posts claiming how much a fleet of agents helped them accomplish goals that couldn't have been done before:
- Porting a system from one language to another
- Targeted but impressive performance improvements in some dimension
- Hill-climbing on a benchmark or metric to lead the pack
- Re-creating some piece of software that already exists, but slightly different, and with no new approach or system that makes it feel different
All of these are, objectively speaking, impressive pieces of work, and quite valuable just on their own.
And yet, I can't help but feel like these don't really count. In each case, nothing really new is being made. There's often an already clearly-defined metric whose value changing means something unambiguous. Often times, the act of measuring that metric is actually just ... easy. And so that's why it's doable.
The vast, vast majority of software in the world just doesn't work like that. Most business problems don't get solved because you could rewrite a codebase to Rust, improve perf by X%, or prove you can do well on a (typically flawed) benchmark.
Often what's stated for these kinds of efforts is there's so much potential, but what's funny about that is none of these efforts seemed to have realized much of that potential so far.
So far, by my measure, it's all just bluster.