Anthropic's UltraPlan Turns Claude Into a Planning Engine

Anthropic quietly released something that might actually matter for how people build with AI assistants. It's called UltraPlan, and it lives inside Claude Code as a cloud-based planning mode that tries to solve a problem I've watched developers bang their heads against for months: the planning phase.

Here's the setup. You're building something—doesn't matter if it's an automation workflow or an actual app. You have an idea of what you want. You write a prompt. Claude does... something. Maybe it's right. Maybe it's not. You iterate. Repeat. Eventually you get there, but you've spent half your time debugging things that could've been caught earlier.

UltraPlan is Anthropic's attempt to front-load that mess. Instead of Claude executing tasks locally and hoping for the best, you type one command—literally just "UltraPlan"—and it offloads the planning work to the cloud. Claude builds out a detailed task plan, generates a session URL, and you review everything in a web interface before any code gets written.

How It Actually Works

The workflow is almost aggressively simple. Type "UltraPlan" in Claude Code. Get a URL. Open it in your browser. Look at the plan. Comment on it. Approve it. Run it.

What makes this interesting—and I say this as someone who's watched a lot of AI tools promise simplicity and deliver configuration hell—is that it actually seems to be that simple. No setup. No API keys to manage. Just a command and a URL.

The web interface itself is where things get more nuanced. You're not staring at a wall of text hoping you catch errors. You can highlight individual steps, add comments like "this doesn't account for edge case X," approve parts of the plan while flagging others. If you're working with a team, you share the URL and everyone reviews it before anything gets built.

That last bit matters more than it sounds like it does. How many times have you had a developer tell you what they're about to build, you nod along, and then the final product is... not quite what you meant? UltraPlan makes the plan itself a reviewable artifact. Non-technical people can actually see what's about to happen and push back early.

The Variant System

Here's where it gets technically interesting. Anthropic isn't giving everyone the same planning experience. They've built what they call "server-controlled variants"—different types of plans depending on your task and account.

The simple variant is straightforward: clean, step-by-step task breakdown. The visual variant gives you diagrams (ASCII or Mermaid format) so you can actually see architecture and flow. And then there's the deep multi-agent variant.

This one's the outlier. Julian Goldie (the creator of the source video) describes it like this: "This is where Claude spins up multiple agents. They all analyze your task. They critique each other's outputs. And you get a final plan that identifies risks, edge cases, dependencies, things that could break."

The multi-agent approach isn't new—we've seen it in AutoGPT, MetaGPT, and various research projects. What's new is having it baked into a production tool with a clean UX. The agents critique each other's outputs and surface risks you wouldn't catch with a single pass. Things like "if the user skips step two, the personalization logic fails—add a null check."

That's the kind of issue that normally takes two hours of debugging to find. Having it flagged pre-implementation is legitimately useful.

Speed Claims and Real Use Cases

Anthropic claims UltraPlan runs up to 2x faster than local planning. I'm always skeptical of benchmark claims (2x faster than what baseline? under what conditions?), but the premise makes sense. Cloud-based planning can parallelize work in ways local execution can't. Whether that translates to actual 2x speedups in real-world use is something we'll need more data on.

Goldie walks through a practical example: building an automated onboarding flow for new members. Multiple integrations, conditional logic, personalization based on user input. The kind of thing where you'd normally write a big prompt, hope Claude interprets it correctly, and spend time fixing whatever it gets wrong.

With UltraPlan, he describes the task, gets a detailed plan back with steps like "build member intake logic," "trigger onboarding sequence via API," "set up fallback logic for incomplete profiles." The multi-agent variant adds a risk section identifying where things could break.

Another use case that stood out: dependency upgrades and auditing. Anyone who's upgraded a major dependency in a codebase knows this pain. Things break in unexpected ways. Libraries change. Functions get deprecated. You upgrade one thing and three other things stop working.

UltraPlan can map out every dependency, check for conflicts, flag breaking changes, and show you the order to upgrade things in. The multi-agent variant critiques the plan and looks for edge cases. It's not magic—you still need to understand what you're doing—but it's a structured process instead of chaos.

The Cloud Evolution Play

The detail that actually has me thinking about where this goes: Anthropic controls which variant you get server-side. You might get a visual plan today. Tomorrow you might get a fully autonomous multi-agent critique. They're A/B testing in production.

This is how cloud-based AI tools evolve now. The model gets smarter. The planning engine improves. You don't update anything on your end—you just get better outputs over time. That's either really convenient or slightly unsettling depending on how you feel about black-box improvements.

It also means we don't really know what "UltraPlan" will mean in three months. The feature as described today might be totally different by summer. That flexibility is powerful for Anthropic (they can iterate fast) but makes it harder to evaluate as a tool. What are we actually assessing—the current implementation or the concept?

Who This Is Actually For

Goldie emphasizes that this isn't just for developers, and I think he's half right. Non-technical people can use UltraPlan to review plans before they're implemented, which increases transparency. If you're working with a developer or using Claude Code for no-code-adjacent tasks (building automations, writing scripts), you can actually see what's being planned before it runs.

But let's be real: to get value from this, you need enough technical literacy to evaluate whether a plan makes sense. You don't need to write code, but you need to understand logic flow, dependencies, and edge cases. That's not nothing.

For actual developers, this is one of the more thoughtful planning tools I've seen shipped recently. The fact that it's native to Claude Code, activated by one command, with cloud offloading and web-based review—that's a proper workflow integration, not a bolted-on feature.

What We Don't Know Yet

We don't know how the variant selection actually works. Is it based on task complexity? Account tier? Random A/B testing? Anthropic hasn't published details.

We don't know what the accuracy rates look like for the multi-agent risk detection. Does it actually catch the things that would've broken, or does it flag false positives?

We don't know how this pricing scales. Goldie mentions it's available on "20X Max" accounts, but we don't have clear documentation on which plans get what access.

And we don't know what happens when the plan is wrong. The whole value proposition is "review before you build," but if you're not technical enough to spot errors in the plan, you're back to the same problem—just earlier in the process.

The server-controlled variants mean Anthropic is still figuring out what UltraPlan should be. That makes it hard to evaluate definitively. Right now it's promising. Whether it becomes essential depends on how those variants evolve and whether the multi-agent planning actually delivers on its accuracy promise.

For now, if you're building with Claude Code and you haven't tried typing "UltraPlan" yet, you probably should. At minimum, it's an interesting look at where AI-assisted development tooling might be headed—less "execute and hope," more "plan, review, then build."

—Yuki Okonkwo