I posted two screenshots last week. One said "Claude Opus 4.8 is so smart." The other said "Ok. Anthropic team definitely cooked with it." That was the whole caption. Here is what was on the screen and why I reacted that way.
Both shots show the same thing: a parallel fan out. Rather than one model answering one question, a coordinator spins up a row of independent agents, gives each one a slice of the problem, runs them at once, and sends their findings through a final pass that reconciles them.
What I Was Actually Running
The first screenshot is a performance audit of an iOS app. The codebase covers about a hundred files, too many to hold and reason about carefully in one pass. Instead of one agent skimming all of it, I split the app by performance surface: the main scroll and render hot path, the image cache and prefetch layer, the state observation layer, the map and gallery, and the AI/onboarding views. Five agents can only read, each owns one surface, and each produces a report in the same format. Then I synthesize.
The second screenshot is bigger: a security and performance audit across an app's whole API surface: the admin endpoints, the data delivery, the cloud functions proxy, the web client, and the iOS networking. Eleven agents in the audit phase, then a verification phase where findings get attacked adversarially before anything is trusted, then a synthesis. The counter in the corner read fourteen of eighty-two agents when I grabbed the shot.
Why This Felt Different
I have been running setups with multiple agents for a while. Parallel work was already possible. The difference is that the agents stopped dropping things.
Each one runs with a very large context window, so it can hold an entire subsystem in view: every file in its surface, the conventions, and the related call sites. It can work with them together instead of paging pieces in and out and losing the thread halfway through. The reports come back specific. They cite real lines. They understand why the code is shaped the way it is before they suggest changing it.
The synthesis at the end actually reconciles. When two agents disagree, or one finds a bug that another's fix would reintroduce, the merge step catches it instead of stapling the reports together. That used to be the part I had to do by hand. Now I mostly check that it did it right.
That is the moment that earned the screenshot. It was not a benchmark. It was the feeling of kicking off a piece of work that would have taken a real team a day, watching the row of agents light up, and getting back something I would have been happy to receive from people.
The Honest Part
I do not pretend this is magic. The agents are only as good as the scoping. If I hand them a vague surface, I get vague reports. They need explicit boundaries. This file, not that one. Otherwise they collide. The verification phase exists precisely because a finding that sounds confident is sometimes wrong. The adversarial pass is there to kill the plausible but false ones before they reach me. I still read everything. I still make the calls.
But the floor moved. The work that used to need me sitting in the loop, nudging, prompting again, and catching dropped context now mostly runs. I set the shape, it executes, I review.
What This Means for a Company of One
I have written before about replacing a team of five with one tool. The honest update is that it no longer feels like one tool doing the work of five people. It feels like one model that is good enough to coordinate a team of itself. It can split a job across a dozen copies, keep them from stepping on each other, and pull the results back into something coherent.
That is a strange thing to have on a laptop. A solo founder with, functionally, a reviewing department, an audit department, and a synthesis lead. All the same underlying model, all running in parallel, all done before lunch.
So yeah. They cooked.