AI is splitting up the work. I'm more interested in who finishes the job

When I saw that ChatGPT could put several agents to work at once, my first thought was writing for this blog. Checking documentation, finding examples and verifying prices could finally happen in parallel.

Then I thought about the results coming back. Someone still has to read them together. Prices are an obvious trap: one agent finds subscription pricing, another finds API pricing. Put those straight into an article and fluent writing won’t save it.

Add Cursor’s cloud-agent update, Google DeepMind’s Minecraft experiment and Anthropic’s quantum-circuit research, and my question becomes: how much work would these actually save in my own projects?

Research in parallel, then sit down and compare the results

OpenAI’s announcement says GPT-6 Astra Pro in ChatGPT supports parallel agents, with individual progress tracking and completed tasks you can open to review. The announcement explicitly makes it available to Pro users in the Chat tab.

I’d try that for a technical article. One agent reads official documentation, another finds examples, another checks pricing and access conditions. That should be quicker than waiting for one agent to do everything in order.

But I wouldn’t immediately combine their answers into a draft.

The web app and API of the same product can offer different capabilities. A fresh announcement might not yet be reflected in the documentation. Each answer can have a source and still mislead readers when placed beside the others.

So I’d still ask: which version, what date and which region? Only once those line up would I use the material. Research can happen simultaneously; I don’t want to skip that final comparison.

With Cursor, environment management is what I’d like to try

Cursor’s update lets cloud agents build interactive canvases. Finish a dashboard or report, send someone a link, and they can view it. Convenient enough.

For development, though, I’m more interested in the beta Environments API: creating and managing agents’ cloud environments programmatically.

Spending ages on setup before writing any code wears down my patience. The repository is cloned but dependencies aren’t right. The service finally starts, then a missing environment variable turns up. Get it working, switch tasks, and start again.

Agents need those problems solved, too. If repositories, dependencies and test environments can be prepared and reused, at least each task doesn’t have to begin with a conversation about how to start the project.

Cursor says large multi-repository environments load five times faster. I’d read that as less waiting before work begins, not a fivefold improvement in the whole development process.

The repository limit isn’t consistent: the X post says 500, while the changelog and agent-creation API documentation say 300. If I needed that many, I’d plan around the documented 300 and confirm access to a higher limit first.

Four agents playing Minecraft: I’d like to see the handoffs

Google DeepMind’s experiment put four Gemini 4 Argon agents into Minecraft from scratch. They defeated the Ender Dragon after roughly 27 hours.

According to the announcement, they operated through code and text, wrote 2,783 programs, divided jobs over chat, shared notes and debugged together, without humans helping them complete the game tasks.

But the researcher’s full account includes important details. They played on Easy, read their surroundings and acted through Mineflayer, and had a pathfinding plugin. They didn’t see game pixels or use a keyboard and mouse like a human. Researchers could monitor, pause or stop the experiment from a dashboard.

It wasn’t a smooth run, either: 605 respawns, with 22% of programs ending in an error. The log records victory at 27 hours and 14 minutes. “Finished in 27 hours” can hide a lot of retries.

The win is worth watching, but I’m more curious about what happened during those hours.

When one agent finds resources, how does it tell the others enough to save them unnecessary trips? When something goes wrong, who notices and brings everyone back on track?

Development has similar problems. Several agents being able to code doesn’t guarantee they’ll work well together. One changes an interface while another builds a page against the old version. Put them together and it will still break.

For my blog, I’d consider dividing translations by language, or having one agent check links while another checks pages. I’d be much less comfortable with several agents changing styles and routes at once. Each might think its work is finished; the combined result still needs a look.

Before deciding whether this transfers well to real projects, I’d also want repeated-run success rates and the cost of those 27 hours. Without them, I can’t work out whether it’s worthwhile.

Knowing whether the result is right matters more to me

There’s an arrangement I like in Anthropic’s quantum-circuit research: give Claude Mythos 5 circuit specifications and an automated evaluator.

After a design, a program checks correctness and scores “qubit count × gate count.” The model gets the feedback and tries again. Improvement doesn’t depend entirely on the model explaining how well it did.

The report says all eight selected tasks produced designs more resource-efficient than the best previously published approaches. One Reed–Solomon decoder used roughly one-twelfth the gates of Google’s earlier construction. That’s a circuit-design comparison, not a twelvefold speedup of an entire quantum computer. Nor does the research claim no human participation: the point-addition task ran for 53 hours, with an initial brief and occasional human prompts to explore more broadly.

Quantum circuits are far from my daily work, but I need ways to check AI’s results when building a website, too.

If it says a page is fixed, I’d like to see it on a phone. If it says a link is repaired, open it. If it says a release is live, confirm we’re seeing the new version. Having those checks makes it easier to delegate more.

Otherwise, four “finished” messages just mean asking four times: finished where? Show me.

So I’d start these features with a few independent blog tasks. Agree on which files each agent can change and what it should return, then look at the combined work afterward.

I’d like them to finish their parts so I can check and use the result. If I still need four or five conversations open to track down who changed what, I’d rather start with fewer agents.