Claude Managed Agents

pip install arize-otel anthropic

npm install @anthropic-ai/sdk \
  @opentelemetry/api \
  @opentelemetry/exporter-trace-otlp-proto \
  @opentelemetry/resources \
  @opentelemetry/sdk-trace-base \
  @opentelemetry/sdk-trace-node \
  @opentelemetry/semantic-conventions \
  @arizeai/openinference-core \
  @arizeai/openinference-semantic-conventions \
  tsx

go get \
  github.com/Arize-ai/arize-otel-go \
  github.com/anthropics/anthropic-sdk-go

// 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
from arize.otel import register

# register() reads ARIZE_SPACE_ID, ARIZE_API_KEY, ARIZE_PROJECT_NAME, and
# ARIZE_COLLECTOR_ENDPOINT from the environment.
tracer_provider = register()

print("Arize AX tracing initialized for Claude Managed Agents.")

// instrumentation.ts
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
import {
  SEMRESATTRS_PROJECT_NAME,
} from "@arizeai/openinference-semantic-conventions";

const projectName = process.env.ARIZE_PROJECT_NAME ?? "default";
// For EU or Canada spaces, set ARIZE_COLLECTOR_ENDPOINT to your region's
// endpoint, such as https://otlp.eu-west-1a.arize.com/v1.
const endpoint =
  process.env.ARIZE_COLLECTOR_ENDPOINT ?? "https://otlp.arize.com/v1";

export const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    [ATTR_SERVICE_NAME]: projectName,
    [SEMRESATTRS_PROJECT_NAME]: projectName,
  }),
  spanProcessors: [
    new BatchSpanProcessor(
      new OTLPTraceExporter({
        url: `${endpoint}/traces`,
        headers: {
          "arize-api-key": process.env.ARIZE_API_KEY ?? "",
          "arize-space-id": process.env.ARIZE_SPACE_ID ?? "",
        },
      }),
    ),
  ],
});

// register() installs the W3C trace context propagator and the context
// manager, so the SDK's spans nest under your own spans.
provider.register();

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

// main.go
package main

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

    arizeotel "github.com/Arize-ai/arize-otel-go"
    "github.com/anthropics/anthropic-sdk-go"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/codes"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/trace"
)

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

func main() {
    if err := run(context.Background()); err != nil {
        log.Fatal(err)
    }
}

// run returns errors instead of exiting, so the deferred calls end the
// span and flush it to Arize AX even when a request fails.
func run(ctx context.Context) (err error) {
    // Register reads ARIZE_SPACE_ID, ARIZE_API_KEY, and
    // ARIZE_COLLECTOR_ENDPOINT from the environment.
    tp, err := arizeotel.Register(ctx, arizeotel.Options{
        ProjectName: os.Getenv("ARIZE_PROJECT_NAME"),
    })
    if err != nil {
        return fmt.Errorf("register tracer: %w", err)
    }
    defer func() {
        shutdownCtx, cancel := context.WithTimeout(
            context.Background(), 5*time.Second)
        defer cancel()
        _ = tp.Shutdown(shutdownCtx)
    }()
    // OpenTelemetry for Go registers no propagator by default. The Claude
    // SDK needs W3C trace context to link its spans to the API's spans.
    otel.SetTextMapPropagator(propagation.TraceContext{})

    fmt.Println("Arize AX 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: "arize-tracing-example",
            Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
                OfCloud: &anthropic.BetaCloudConfigParams{
                    Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
                        OfLimited: &anthropic.BetaLimitedNetworkParams{},
                    },
                },
            },
        })
    if err != nil {
        return fmt.Errorf("create environment: %w", 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 {
        return fmt.Errorf("create agent: %w", err)
    }

    ctx, span := otel.Tracer("claude-managed-agents-example").
        Start(ctx, "fibonacci-agent", trace.WithAttributes(
            attribute.String("openinference.span.kind", "CHAIN"),
            attribute.String("input.value", prompt),
        ))
    defer func() {
        if err != nil {
            span.RecordError(err)
            span.SetStatus(codes.Error, err.Error())
        } else {
            span.SetStatus(codes.Ok, "")
        }
        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 {
        return fmt.Errorf("create session: %w", 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 {
        return fmt.Errorf("send message: %w", err)
    }

    var replies []string
events:
    for stream.Next() {
        switch event := stream.Current().AsAny().(type) {
        case anthropic.BetaManagedAgentsAgentMessageEvent:
            for _, block := range event.Content {
                replies = append(replies, block.Text)
            }
        case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
            if event.StopReason.Type != "requires_action" {
                break events
            }
        case anthropic.BetaManagedAgentsSessionStatusTerminatedEvent:
            break events
        }
    }
    if err := stream.Err(); err != nil {
        return fmt.Errorf("stream: %w", err)
    }

    answer := strings.Join(replies, "\n")
    span.SetAttributes(attribute.String("output.value", answer))
    fmt.Println(answer)
    return nil
}

func toolset() *anthropic.BetaManagedAgentsAgentToolset20260401Params {
    ts := &anthropic.BetaManagedAgentsAgentToolset20260401Params{
        Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
            {OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
                Enabled: anthropic.Bool(false),
            }},
            {OfWebSearch: &anthropic.BetaManagedAgentsWebSearchToolConfigParams{
                Enabled: anthropic.Bool(false),
            }},
        },
    }
    ts.Type = anthropic.
        BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401
    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.StatusCode;
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.trace.OtlpGrpcSpanExporter;
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.net.URI;
import java.util.ArrayList;
import java.util.Map;
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 = System.getenv().getOrDefault(
            "ARIZE_PROJECT_NAME", "default");

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

        // For EU or Canada spaces, set ARIZE_COLLECTOR_ENDPOINT to your
        // region's endpoint, such as https://otlp.eu-west-1a.arize.com/v1.
        URI collector = URI.create(System.getenv().getOrDefault(
            "ARIZE_COLLECTOR_ENDPOINT", "https://otlp.arize.com/v1"));
        OtlpGrpcSpanExporter exporter = OtlpGrpcSpanExporter.builder()
            .setEndpoint("https://" + collector.getHost() + ":443")
            .setHeaders(() -> Map.of(
                "authorization", System.getenv("ARIZE_API_KEY"),
                "arize-space-id", System.getenv("ARIZE_SPACE_ID")))
            .build();

        SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
            .addSpanProcessor(BatchSpanProcessor.builder(exporter).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(
            "Arize AX 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("arize-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)
                .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()) {
            span.setAttribute("openinference.span.kind", "CHAIN");
            span.setAttribute("input.value", PROMPT);

            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());

            var replies = new ArrayList<String>();

            // 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 -> replies.add(text.text())));
                    } else if (event.isSessionStatusIdle()) {
                        if (!event.asSessionStatusIdle().stopReason()
                                .isRequiresAction()) {
                            break;
                        }
                    } else if (event.isSessionStatusTerminated()) {
                        break;
                    }
                }
            }

            String answer = String.join("\n", replies);
            span.setAttribute("output.value", answer);
            span.setStatus(StatusCode.OK);
            System.out.println(answer);
        } catch (Exception e) {
            span.recordException(e);
            span.setStatus(StatusCode.ERROR, e.getMessage());
            throw e;
        } finally {
            span.end();
        }

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

# 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="arize-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",
            "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: "arize-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",
        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