Anthropic's managed agent platform Claude Managed Agents (CMA) pushed six incremental updates in one go. Boundaries first: CMA is Anthropic's hosted agent runtime platform, distinct from Claude Code Skills, Record a Skill, and Cowork — don't lump these products together.

Of the six updates, the three with the most practical value for developers are: the per-session skill cap lifted from 20 to 500, the effort reasoning level now writable into each agent's model config, and POST /v1/sessions creating a session with initial_events in one step. Working API payloads below.

✅ Source of facts: This article is based on Anthropic's official developer account @ClaudeDevs (tweet), the official "we just added" posts from developer advocates CJ Avilla and Eric Buess, and the official effort parameter documentation. Other narrative details from the original posts were not verified one by one; this article states only the facts that map to official sources.

The Six Updates at a Glance

Below are the three most worth coding against, with real payloads.

Update 1: Per-Session Skill Cap Lifted from 20 to 500

CMA's Skills are knowledge packages that inject specialized instructions into agents, running in a unified managed sandbox; previously a session could hold at most 20. Now it's 500, shared by all agents within the session.

What does that mean? Before, if you built an enterprise customer-service system, just onboarding the SOPs of the various business lines blew past 20, forcing you to split across sessions or load skills dynamically. Now one session carries the whole enterprise knowledge base.

There's no API change to mounting — you always specified a skill list in the session config; only the cap moved. The key change is architectural: you can pre-mount all your company docs, compliance rules, and product manuals in one shot, eliminating the overhead and complexity of runtime dynamic loading.

Update 2: Five-Level effort Now Written into Per-Agent Config

The effort parameter has existed at the API level for a while, but agents in CMA couldn't set it individually — the whole session ran on one default level. Now it goes into each agent's model config, with five levels: low / medium / high / xhigh / max.

The typical use is tiered dispatch in multi-agent collaboration:

• Triage coordinator: low (simple classification, saves tokens)
• Product Q&A: medium (good enough)
• Complaint escalation: high (needs deeper reasoning)
• Legal & compliance: max (cannot afford errors — max it out)

Per-agent config example (key fields excerpted):

{
  "agents": {
    "triage": {
      "model": "claude-...",
      "model_config": {
        "effort": "low"
      }
    },
    "complaints": {
      "model": "claude-...",
      "model_config": {
        "effort": "high"
      }
    },
    "legal": {
      "model": "claude-...",
      "model_config": {
        "effort": "max"
      }
    }
  }
}

For the complete field structure, defer to the official effort documentation.

Update 3: One-Step Seeded Session Creation (with initial_events)

Cold start was one of CMA's most-complained-about pain points: creating a session used to take two steps — first POST /v1/sessions to build the empty shell, then adding initial events one by one. Now it's one step.

Here's a runnable seeded-session creation payload, carrying initial_events directly in POST /v1/sessions (up to 50):

curl -X POST https://api.claude.com/v1/sessions \
  -H "Authorization: Bearer $CLAUDE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "agent_01ABC...",
    "initial_events": [
      {
        "type": "user_message",
        "content": "Current user status: enterprise plan, ample quota remaining."
      },
      {
        "type": "system_context",
        "content": "Restrict all replies to the SaaS billing domain."
      }
    ]
  }'

💡 Tip: initial_events caps at 50. What goes in is "the context a session should open with" — identity, permission boundaries, domain constraints — not chat history. Mixing in a lot of history slows the cold start.

Update 4: Sub-Agent Streaming Drills Down to Thread Level

In late June CMA launched session-level event_deltas (you could see what agents were doing across the whole session). This update drills down to thread level — where each sub-agent stands and what it's thinking mid-flight, all visible in real time.

For a complex workflow with five or six sub-agents hanging off one session, this raises observability's resolution from "session" to "thread." When debugging multi-agent orchestration, you can pinpoint exactly which sub-agent stalled or answered wrong.

Update 5: 7 New Webhooks

CMA already shipped webhooks for agent and deployment lifecycles in late June. This update fills in the other two big blocks:

• 4 environment events (environment lifecycle)
• 3 memory storage events (memory storage)

Seven new event types in total. The practical significance: polling can retire. You used to loop-poll to learn when an agent entered a new environment or when a memory write completed; now everything is event-driven — just wire up a webhook receiver. For exact event names, defer to the official webhook documentation.

Update 6: version Field Now Optional on the Agent Update Endpoint

The version field on the agent update endpoint went from required to optional.

For a continuously iterating agent (instructions updated frequently in a CI/CD pipeline), this means no more maintaining a version number on every update — one whole block of version-management overhead gone from the pipeline.

Who This Fits

This batch of updates mainly serves teams already building production-grade agents on CMA. If your scenario is:

• Enterprise multi-agent systems (support, risk, compliance) → the 500-skill cap + per-agent effort benefit you most directly
• Cold-start-sensitive real-time applications (finance, support openers) → one-step seeded session creation halves the round trips
• Deep debugging of multi-agent orchestration → thread-level streaming events are a must-have
• Event-driven architecture → the 7 new webhooks can kill most of your polling code

If you haven't touched CMA yet, run the minimal demo first via the official Anthropic documentation, then come back to these six updates — what problems they solve will be much clearer.