45 Code w/ Claude SF 2026: Building on the AI Exponential
45.1 Overview
On May 12, 2026, Anthropic held its annual developer conference — Code w/ Claude SF 2026 — in San Francisco. The event brought together thousands of developers, engineers, and technical leaders for a day of announcements, deep dives, and community building. The theme, “Building on the AI Exponential,” captured the spirit of the moment: the pace of improvement in AI capabilities was not merely fast but exponentially accelerating, and the conference was about giving developers the tools to ride that curve.
The headline announcements were significant. Anthropic doubled Claude Code rate limits and raised Opus API limits, directly addressing the two most common developer pain points: running out of capacity during long coding sessions, and hitting rate limits when building with the most capable model. But the more strategically important announcements were about Managed Agents, where four new features were introduced: Dreaming, Multiagent orchestration, Outcomes, and Webhooks.
This chapter covers the key announcements, the reasoning behind them, and what they meant for developers building on the Claude Platform.
45.2 The Context: Riding the Exponential
The conference opened with a framing that set the tone for everything that followed. The pace of AI improvement, Anthropic argued, was best understood not as linear progress but as an exponential curve — where each improvement built on previous improvements, compounding over time.
The practical implication for developers was profound: anything you build today will be dramatically more capable tomorrow without any change to your code. An agent that takes 10 minutes to complete a task today might take 2 minutes in six months, simply because the underlying models improve. Applications that are marginally useful today become transformative as the curve climbs.
Capability
│
│ ╱
│ ╱
│ ╱ ← We are here (2026)
│ ╱
│ ╱
│ ╱
│ ╱
│ ╱
│ ╱
└──────────────────────────────────► TimeThis framing motivated the conference’s focus: not just on what developers could build today, but on building foundations that would compound as capabilities improved. The Managed Agents features announced at the event were designed with exactly this philosophy — they were infrastructure that would become more valuable as models improved.
45.3 Announcement 1: Doubled Claude Code Rate Limits
The first and most immediately impactful announcement was the doubling of Claude Code rate limits. This directly addressed the most common complaint from the Claude Code community: hitting rate limits during extended coding sessions.
45.3.1 The Problem
Claude Code sessions could run for hours, processing large codebases, running tools, and iterating on solutions. Each action consumed tokens, and the cumulative consumption could exceed rate limits — particularly for users on standard plans. Developers reported the frustration of being in the middle of a complex task and hitting a wall:
“Claude was 90% through a complex refactor and then: ‘Rate limit exceeded. Try again in 47 minutes.’ That’s 47 minutes of lost momentum.”
45.3.2 The Solution
Doubled rate limits meant:
| Metric | Before | After |
|---|---|---|
| Requests per minute | X | 2X |
| Tokens per hour | Y | 2Y |
| Daily token cap | Z | 2Z |
The doubled limits applied to all Claude Code users, with proportional increases for Enterprise customers who had custom limits.
Rate limit increases might seem like a simple capacity expansion, but they represented significant infrastructure investment. Doubling limits meant roughly doubling the peak compute capacity available for Claude Code — requiring Anthropic to provision substantially more inference infrastructure. The investment signaled how central Claude Code had become to Anthropic’s strategy.
45.4 Announcement 2: Raised Opus API Limits
The second announcement addressed API developers building with Claude Opus — the most capable (and most compute-intensive) model. Opus rate limits had been tighter than Sonnet and Haiku, reflecting its higher per-request compute cost. The announcement raised Opus API limits, making it easier to build production applications on the frontier model.
| Model | Limit Change | Impact |
|---|---|---|
| Opus 4.7 | Significantly raised | More production applications can use frontier model |
| Sonnet 4.6 | Maintained (already generous) | No change needed |
| Haiku 4.5 | Maintained (already generous) | No change needed |
This was particularly valuable for applications that required Opus-level reasoning — agentic workflows, complex code generation, multi-step analysis — where falling back to Sonnet would meaningfully degrade quality.
45.5 Announcement 3: New Managed Agents Features
The most strategically significant announcements were four new Managed Agents features. Each addressed a specific limitation of the initial Managed Agents release and opened new categories of use cases.
45.5.1 Feature 1: Dreaming
Dreaming was perhaps the most novel announcement. It introduced scheduled review of agent sessions — a process where an agent periodically reviewed its own past sessions to extract insights, identify patterns, and improve future performance.
The concept was inspired by the cognitive science theory that sleep and dreaming play a role in memory consolidation and learning. Applied to agents, “dreaming” meant:
Regular operation:
Agent executes tasks → Results delivered
With Dreaming:
Agent executes tasks → Results delivered
│
│ (scheduled interval, e.g., daily)
▼
Dreaming session:
1. Review recent sessions
2. Identify patterns (successes, failures)
3. Extract reusable insights
4. Update internal knowledge
5. Improve future task execution# Configuring a Dreaming schedule
agent = managed_agents.create(
name="research-agent",
model="claude-opus-4-7",
dreaming={
"enabled": True,
"schedule": "0 2 * * *", # Daily at 2 AM
"review_window": "24h", # Review last 24 hours
"insight_types": [
"successful_strategies",
"failure_patterns",
"tool_usage_optimizations",
],
}
)Dreaming was particularly valuable for long-running agents that accumulated many sessions over time. Without dreaming, each session was independent — the agent started fresh every time. With dreaming, the agent learned from experience, becoming more effective over time. This was a step toward agents that improved with use, not just with model updates.
45.5.2 Feature 2: Multiagent Orchestration
Multiagent orchestration introduced the ability for a Managed Agent to spawn and coordinate specialist subagents. Rather than a single agent handling every aspect of a complex task, a lead agent could decompose the task and delegate subtasks to specialized agents.
┌─────────────────┐
│ Lead Agent │
│ (Coordinator) │
└───────┬─────────┘
│ decomposes task
┌───────────────┼───────────────┐
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Specialist 1 │ │ Specialist 2 │ │ Specialist 3 │
│ (Research) │ │ (Code Gen) │ │ (Testing) │
└──────┬───────┘ └──────┬───────┘ └──────┬───────┘
│ │ │
└────────────────┼────────────────┘
│
▼
┌───────────────┐
│ Lead Agent │
│ (Synthesizes)│
└───────────────┘This pattern — a lead agent orchestrating specialist subagents — was powerful for complex tasks that required different types of expertise:
- Software project: Lead agent decomposes into research (subagent 1), implementation (subagent 2), testing (subagent 3).
- Market analysis: Lead agent decomposes into data gathering (subagent 1), analysis (subagent 2), report writing (subagent 3).
- Incident response: Lead agent decomposes into diagnosis (subagent 1), fix implementation (subagent 2), communication (subagent 3).
# Multiagent orchestration configuration
agent = managed_agents.create(
name="project-agent",
model="claude-opus-4-7",
orchestration={
"enabled": True,
"specialists": [
{
"name": "researcher",
"model": "claude-sonnet-4-6",
"tools": ["web_search", "web_fetch"],
},
{
"name": "coder",
"model": "claude-opus-4-7",
"tools": ["file_read", "file_write", "bash"],
},
{
"name": "tester",
"model": "claude-sonnet-4-6",
"tools": ["file_read", "bash"],
},
],
}
)45.5.3 Feature 3: Outcomes
Outcomes introduced rubric-based self-evaluation for Managed Agents. Rather than simply completing a task and returning the result, agents could evaluate their own output against defined criteria — and iterate until the output met the standard.
The feature was called “Outcomes” because it shifted the focus from tasks (what the agent did) to outcomes (whether the result was good enough).
# Outcome rubric configuration
agent:
outcomes:
enabled: true
rubrics:
- name: "code_quality"
criteria:
- "Code follows project style guide"
- "No obvious security vulnerabilities"
- "Includes appropriate error handling"
- "Tests cover main code paths"
threshold: 0.85 # Must score 85% or higher
max_iterations: 3 # Retry up to 3 times
- name: "completeness"
criteria:
- "All requirements from the task are addressed"
- "Edge cases are handled"
- "Documentation is included"
threshold: 0.90Anthropic reported that Outcome-based self-evaluation could deliver up to a 10-point improvement in output quality, as measured by human evaluators. The agent caught its own mistakes and iterated before presenting the final result.
The “up to 10-point improvement” figure was significant. In many domains, a 10-point quality improvement (on a 100-point scale) was the difference between “acceptable” and “excellent.” By having agents self-evaluate against rubrics, the floor of output quality was raised substantially.
45.5.4 Feature 4: Webhooks
Webhooks made Managed Agents event-driven, capable of notifying external systems when significant events occurred. This transformed Managed Agents from poll-based (you check if it’s done) to push-based (it tells you when it’s done).
# Webhook configuration
agent = managed_agents.create(
name="monitor-agent",
webhooks=[
{
"event": "task.completed",
"url": "https://api.contoso.com/webhooks/agent-complete",
"headers": {"Authorization": "Bearer ${WEBHOOK_SECRET}"},
},
{
"event": "task.failed",
"url": "https://api.contoso.com/webhooks/agent-failed",
},
{
"event": "outcome.below_threshold",
"url": "https://api.contoso.com/webhooks/agent-quality",
},
]
)Supported webhook events included:
| Event | When It Fires | Use Case |
|---|---|---|
task.completed |
Agent finishes successfully | Trigger downstream processing |
task.failed |
Agent encounters an error | Alert operations team |
outcome.below_threshold |
Self-evaluation below rubric threshold | Quality intervention |
dreaming.insight |
Dreaming session produces an insight | Knowledge base update |
subagent.spawned |
Multiagent orchestration spawns a subagent | Monitoring/tracing |
Webhooks enabled Managed Agents to integrate into event-driven architectures — triggering CI/CD pipelines, updating ticketing systems, notifying Slack channels, or feeding data into analytics platforms — without polling.
45.6 Summary of Announcements
| Announcement | What It Does | Who Benefits |
|---|---|---|
| Doubled Claude Code limits | 2x capacity for coding sessions | All Claude Code users |
| Raised Opus API limits | More capacity for frontier model | API developers |
| Dreaming | Scheduled session review and learning | Long-running agents |
| Multiagent orchestration | Lead + specialist subagents | Complex task automation |
| Outcomes | Rubric-based self-evaluation | Quality-critical applications |
| Webhooks | Event-driven notifications | Integration with external systems |
45.7 The Road Ahead: London and Tokyo
Code w/ Claude SF was the first stop in a global tour. Anthropic announced two additional events:
- Code w/ Claude London — May 20-21, 2026
- Code w/ Claude Tokyo — June 5-6, 2026
Each event would feature region-specific content, local customer stories, and additional announcements (as covered in Chapters 44). The global tour reflected the international nature of Claude’s developer community and Anthropic’s commitment to engaging developers in their own regions.
For developers who couldn’t attend in person, Anthropic made recordings available shortly after each event. The recordings included all sessions, deep dives, and Q&A — ensuring the knowledge shared at the conferences was accessible to the broader community.
45.8 Community and Ecosystem
Beyond the announcements, Code w/ Claude SF 2026 was notable for the energy and maturity of the developer community. Sessions covered:
- Real-world case studies from companies running Claude in production.
- Best practices for agentic coding, context engineering, and security.
- Community-led talks on creative uses of the Claude Platform.
- Hands-on workshops for getting started with new features.
The conference demonstrated that the Claude developer ecosystem had moved well beyond early experimentation into production-grade implementations at scale.
45.9 Key Takeaways
- Code w/ Claude SF 2026 was Anthropic’s annual developer conference, themed “Building on the AI Exponential.”
- Claude Code rate limits were doubled. The most common developer pain point — hitting limits during long sessions — was directly addressed.
- Opus API limits were significantly raised. More production applications can use the frontier model without capacity concerns.
- Dreaming introduces scheduled review of agent sessions, enabling agents to learn from experience and improve over time.
- Multiagent orchestration allows a lead agent to spawn and coordinate specialist subagents, enabling complex task decomposition.
- Outcomes delivers rubric-based self-evaluation with up to a 10-point quality improvement, as agents catch their own mistakes before presenting results.
- Webhooks make Managed Agents event-driven, integrating into CI/CD, ticketing, analytics, and other external systems.
- The announcements reflect exponential thinking. Each feature is designed to compound in value as underlying model capabilities improve.
- A global tour followed: London (May 20-21) and Tokyo (June 5-6), with region-specific content and additional announcements.
- Recordings were made available to the broader community, ensuring the knowledge shared at the conference was accessible to all developers.
- The community has matured from early experimentation to production-grade implementations at enterprise scale.