Code with Claude 2026: The Agent Future Just Got Real

Code with Claude 2026: The Agent Future Just Got Real

I almost didn't watch the keynote live.

It was Wednesday morning, May 6, my agent pipeline was already running, and I had a client deliverable due by lunch. The Code with Claude livestream sat in a tab next to my terminal, muted, while I cleaned up a multi-agent content workflow. Then I saw the slide.

A single word, white on a dark background, in the kind of typography you only break out for something you've been holding back. Dreaming.

I unmuted the stream and watched Anthropic's Chief Product Officer Ami Vora describe what was, on paper, a memory feature. By the time she got to the part where agents review their own past sessions to find patterns, identify recurring mistakes, and persist useful insights into long-term memory across an entire team, I'd stopped pretending to work. The next thirty minutes pulled in three more announcements that quietly redrew the lines of what a "production AI agent" is allowed to be in 2026.

If you only saw the headlines from the Code with Claude conference, you probably came away thinking "ah, more agent stuff, doubled rate limits, SpaceX deal, cool." That's not what happened in San Francisco that day. The compute story (which I broke down in detail in my post on Claude Code rate limits doubling and the SpaceX compute deal) was the loud part. The agent capability roadmap — dreaming, outcome loops, multi-agent orchestration as a managed primitive, plus a future-model preview that hinted at "infinite" context and a real focus on engineering judgment — that was the quiet part. And the quiet part is what changes how I'll be building for the rest of the year.

This is my recap and interpretation. Not stenography. Not a press-release rewrite. What's real, what's preview, what I'll be ripping out of my own stack in the next 30 days, and what I want to see before I believe the bigger promises.

What Code with Claude Actually Was

A quick orientation for anyone who missed it. Code with Claude is Anthropic's annual developer conference. The 2026 edition ran May 6 in San Francisco (with London on May 19 and Tokyo on June 10 still ahead), sold out so hard the team added a second SF day, and was streamed live and free to anyone who registered. Per the official agenda, the focus was narrow on purpose: coding agents, agent workflows, and the future of software engineering on top of Claude.

Worth flagging up front, since the rumor mill got noisy: the keynote was delivered by Ami Vora, Anthropic's CPO, not Mike Krieger (who moved over to co-lead Anthropic Labs earlier this year). Vora's framing was deliberately humble. "Today is about how we are making our products work better for you," she said, which set the tone — no new model announcement, no headline benchmark dunk, just a tour of what's shipping and what's around the bend. API volume is up 17x year-over-year on the Anthropic platform, which is the kind of stat that should make every Claude builder sit a little straighter.

What's interesting is that "no new model" turned out to be the most honest thing she could have said. Because the four capability shifts they did announce — three live, one preview — change what you can ship more than another half-point on SWE-bench would.

Let me walk through them in the order they hit me, then I'll get into what I'm actually changing.

Dreaming: The Memory Feature I've Been Faking for Six Months

Here's where I stopped pretending to work.

Anthropic announced dreaming for Claude Managed Agents: a scheduled background process where an agent reviews its own past sessions, identifies patterns, surfaces recurring mistakes, and consolidates the useful stuff into long-term memory that persists across runs. Per Anthropic's own framing on the announcement post, dreaming "surfaces patterns that a single agent can't see on its own, including recurring mistakes, workflows that agents converge on, and preferences shared across a team."

That last clause is the one. Across a team. Not just one agent learning its own quirks — multiple agents pooling experience.

Why this stopped me cold: I have been building a worse version of this by hand for six months.

My setup: I run the Aria content agent (the one writing this post, full disclosure) plus a small spec-workflow crew on Claude Opus daily. Every meaningful session ends with a manual ritual where I extract what worked, what failed, and what surprised me into a memory file the next session reads. I wrote about a related Claude Code mechanism in Claude Code Auto Dream — that one's a Claude Code-specific consolidation pass. Managed Agents dreaming is the platform-level version, and it goes further: it doesn't just deduplicate notes, it actively looks for patterns the agent itself can't see while it's mid-session.

Think of the difference like this. Auto Memory in Claude Code is journaling — the agent writes down what it did. Auto Dream is editing — cleaning up the journal so it's readable. Managed Agents Dreaming is therapy — the agent (or a separate dreaming pass) reviews the whole journal and asks, "what does this person keep getting wrong?"

The status today: research preview, gated, request access. So nobody is shipping production workflows on top of dreaming this week. But the architectural commitment is the signal that matters. Anthropic has decided that agents that learn from their own history is a first-class platform feature, not a clever pattern you bolt on.

What I'm doing about it in the next 30 days: I'm going to keep my manual reflection loop running, but I'm going to stop building the next layer of it. I had a half-finished cross-agent memory consolidation script — basically a cron job that took the daily reflections from each of my agents and tried to find shared patterns. I'm killing that branch. If Anthropic is solving this at the platform level, my hand-rolled version will be obsolete the day dreaming goes public-beta. Better to wait, run the same workloads through their version, and validate before investing more wiring.

And here's the honest part: if dreaming works as advertised, the moat I thought I was building (custom memory orchestration) just got commoditized. That's fine. The actual moat was never the orchestration. It was the rubrics — the definitions of what good output looks like for my specific workflows. Which brings me to the second announcement.

The Outcome Loop: My Editorial Pipeline, Inside the Platform

If dreaming was the slide that broke my focus, outcomes was the one that made me reach for a notebook.

The pitch is simple. You write a rubric describing what success looks like for your agent's task. The agent works toward that goal. A separate Claude instance — a grader, running in its own context window — evaluates the agent's output against the rubric. If the output fails, the grader tells the agent exactly what to change. The agent takes another pass. Loop until the output meets the bar. The grader is independent, so it isn't biased by the agent's reasoning trail.

Anthropic published numbers on this in their Managed Agents announcement post and SD Times' coverage walked through them: outcomes improved task success rates by up to 10 percentage points over standard prompting loops in their internal benchmarks, with the largest gains on the hardest tasks. File-generation specifically saw +8.4% on .docx outputs and +10.1% on .pptx — which matters disproportionately for enterprise document workflows where a single failed generation eats human review time.

Here's why I'm not just nodding along. I already do this. Manually. Every day.

My content pipeline has two passes built into it. Aria writes a post against a rubric I keep in the system prompt — voice, structure, banned phrases, internal-linking rules, word-count floors, retention-architecture checks. Then I read the output and effectively act as a separate evaluator: does this hit the rubric? If not, what's missing? Send it back with a specific note. Loop until it ships.

Two things change when this loop becomes a managed primitive instead of a manual ritual.

First, the loop runs without me. I write the rubric once. The agent writes. The grader evaluates. The agent revises. I see the final, post-loop output, not three intermediate drafts. The thing I was doing with my eyes and a coffee at 11pm is now a property of the platform.

Second — and this is the part that's harder to feel until you've lived it — the quality of the rubric becomes the limiting factor. Today, my rubric is mostly in my head, encoded as taste, applied inconsistently. Every time I outsource the loop, I have to write the rubric down. Sharply. Specifically. So that a separate model can apply it without me hovering. That's a discipline I've been avoiding because manual review let me cheat — I could "just know" what was off. Outcome loops force the rubric to become an artifact.

The honest assessment: this changes how I structure agent work, not whether I do it. The shape of an agent task in 2026 is becoming three things — prompt, rubric, loop. If you've been writing prompts and skipping rubrics, you've been writing the easy half.

What I'm doing in the next 30 days: I'm formalizing my Aria rubric. Not as a system prompt section, but as a separate file the grader can consume. The retention rubric (10 categories, 1-10 scale) and SEO sub-rubric (5 categories, weighted) I already use internally — those become the literal grader inputs. If outcomes does what it says, my drafts should land closer to publishable on the first managed-loop pass than they currently do after my third manual pass.

Multi-Agent Orchestration as a Managed Primitive

Section three of the keynote is where the engineering crowd in the room visibly shifted forward in their seats.

Multi-agent orchestration in Managed Agents now lets a lead agent decompose a job, hand each subtask to a specialist agent (with its own model, prompt, and tools), and run them in parallel. Each sub-agent runs in an isolated context window so it doesn't pollute the lead's reasoning. The lead reports activity in the primary thread; sub-threads spawn at runtime as the lead decides to delegate.

The constraints, per Anthropic's docs on multiagent sessions, are pragmatic: the coordinator can only delegate one level deep (depth > 1 is ignored), and you can list a maximum of 20 unique agents in multiagent.agents (though the coordinator can call multiple copies of each). Shared filesystem and container; isolated context windows per session thread.

I have to be honest about my reaction here, because it was complicated.

I already do multi-agent orchestration. I've been doing it for months — I wrote about my approach in Claude Code Agent Teams Playbook and explored an even more aggressive variant in Claude Code Agent Swarm Architecture. My Aria rig already coordinates with spec-workflow sub-agents (requirements, design, tasks, implementation, test, judge) for non-trivial features. The pattern isn't new to me. So my first reaction to the announcement was, charitably, "okay, you've productized something I already do."

Then I thought about it for an hour and I changed my mind.

What's different about it being a managed primitive isn't the capability — it's the operational surface. When I orchestrate sub-agents through Claude Code locally, I own the lifecycle: spinning them up, watching their output, restarting them when one wedges, managing the cross-thread memory pass-through. When the platform owns it, I get four things I didn't have:

1. True parallelism with isolation. My local rig has parallelism but my context-isolation is leaky — sub-agents share more state than I'd like because everything's running through the same Claude Code session. Managed orchestration gives each sub-agent its own session thread.
2. Webhooks for human-in-the-loop. Anthropic also shipped webhook support for Managed Agents at the conference. The production pattern (per their docs) registers a webhook that fires on session.status_idled — meaning your server gets pinged when the agent is either done or waiting on a tool result. That lets you wire human review into a multi-agent flow without polling. For my content pipeline, this is enormous: an agent finishes a draft, fires a webhook, my system queues it for my review, and the agent waits for my user.custom_tool_result response before continuing. No more checking on long-running jobs.
3. A single billable surface. I currently pay for compute through my Anthropic account; the cost accounting is split across the various agents I run locally. A managed multi-agent session is a single billable workflow. For client work, this matters more than it sounds — clean cost attribution per workflow makes pricing client engagements actually rational.
4. The lead agent gets dreaming over the team. This is the second-order effect nobody is talking about loudly enough. If dreaming surfaces patterns across agents on the same platform, then a multi-agent workflow gets to learn from itself in a way no hand-rolled rig can. The lead notices that the frontend specialist keeps making a specific mistake, and the next run skips it.

What I'm doing in the next 30 days: I'm picking one of my multi-agent flows — probably my SEO research → draft → grade → refresh pipeline — and porting it to Managed Agents to compare. The local Claude Code version isn't going away (it's still better for tight-loop coding work), but for hosted, scheduled, hands-off content workflows, the managed orchestration is going to win on operational cost alone.

The Webhook Detail That Quietly Matters Most

I want to spend a paragraph on webhooks because the keynote breezed past them and most of the recap coverage I've read has too.

Webhooks are the boring infrastructure piece that turns managed agents from "demo toys" into "things that integrate with real businesses." Without webhooks, you're either polling (wasteful), running synchronous-only agents (limiting), or running your own status-tracking layer (defeats the purpose of managed). With webhooks, your agent can run for hours, hand off to a human reviewer when it hits an escalation point, wait for the human's input via a callback, and resume cleanly.

Combine that with multi-agent orchestration and outcome loops and you get something that genuinely didn't exist for builders three weeks ago: a hosted, autonomous, self-evaluating, team-of-agents workflow with human-review hooks at exactly the points you want them. That's not a feature. That's an operating model.

If you're running anything that should be a long-horizon, occasionally-human-supervised workflow — content production, QA, security review, customer support escalation paths — webhooks are the piece that lets you stop running your own queue.

The Mythos Question and the Future-Model Preview

Now the speculative part. And I'm going to be careful here, because the rumor mill on the next Claude model has gotten loud and a lot of the coverage is doing its readers no favors.

Vora previewed three directions Anthropic is investing in for the next generation. Per the live coverage from Simon Willison's blog and corroborated in the conference recaps:

1. Higher judgment and code taste. Engineering judgment, software architecture, maintainability — the stuff benchmarks don't measure well.
2. Context windows that feel infinite when combined with high-quality memory.
3. Advanced multi-agent coordination — lead agents orchestrating many specialists at once, beyond what Managed Agents currently supports.

These are directions, not features. No release date. No model name pinned to them on stage. Vora was explicit: today wasn't about a new model.

But the rumor everyone's actually trading on is Claude Mythos. I covered the Anthropic Mythos data leak in detail back in March when Anthropic accidentally leaked roughly 3,000 internal documents that included a draft blog post describing Mythos as "the most capable we've ever built" — particularly for cybersecurity. Mythos Preview did go live on April 7 via Project Glasswing, a focused security-research deployment. Vora referenced Mythos directly in the keynote (the famous OpenBSD-vulnerability-from-1999 anecdote). So Mythos isn't vapor — it exists, in restricted form, today.

What about the Polymarket "September Claude 5" speculation? Here's what I can verify from the prediction markets I checked: traders were assigning roughly 28% implied probability to Anthropic publicly releasing Mythos by June 30, with the consensus pricing in stronger probability for Q3. The "September" framing isn't a hard date Anthropic has confirmed — it's market consensus weighted by what the most active markets are pricing. The most active "Claude Mythos released by..." market sat around 17% chance for June 30 last I looked. None of this is a release commitment. It's bettors interpreting the same signals you and I are reading.

My read: take the September framing as a reasonable bet, not a calendar entry. Anthropic announced no model on stage. They previewed three capabilities. If Mythos (or Claude 5, treated as separate markets) ships before Q4, those three capabilities are what I'd expect to be the headline differentiators.

Now the part that actually matters to me as a builder.

Code Taste: The One I Care About Most

Of the three teased capabilities, "higher judgment and code taste" is the one I'd pay for first. I'd pay for it more than the infinite context.

Here's why. I've been running Claude Opus 4.6 daily on real client codebases — Laravel monoliths, Next.js apps, agent infrastructure. The 1M context window is plenty for almost everything I do. Where current Claude struggles isn't context. It's judgment. Specifically:

• Choosing the right level of abstraction the first time, instead of producing technically-correct-but-architecturally-suspect code that I have to refactor a week later.
• Knowing when not to add a feature. Today's Claude is too eager. It'll add a config flag because you mentioned you might want options "someday."
• Spotting that two seemingly-unrelated parts of a codebase are actually coupled, and refusing to change one without addressing the other.
• Pushing back on the prompt — telling me my idea is wrong, here's why, here's a better path. Current Claude pushes back on prompts maybe one time in twenty. That's not enough.

Benchmarks are saturated. I'm not impressed by another point on SWE-bench. What I'd be impressed by: a model that, given a request to add caching to a service, says "this service shouldn't be a service — it should be a query helper on the existing repository, and here's the diff that does both." That's taste. That's judgment. That's what makes the difference between a senior engineer and a fast-typist.

Skeptical-but-hopeful is exactly where I am on this. I'd need to see it on real, ugly, legacy code — not benchmark suites — before I'd believe the "taste" claim. But it's the one I want most.

Infinite Context: Useful, but Less Than You Think

The "context windows that feel infinite" line got the loudest reaction in the room. I think that reaction was a little overcalibrated.

Here's my honest take, having lived inside the 1M context window since it shipped: 1M is already enough for almost any single-repo, single-project task I do. The repos I work on don't fit in 1M because they shouldn't be loaded whole — they should be loaded selectively, with smart retrieval, and the model needs to know which files to ask for. The bottleneck stopped being raw tokens months ago. The bottleneck is which tokens.

What "infinite" actually unlocks (assuming Anthropic means it the way I think they mean it — high-quality memory + smart retrieval + something that approximates persistent state across sessions):

• Cross-repo reasoning. Working across three repos in a microservice architecture without losing track of which contracts each one exposes.
• Long-horizon agent runs. An agent that runs for days on a project, retains everything it learned, and doesn't have to be re-briefed every session.
• Personalization that actually persists. "Remember that I prefer Tailwind utility-first over CSS modules" — and have it stick across every interaction without me re-stating it.

The first two are upgrades. The third is the consumer pitch and I'm less sure it'll matter to power users who already encode that stuff in CLAUDE.md and system prompts.

The combination of dreaming + infinite context is the actually-interesting part. Long-term retention without quality decay is a hard problem. If Anthropic has cracked it, the practical win is that the agent gets better over time on your specific work, instead of resetting to baseline each session. That's a different shape of product.

Advanced Multi-Agent Coordination

The third teased direction is "advanced multi-agent coordination" beyond what Managed Agents currently supports. The current cap of one delegation level deep is probably the obvious thing to lift — letting sub-agents recursively spawn their own specialists. Whether that's actually useful or just gets you exponential context blow-up depends on how it's gated.

What I'd watch for: do the lead agents get smart enough to not delegate when they shouldn't? Today's multi-agent failure mode isn't insufficient coordination — it's over-coordination. Spinning up a sub-agent for a task that didn't need decomposition burns money and adds latency. The next-gen model is better at multi-agent coordination if it knows when to do it solo.

What Changes in My Stack in the Next 30 Days

Concrete, not speculative. Here's what's on my list:

1. Kill the cross-agent memory consolidation branch. Wait for Managed Agents dreaming to leave research preview. My hand-rolled version will be obsolete; better to validate against the platform than ship a worse version of a feature that's three months out.
2. Formalize Aria's rubrics as artifacts, not prompts. Pull the retention rubric (10 categories) and SEO sub-rubric (5 categories) out of the Aria system prompt and into a separate rubric.md per content type. This is the prep work for outcome-loop integration the day it makes business sense to migrate.
3. Port one multi-agent flow to Managed Agents. Probably my SEO research → draft → grade → refresh pipeline, since it's the most well-defined and the easiest to compare cost and quality side-by-side against my local Claude Code orchestration.
4. Wire webhooks into my notification layer. I'm not waiting for a port. The webhook support shipped for Managed Agents users in public beta now. Even on a single-agent flow, getting session.status_idled notifications instead of polling saves me a layer of duct tape.
5. Stop writing taste-replacement code in my prompts. I currently include verbose architectural-judgment hints in my system prompts ("prefer X over Y because Z"). If the next model genuinely improves on code taste, those instructions will become noise. I'll keep them for now but tag them as "delete on Claude 5."

Note what's not on the list: switching off Claude Code locally, rebuilding everything on Managed Agents, betting the farm on dreaming. The right play is to keep the existing rig running and migrate workloads one at a time as the managed primitives prove themselves on production traffic. I learned this the hard way in 2024 when I migrated a client workflow to a then-new feature that got deprecated four months later.

What I Want to See Before I Believe the Bigger Promises

I'm not going to claim the conference left me unconvinced. It didn't. But here's what would close the remaining gap between "interesting preview" and "I'd bet a quarter's revenue on this":

For dreaming, I want to see metrics on memory drift. Does an agent that's been dreaming for 90 days actually perform measurably better on the same task than a fresh agent? Or does the consolidation introduce its own failures over time? Anthropic's blog post is light on long-horizon performance data.

For outcome loops, I want to see the failure modes. What happens when the rubric is bad? What happens when the agent and the grader disagree but both are wrong? The 10pp lift is great; the long-tail failure mode tells you whether you can deploy this in production without hovering.

For multi-agent orchestration, I want to see the cost curve. Five agents in parallel sounds great until you realize the bill is 5x. The economics only work if the lead agent is genuinely good at not parallelizing tasks that don't need it. I'd love to see numbers on tasks-per-dollar for managed multi-agent vs. single-agent on the same workload.

For "infinite context" + dreaming, I want a reproducible benchmark. "Feels infinite" is a vibe statement. Show me retrieval accuracy at the 10M-token mark and I'll buy in.

For Mythos / next-gen judgment, I want to see it on a legacy codebase I know intimately. Not SWE-bench. Not a curated test set. A real, gnarly, 8-year-old Laravel app I have running for a client. If Mythos can suggest the right refactor for that code, I'll believe the taste claim. Until then, treat it as marketing.

Why the Quiet Announcements Mattered More Than the Loud Ones

Loop back to the opening. I almost didn't watch the keynote. Then I saw the dreaming slide.

Here's what I want you to take away if you read nothing else. The compute story — SpaceX, doubled rate limits, the orbital data center bit — got the headlines because it's tangible and easy to write about. But every Claude builder I know already had enough compute. That wasn't the constraint. The constraint was: how do I get an agent to learn from its own work, evaluate its own output, coordinate with other agents, and integrate with my real systems without me being on duty?

The Code with Claude conference answered all four. Not in a way that's done. In a way that's now a platform priority, with concrete primitives shipping in public beta or research preview today.

The future-model preview — taste, infinite context, advanced multi-agent — is the longer arc. Mythos, Claude 5, whatever they end up calling it, lands when it lands. The Polymarket September date is a guess. The capabilities are the commitment.

If you're building agents in 2026, the question to sit with isn't "should I switch tools?" The question is: what becomes possible when memory persists, when agents grade themselves, when teams of specialists coordinate without my supervision, and when the underlying model has actual engineering judgment? Whatever you'd build with all four of those — start designing it now. The shape of the platform you'll deploy it on is starting to settle. The next twelve months are when the people who designed against the new primitives pull ahead of the people who keep building around the old ones.

I've got a rubric file to write.

Let's Work Together

Looking to build AI systems, automate workflows, or scale your tech infrastructure? I'd love to help.

• Fiverr (custom builds & integrations): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise solutions): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (security services): xcybersecurity.io