Claude Managed Agents

pip install arize-phoenix-otel anthropic

npm install @anthropic-ai/sdk @arizeai/openinference-core @arizeai/phoenix-otel tsx

go get github.com/anthropics/anthropic-sdk-go
go get go.opentelemetry.io/otel
go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp
go get go.opentelemetry.io/otel/sdk

// build.gradle
plugins {
    id 'application'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.anthropic:anthropic-java:2.72.0'
    implementation 'io.opentelemetry:opentelemetry-sdk:1.66.0'
    implementation 'io.opentelemetry:opentelemetry-exporter-otlp:1.66.0'
}

application {
    mainClass = 'example.Main'
}

# instrumentation.py
import os

from phoenix.otel import register

tracer_provider = register(
    project_name=os.environ.get(
        "PHOENIX_PROJECT_NAME",
        "claude-managed-agents-example",
    ),
    endpoint=os.environ.get("PHOENIX_COLLECTOR_ENDPOINT"),
)

print("Phoenix tracing initialized for Claude Managed Agents.")

// instrumentation.ts
import { register } from "@arizeai/phoenix-otel";

export const provider = register({
  projectName:
    process.env.PHOENIX_PROJECT_NAME ?? "claude-managed-agents-example",
  url: process.env.PHOENIX_COLLECTOR_ENDPOINT,
  apiKey: process.env.PHOENIX_API_KEY,
});

console.log("Phoenix tracing initialized for Claude Managed Agents.");

// main.go
package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "strings"
    "time"

    "github.com/anthropics/anthropic-sdk-go"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
)

const prompt = "Use bash to compute the first 10 Fibonacci numbers. " +
    "Reply with only the numbers, comma-separated."

func phoenixTraceEndpoint(endpoint string) string {
    endpoint = strings.TrimRight(endpoint, "/")
    if strings.HasSuffix(endpoint, "/v1/traces") {
        return endpoint
    }
    return endpoint + "/v1/traces"
}

func initTracer(ctx context.Context) (*sdktrace.TracerProvider, error) {
    project := os.Getenv("PHOENIX_PROJECT_NAME")
    if project == "" {
        project = "claude-managed-agents-example"
    }
    endpoint := os.Getenv("PHOENIX_COLLECTOR_ENDPOINT")
    if endpoint == "" {
        endpoint = "http://localhost:6006/v1/traces"
    }
    headers := map[string]string{"x-project-name": project}
    if apiKey := os.Getenv("PHOENIX_API_KEY"); apiKey != "" {
        headers["Authorization"] = "Bearer " + apiKey
    }
    exporter, err := otlptracehttp.New(
        ctx,
        otlptracehttp.WithEndpointURL(phoenixTraceEndpoint(endpoint)),
        otlptracehttp.WithHeaders(headers),
    )
    if err != nil {
        return nil, err
    }
    res, _ := resource.New(ctx, resource.WithAttributes(
        semconv.ServiceName(project),
    ))
    tp := sdktrace.NewTracerProvider(
        sdktrace.WithBatcher(exporter),
        sdktrace.WithResource(res),
    )
    otel.SetTracerProvider(tp)
    otel.SetTextMapPropagator(propagation.TraceContext{})
    return tp, nil
}

func shutdownTracer(tp *sdktrace.TracerProvider) {
    shutdownCtx, cancel := context.WithTimeout(
        context.Background(), 5*time.Second)
    defer cancel()
    _ = tp.Shutdown(shutdownCtx)
}

func main() {
    ctx := context.Background()

    tp, err := initTracer(ctx)
    if err != nil {
        log.Fatalf("register tracer: %v", err)
    }
    defer shutdownTracer(tp)

    fmt.Println("Phoenix tracing initialized for Claude Managed Agents.")

    // The client reads ANTHROPIC_API_KEY from the environment.
    client := anthropic.NewClient()

    environment, err := client.Beta.Environments.New(ctx,
        anthropic.BetaEnvironmentNewParams{
            Name: "phoenix-tracing-example",
            Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
                OfCloud: &anthropic.BetaCloudConfigParams{
                    Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
                        OfLimited: &anthropic.BetaLimitedNetworkParams{},
                    },
                },
            },
        })
    if err != nil {
        log.Fatalf("create environment: %v", err)
    }

    agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
        Name: "Fibonacci Agent",
        Model: anthropic.BetaManagedAgentsModelConfigParams{
            ID: "claude-opus-5-5",
        },
        System: anthropic.String(
            "You are a concise assistant. Use bash to compute answers."),
        Tools: []anthropic.BetaAgentNewParamsToolUnion{{
            OfAgentToolset20260401: toolset(),
        }},
    })
    if err != nil {
        log.Fatalf("create agent: %v", err)
    }

    ctx, span := otel.Tracer("claude-managed-agents-example").
        Start(ctx, "fibonacci-agent")
    defer span.End()

    sessionParams := anthropic.BetaSessionNewParams{
        Agent: anthropic.BetaSessionNewParamsAgentUnion{
            OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
                Type:    anthropic.BetaManagedAgentsAgentParamsTypeAgent,
                ID:      agent.ID,
                Version: anthropic.Int(agent.Version),
            },
        },
        EnvironmentID: environment.ID,
    }
    session, err := client.Beta.Sessions.New(ctx, sessionParams)
    if err != nil {
        log.Fatalf("create session: %v", err)
    }

    // Open the stream before sending the message so no events are missed.
    stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID,
        anthropic.BetaSessionEventStreamParams{})
    defer stream.Close()

    message := anthropic.BetaManagedAgentsUserMessageEventParams{
        Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
        Content: []anthropic.
            BetaManagedAgentsUserMessageEventParamsContentUnion{{
            OfText: &anthropic.BetaManagedAgentsTextBlockParam{
                Type: anthropic.BetaManagedAgentsTextBlockTypeText,
                Text: prompt,
            },
        }},
    }
    _, err = client.Beta.Sessions.Events.Send(ctx, session.ID,
        anthropic.BetaSessionEventSendParams{
            Events: []anthropic.BetaManagedAgentsEventParamsUnion{
                {OfUserMessage: &message},
            },
        })
    if err != nil {
        log.Fatalf("send message: %v", err)
    }

events:
    for stream.Next() {
        switch event := stream.Current().AsAny().(type) {
        case anthropic.BetaManagedAgentsAgentMessageEvent:
            for _, block := range event.Content {
                fmt.Println(block.Text)
            }
        case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
            if event.StopReason.Type != "requires_action" {
                break events
            }
        case anthropic.BetaManagedAgentsSessionStatusTerminatedEvent:
            break events
        }
    }
    if err := stream.Err(); err != nil {
        log.Fatalf("stream: %v", err)
    }
}

func toolset() *anthropic.BetaManagedAgentsAgentToolset20260401Params {
    allow := anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
        Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
    }
    ts := &anthropic.BetaManagedAgentsAgentToolset20260401Params{
        Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
            {OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
                Enabled: anthropic.Bool(false),
            }},
            {OfWebSearch: &anthropic.BetaManagedAgentsWebSearchToolConfigParams{
                Enabled: anthropic.Bool(false),
            }},
        },
    }
    ts.Type = anthropic.
        BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401
    ts.DefaultConfig.PermissionPolicy.OfAlwaysAllow = &allow
    return ts
}

// src/main/java/example/Main.java
package example;

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.beta.agents.*;
import com.anthropic.models.beta.environments.BetaCloudConfigParams;
import com.anthropic.models.beta.environments.BetaLimitedNetworkParams;
import com.anthropic.models.beta.environments.EnvironmentCreateParams;
import com.anthropic.models.beta.sessions.BetaManagedAgentsAgentParams;
import com.anthropic.models.beta.sessions.SessionCreateParams;
import com.anthropic.models.beta.sessions.events.*;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.Scope;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.exporter.otlp.http.trace.OtlpHttpSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
import java.util.concurrent.TimeUnit;

public class Main {

    private static final String PROMPT =
        "Use bash to compute the first 10 Fibonacci numbers. "
            + "Reply with only the numbers, comma-separated.";

    public static void main(String[] args) {
        String project = envOrDefault(
            "PHOENIX_PROJECT_NAME",
            "claude-managed-agents-example");

        Resource resource = Resource.getDefault().merge(Resource.create(
            Attributes.of(AttributeKey.stringKey("service.name"), project)));

        OtlpHttpSpanExporter.Builder exporter = OtlpHttpSpanExporter.builder()
            .setEndpoint(phoenixTraceEndpoint(envOrDefault(
                "PHOENIX_COLLECTOR_ENDPOINT",
                "http://localhost:6006/v1/traces")))
            .addHeader("x-project-name", project);
        String apiKey = System.getenv("PHOENIX_API_KEY");
        if (apiKey != null && !apiKey.isBlank()) {
            exporter.addHeader("Authorization", "Bearer " + apiKey);
        }

        SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
            .addSpanProcessor(BatchSpanProcessor.builder(
                exporter.build()).build())
            .setResource(resource)
            .build();

        // The Claude SDK reads the global OpenTelemetry instance. It needs
        // the W3C propagator to link its spans to the API's spans.
        OpenTelemetrySdk otel = OpenTelemetrySdk.builder()
            .setTracerProvider(tracerProvider)
            .setPropagators(ContextPropagators.create(
                W3CTraceContextPropagator.getInstance()))
            .buildAndRegisterGlobal();

        System.out.println(
            "Phoenix tracing initialized for Claude Managed Agents.");

        // fromEnv() reads ANTHROPIC_API_KEY and the
        // ANTHROPIC_OPEN_TELEMETRY_* variables.
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();
        Tracer tracer = otel.getTracer("claude-managed-agents-example");

        var environment = client.beta().environments().create(
            EnvironmentCreateParams.builder()
                .name("phoenix-tracing-example")
                .config(BetaCloudConfigParams.builder()
                    .networking(BetaLimitedNetworkParams.builder().build())
                    .build())
                .build());

        var agent = client.beta().agents().create(AgentCreateParams.builder()
            .name("Fibonacci Agent")
            .model(BetaManagedAgentsModel.of("claude-opus-5-5"))
            .system("You are a concise assistant. "
                + "Use bash to compute answers.")
            .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
                .type(BetaManagedAgentsAgentToolset20260401Params.Type
                    .AGENT_TOOLSET_20260401)
                .defaultConfig(
                    BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
                        .permissionPolicy(BetaManagedAgentsAlwaysAllowPolicy
                            .builder()
                            .type(BetaManagedAgentsAlwaysAllowPolicy.Type
                                .ALWAYS_ALLOW)
                            .build())
                        .build())
                .addConfig(BetaManagedAgentsWebFetchToolConfigParams.builder()
                    .enabled(false).build())
                .addConfig(BetaManagedAgentsWebSearchToolConfigParams.builder()
                    .enabled(false).build())
                .build())
            .build());

        Span span = tracer.spanBuilder("fibonacci-agent").startSpan();
        try (Scope scope = span.makeCurrent()) {
            var session = client.beta().sessions().create(
                SessionCreateParams.builder()
                    .agent(BetaManagedAgentsAgentParams.builder()
                        .type(BetaManagedAgentsAgentParams.Type.AGENT)
                        .id(agent.id())
                        .version(agent.version())
                        .build())
                    .environmentId(environment.id())
                    .build());

            // Open the stream before sending the message so no events
            // are missed.
            try (var stream = client.beta().sessions().events()
                    .streamStreaming(session.id())) {
                client.beta().sessions().events().send(session.id(),
                    EventSendParams.builder()
                        .addEvent(BetaManagedAgentsUserMessageEventParams
                            .builder()
                            .type(BetaManagedAgentsUserMessageEventParams
                                .Type.USER_MESSAGE)
                            .addTextContent(PROMPT)
                            .build())
                        .build());

                Iterable<BetaManagedAgentsStreamSessionEvents> events =
                    stream.stream()::iterator;
                for (var event : events) {
                    if (event.isAgentMessage()) {
                        event.asAgentMessage().content()
                            .forEach(block -> block.text().ifPresent(
                                text -> System.out.println(text.text())));
                    } else if (event.isSessionStatusIdle()) {
                        if (!event.asSessionStatusIdle().stopReason()
                                .isRequiresAction()) {
                            break;
                        }
                    } else if (event.isSessionStatusTerminated()) {
                        break;
                    }
                }
            }
        } finally {
            span.end();
        }

        tracerProvider.forceFlush().join(10, TimeUnit.SECONDS);
        tracerProvider.shutdown().join(10, TimeUnit.SECONDS);
    }

    private static String phoenixTraceEndpoint(String endpoint) {
        String trimmed = endpoint.replaceAll("/+$", "");
        if (trimmed.endsWith("/v1/traces")) {
            return trimmed;
        }
        return trimmed + "/v1/traces";
    }

    private static String envOrDefault(String name, String defaultValue) {
        String value = System.getenv(name);
        return value == null || value.isBlank() ? defaultValue : value;
    }
}

# example.py

# Importing instrumentation first registers the tracer provider
# before the Claude SDK makes its first request.
from instrumentation import tracer_provider

import anthropic

# The client reads ANTHROPIC_API_KEY from the environment.
client = anthropic.Anthropic()
tracer = tracer_provider.get_tracer("claude-managed-agents-example")

REQUEST = (
    "Use bash to compute the first 10 Fibonacci numbers. "
    "Reply with only the numbers, comma-separated."
)

environment = client.beta.environments.create(
    name="phoenix-tracing-example",
    config={"type": "cloud", "networking": {"type": "limited"}},
)

agent = client.beta.agents.create(
    name="Fibonacci Agent",
    model="claude-opus-5-5",
    system="You are a concise assistant. Use bash to compute answers.",
    tools=[
        {
            "type": "agent_toolset_20260401",
            "default_config": {
                "permission_policy": {"type": "always_allow"},
            },
            "configs": [
                {"name": "web_fetch", "enabled": False},
                {"name": "web_search", "enabled": False},
            ],
        },
    ],
)

@tracer.chain(name="fibonacci-agent")
def run_agent(request: str) -> str:
    session = client.beta.sessions.create(
        agent={"type": "agent", "id": agent.id, "version": agent.version},
        environment_id=environment.id,
    )
    replies = []

    # Open the stream before sending the message so no events are missed.
    with client.beta.sessions.events.stream(session_id=session.id) as stream:
        client.beta.sessions.events.send(
            session_id=session.id,
            events=[
                {
                    "type": "user.message",
                    "content": [
                        {
                            "type": "text",
                            "text": request,
                        },
                    ],
                },
            ],
        )

        for event in stream:
            if event.type == "agent.message":
                for block in event.content:
                    if block.type == "text":
                        replies.append(block.text)
            elif event.type == "session.status_idle":
                if event.stop_reason.type != "requires_action":
                    break
            elif event.type == "session.status_terminated":
                break

    return "\n".join(replies)


print(run_agent(REQUEST))
tracer_provider.shutdown()

// example.ts

// Importing instrumentation first registers the tracer provider
// before the Claude SDK makes its first request.
import { provider } from "./instrumentation";
import Anthropic from "@anthropic-ai/sdk";
import { traceChain } from "@arizeai/openinference-core";

// The client reads ANTHROPIC_API_KEY from the environment.
const client = new Anthropic();

const REQUEST =
  "Use bash to compute the first 10 Fibonacci numbers. " +
  "Reply with only the numbers, comma-separated.";

async function main() {
  const environment = await client.beta.environments.create({
    name: "phoenix-tracing-example",
    config: { type: "cloud", networking: { type: "limited" } },
  });

  const agent = await client.beta.agents.create({
    name: "Fibonacci Agent",
    model: "claude-opus-5-5",
    system: "You are a concise assistant. Use bash to compute answers.",
    tools: [
      {
        type: "agent_toolset_20260401",
        default_config: { permission_policy: { type: "always_allow" } },
        configs: [
          { name: "web_fetch", enabled: false },
          { name: "web_search", enabled: false },
        ],
      },
    ],
  });

  const runAgent = traceChain(
    async (request: string): Promise<string> => {
      const session = await client.beta.sessions.create({
        agent: { type: "agent", id: agent.id, version: agent.version },
        environment_id: environment.id,
      });
      const replies: string[] = [];

      // Open the stream before sending the message so no events are missed.
      const stream = await client.beta.sessions.events.stream(session.id);
      await client.beta.sessions.events.send(session.id, {
        events: [
          { type: "user.message", content: [{ type: "text", text: request }] },
        ],
      });

      loop: for await (const event of stream) {
        switch (event.type) {
          case "agent.message":
            for (const block of event.content) {
              if (block.type === "text") replies.push(block.text);
            }
            break;
          case "session.status_idle":
            if (event.stop_reason.type !== "requires_action") break loop;
            break;
          case "session.status_terminated":
            break loop;
        }
      }

      return replies.join("\n");
    },
    { name: "fibonacci-agent" },
  );

  console.log(await runAgent(REQUEST));
  await provider.shutdown();
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

# The full example is in main.go above.
go run main.go

# The full example is in Main.java above.
gradle run