I Let Opus 4.8 Hold Its Own Plan. It Scaled, and I Lost the Wheel

The marketing for Opus 4.8 is about a smarter, more honest model. The feature I actually care about is quieter, and it isn't even really new: dynamic workflows, where the plan moves out of the AI's working memory and into a script the AI writes and runs on its own. It took me a full night to understand what it changes.

The test

The cleanest way to show it is the job I used it for: pulling real data off the web. Specifically, find every operating business in a city and verify each one is real.

• The old script way: grab fixed pieces of a page; collapse the moment the structure changes.
• One agent: reads the page the way a person would, doesn't care how it's built, can judge what's on it. But it does one thing at a time.
• The question that actually matters at city scale: who holds the plan?

Until now the answer was Claude itself: it ran the show, holding the plan and every agent's partial result in its own working memory. Fine for a handful of agents. On a big job the memory fills and it loses the thread.

Dynamic workflows move the plan out. You describe the goal; Claude writes the plan as an actual script; a separate engine runs that script in the background. The half-finished results live in the script, not in the model's memory. Only the final answer comes back.

What it earned

For verifying thousands of businesses: worth it. ~90 minutes, a small army of agents running at once, my session free the whole time, and a high-enough confidence level (~70% on my own independent review under strict rules). Three things genuinely landed:

• Scale — it runs many agents on one job instead of a handful.
• No drift — the plan lives in code, so it doesn't get lost the way a long conversation does. A resumable run saved the job more than once when the work got disrupted.
• Built-in fact-checking — independent agents review each other's work. Because they run separately, their mistakes don't line up, so disagreement is how you catch errors. (I've argued for adversarial review of LLM output before; this bakes it in.)

Why the verdict is MIXED, not PASS

The trade is real, and it's the whole point:

• Tokens — a single run burns far more than before. That's the AI vendors' business model, not an accident.
• Control — once it starts, you can't step in or intervene.
• Maturity — still a preview; resumable only inside the same session.

So for verifying thousands of businesses, I'd hand over the wheel and pay the bill. For a five-minute task it's overkill, and the tool will happily push it on you anyway.

The shift worth watching isn't that the model got smarter. Models are already capable at plenty of tasks. It's that the orchestration moved into code the AI runs itself, which is where the scale and the savings come from, and where you give up the ability to babysit. The judgment call is no longer "is the output right?" It's "how big does a job have to be before handing over the wheel is worth what it costs?"