Claude Managed Agents: Dynamic Workflows & OpenTelemetry

Anthropic officially rolled out two major architectural capabilities for its developer platform: Dynamic Workflows for Claude Managed Agents and native OpenTelemetry (OTel) trace and metric export.

The release directly confronts the twin bottlenecks paralyzing enterprise multi-agent deployments: brittle orchestration logic and the complete absence of standardized runtime observability.

Under the new managed-agents-2026-04-01 beta protocol, a lead Claude model no longer requires hand-crafted finite-state machines or static DAG definitions to coordinate complex operations. Instead, the agent autonomously synthesizes an executable workflow program, spawning and orchestrating up to 1,000 concurrent sub-agents across phased execution trees.

Simultaneously, Anthropic launched native OpenTelemetry export across the Messages API, Claude Managed Agents, and the Claude SDK ecosystem, allowing engineering organizations to pipe live agent spans, token burn rates, and tool invocation graphs directly into Datadog, Grafana, and SigNoz.

1. Dynamic Workflows: From Static DAGs to Autonomous Compilation

Until now, orchestrating multi-agent systems required developers to choose between two imperfect paradigms: hardcoded orchestration graphs (such as LangGraph or AutoGen) that break when edge cases deviate from predefined paths, or unconstrained autonomous loops that suffer from compounding reasoning drift and infinite recursion.

┌─────────────────────────────────────────────────────────────────────────────┐
│             Claude Managed Agents: Dynamic Workflow Engine                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   [High-Level Objective] (e.g. "Audit 450 Microservices for CVE-2026-8812") │
│                                │                                            │
│                                ▼                                            │
│   ┌─────────────────────────────────────────────────────────────────────┐   │
│   │                      Lead Claude Planner Agent                      │   │
│   │     - Analyzes repo topography, dependency trees, and constraints   │   │
│   │     - Generates declarative workflow specification (DAG program)     │   │
│   └────────────────────────────┬────────────────────────────────────────┘   │
│                                │                                            │
│                                ▼                                            │
│   ┌─────────────────────────────────────────────────────────────────────┐   │
│   │                Managed Server Execution Engine                      │   │
│   │     - Validates safety constraints and resource budgets             │   │
│   │     - Dispatches tasks across staged execution tiers                │   │
│   │     - Caps active concurrency at 64 parallel threads                │   │
│   └────────────────────────────┬────────────────────────────────────────┘   │
│                                │                                            │
│            ┌───────────────────┼───────────────────┐                        │
│            ▼                   ▼                   ▼                        │
│   [Sub-Agent Group 1]  [Sub-Agent Group 2]  [Sub-Agent Group N]             │
│   (Repo Ingestion)     (AST Vulnerability)  (Patch Synthesis)               │
│   Up to 1,000 Total Workers Allocated Across Execution Lifecycle            │
│                                │                                            │
│                                ▼                                            │
│   ┌─────────────────────────────────────────────────────────────────────┐   │
│   │                Native OpenTelemetry Exporter (OTel)                 │   │
│   │   - Traces: agent.name, session.id, tool.duration, span_id          │   │
│   │   - Metrics: prompt_tokens, completion_tokens, cached_tokens, cost  │   │
│   └────────────────────────────┬────────────────────────────────────────┘   │
│                                │                                            │
│                                ▼                                            │
│            [Enterprise Observability: Grafana / SigNoz]                     │
└─────────────────────────────────────────────────────────────────────────────┘

With Dynamic Workflows, Anthropic shifts workflow compilation inside the model’s server-side runtime. When given a high-volume task, the primary agent evaluates the problem scope and compiles a specialized execution program.

This program executes server-side, asynchronously managing lifecycle hooks, error retries, and data passing between sub-agents while the parent user session remains responsive.

Key parameters of the execution engine include:

• Max sub-agent allocation: Up to 1,000 discrete sub-agents per workflow run.
• Concurrency throttling: Default hardware and API throttling limits active concurrent worker execution to 64 parallel threads to prevent instantaneous rate-limit exhaustion.
• Pricing structure: Anthropic does not charge an orchestration markup. Users pay standard token ingestion and generation rates for each active model, plus the baseline Claude Managed Agents session fee of $0.08 per session-hour.

Enabling Dynamic Workflows via the SDK

To invoke dynamic multi-agent execution, developers pass the multi-agent beta header and configure the workflow engine in the agent specification:

import { Anthropic } from '@anthropic-ai/sdk';

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  defaultHeaders: {
    'anthropic-beta': 'managed-agents-2026-04-01'
  }
});

const agentSession = await anthropic.managedAgents.sessions.create({
  model: 'claude-3-7-sonnet',
  system: 'You are a lead security architect managing enterprise vulnerability remediation.',
  multiagent: {
    type: 'multiagent_20261001',
    workflows: {
      type: 'enabled',
      maxSubagents: 500,
      maxConcurrency: 64,
      allowedModels: ['claude-3-5-haiku', 'claude-3-7-sonnet']
    }
  }
});

2. Solving the Observability Black Box with Native OpenTelemetry

As enterprises scale autonomous agents from experimental scripts into production infrastructure, the lack of telemetry has emerged as a primary security and budgetary blocker. When an agentic loop makes dozens of recursive LLM calls and tool invocations, engineering teams struggle to isolate runaway cost drivers, pinpoint latency bottlenecks, or trace corrupted context windows.

Anthropic’s OpenTelemetry integration addresses this by implementing native W3C Trace Context and OTel semantic conventions across all API boundaries.

trace_id: 4bf92f3577b34da6a3ce929d0e0e4736
├── span: claude.managed_agent.session (duration: 4.82s)
│   ├── span: workflow.compile (duration: 320ms, model: claude-3-7-sonnet)
│   ├── span: subagent.worker_01.exec (duration: 1.14s, model: claude-3-5-haiku)
│   │   └── span: tool.mcp_call (tool: github.get_pull_request, duration: 182ms)
│   ├── span: subagent.worker_02.exec (duration: 1.42s, model: claude-3-5-haiku)
│   │   └── span: tool.mcp_call (tool: ast_parser.scan, duration: 410ms)
│   └── span: workflow.synthesis (duration: 980ms, model: claude-3-7-sonnet)

The OTel exporter attaches rich, structured metadata to every span:

• gen_ai.system: "anthropic"
• gen_ai.agent.name: Configured sub-agent role (e.g. "ASTScanner")
• gen_ai.agent.session_id: Unique managed session identifier
• gen_ai.usage.prompt_tokens: Count of input tokens
• gen_ai.usage.completion_tokens: Count of generated tokens
• gen_ai.usage.cache_read_tokens: Tokens served from prompt cache
• gen_ai.usage.estimated_cost_usd: Direct dollar calculation calculated at runtime

Engineering teams can route these metrics via standard OpenTelemetry Protocol (OTLP) collectors over gRPC or HTTP to Prometheus, Grafana, Datadog, Dynatrace, or open-source stacks like SigNoz without installing proprietary SDK middleware.

3. Architecture Comparison: Claude vs Dots vs Antigravity

Anthropic’s architectural move brings Claude into direct competition with autonomous agent frameworks from OpenAI and Google DeepMind:

While OpenAI’s GPT-6.1 Dots emphasizes swarm consensus and micro-agent voting protocols, Anthropic’s Dynamic Workflows focus on deterministic hierarchical compilation: a reasoning model writes a task program, and execution infrastructure carries it out under strict OTel observability.

4. Engineering Implementation: Setting Up OTel Telemetry

To stream agent execution telemetry directly to an OpenTelemetry collector, configure the exporter during platform initialization:

import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc';

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4317'
  }),
  metricExporter: new OTLPMetricExporter({
    url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4317'
  })
});

sdk.start();

When coupled with automated alerts on gen_ai.usage.estimated_cost_usd, teams can establish hard circuit breakers that terminate runaway sub-agent loops before unexpected compute bills accumulate.

5. Strategic Takeaways for Engineering Leaders

1. Eliminate Hand-Rolled Agent State Machines: Teams writing custom recursive state machines to coordinate multiple Claude calls should evaluate migrating to Dynamic Workflows. Offloading execution state, retry logic, and concurrency throttling to server-side infrastructure eliminates hundreds of lines of fragile plumbing.
2. Mandate Trace-Level Attribution: Adopting native OTel allows platform teams to attribute AI infrastructure costs down to specific teams, pull requests, or automated cron tasks. Spans identify which specific sub-agents drive token bloat.
3. Exploit Sub-Agent Model Tiering: Dynamic Workflows yield the highest ROI when orchestrating tiered models. Using Claude 3.7 Sonnet as the master compiler while routing bulk parallel sub-tasks to Claude 3.5 Haiku reduces end-to-end task costs by up to 78% compared to homogeneous model swarms.

Frequently Asked Questions

What is the maximum number of sub-agents supported in Claude Dynamic Workflows?

The engine supports generating and coordinating up to 1,000 sub-agents within a single workflow program, with execution throttled at a default concurrency limit of 64 parallel active threads.

How much do Claude Managed Agent Dynamic Workflows cost?

Anthropic does not charge an additional markup for workflow orchestration. Usage is billed at standard token rates for the models utilized, plus the Managed Agents baseline session runtime rate of $0.08 per session-hour.

Which observability backends are supported by Claude’s OpenTelemetry export?

Because the feature outputs standard OpenTelemetry Protocol (OTLP) traces and metrics, it natively integrates with any OTel-compliant backend, including Grafana, SigNoz, Datadog, Prometheus, New Relic, and Dynatrace.