Trace and Evaluate 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-triage",
    ),
    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-triage",
  url: process.env.PHOENIX_COLLECTOR_ENDPOINT,
  apiKey: process.env.PHOENIX_API_KEY,
});

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

# triage.py

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

import json

import anthropic

ISSUES = [
    {"number": 101, "title": "Login fails with SSO for all EU users",
     "labels": ["bug", "auth"], "comments": 14},
    {"number": 102, "title": "Typo in the README install section",
     "labels": ["docs"], "comments": 1},
    {"number": 103, "title": "Export to CSV drops the last row",
     "labels": ["bug", "export"], "comments": 6},
    {"number": 104, "title": "Add dark mode to the settings page",
     "labels": ["enhancement"], "comments": 9},
]

REQUEST = (
    "Triage the open issues. Use bash to count the open issues for each "
    "label, then name the single most urgent issue and explain why in "
    "two sentences."
)

client = anthropic.Anthropic()
tracer = tracer_provider.get_tracer("issue-triage")


def create_agent():
    environment = client.beta.environments.create(
        name="issue-triage",
        config={"type": "cloud", "networking": {"type": "limited"}},
    )
    agent = client.beta.agents.create(
        name="Issue Triage Agent",
        model="claude-opus-5-5",
        system=(
            "You triage GitHub issues for a small open-source project. "
            "Call list_issues to read the issues. Use bash for any "
            "counting or sorting."
        ),
        tools=[
            {
                "type": "agent_toolset_20260401",
                "default_config": {
                    "permission_policy": {"type": "always_allow"},
                },
                "configs": [
                    {"name": "web_fetch", "enabled": False},
                    {"name": "web_search", "enabled": False},
                ],
            },
            {
                "type": "custom",
                "name": "list_issues",
                "description": "List the repository's issues as JSON.",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "state": {"type": "string", "enum": ["open"]},
                    },
                    "required": ["state"],
                },
            },
        ],
    )
    return environment, agent


# Your own span for the tool your application runs. The Claude API
# can't see inside this function, so nothing else would trace it.
@tracer.tool(name="list_issues")
def list_issues(state: str) -> str:
    """List the repository's issues as JSON."""
    return json.dumps(ISSUES)


@tracer.chain(name="triage-request")
def run_triage(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 == "agent.custom_tool_use":
                client.beta.sessions.events.send(
                    session_id=session.id,
                    events=[
                        {
                            "type": "user.custom_tool_result",
                            "custom_tool_use_id": event.id,
                            "content": [
                                {
                                    "type": "text",
                                    "text": list_issues(**event.input),
                                },
                            ],
                        },
                    ],
                )
            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)


environment, agent = create_agent()
print(run_triage(REQUEST))
tracer_provider.shutdown()

// triage.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, traceTool } from "@arizeai/openinference-core";

const ISSUES = [
  { number: 101, title: "Login fails with SSO for all EU users",
    labels: ["bug", "auth"], comments: 14 },
  { number: 102, title: "Typo in the README install section",
    labels: ["docs"], comments: 1 },
  { number: 103, title: "Export to CSV drops the last row",
    labels: ["bug", "export"], comments: 6 },
  { number: 104, title: "Add dark mode to the settings page",
    labels: ["enhancement"], comments: 9 },
];

const LIST_ISSUES_PARAMETERS = {
  type: "object" as const,
  properties: { state: { type: "string", enum: ["open"] } },
  required: ["state"],
};

const REQUEST =
  "Triage the open issues. Use bash to count the open issues for each " +
  "label, then name the single most urgent issue and explain why in " +
  "two sentences.";

const client = new Anthropic();

async function createAgent() {
  const environment = await client.beta.environments.create({
    name: "issue-triage",
    config: { type: "cloud", networking: { type: "limited" } },
  });
  const agent = await client.beta.agents.create({
    name: "Issue Triage Agent",
    model: "claude-opus-5-5",
    system:
      "You triage GitHub issues for a small open-source project. " +
      "Call list_issues to read the issues. Use bash for any " +
      "counting or sorting.",
    tools: [
      {
        type: "agent_toolset_20260401",
        default_config: { permission_policy: { type: "always_allow" } },
        configs: [
          { name: "web_fetch", enabled: false },
          { name: "web_search", enabled: false },
        ],
      },
      {
        type: "custom",
        name: "list_issues",
        description: "List the repository's issues as JSON.",
        input_schema: LIST_ISSUES_PARAMETERS,
      },
    ],
  });
  return { environment, agent };
}

// Your own span for the tool your application runs. The Claude API
// can't see inside this function, so nothing else would trace it.
const listIssues = traceTool(
  (input: unknown): string => JSON.stringify(ISSUES),
  {
    name: "list_issues",
    attributes: {
      "tool.name": "list_issues",
      "tool.description": "List the repository's issues as JSON.",
      "tool.parameters": JSON.stringify(LIST_ISSUES_PARAMETERS),
    },
  },
);

function traceTriage(environmentId: string, agentId: string,
    agentVersion: number) {
  return traceChain(async (request: string): Promise<string> => {
    const session = await client.beta.sessions.create({
      agent: { type: "agent", id: agentId, version: agentVersion },
      environment_id: environmentId,
    });
    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 "agent.custom_tool_use":
          await client.beta.sessions.events.send(session.id, {
            events: [
              {
                type: "user.custom_tool_result",
                custom_tool_use_id: event.id,
                content: [{ type: "text", text: listIssues(event.input) }],
              },
            ],
          });
          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: "triage-request" });
}

async function main() {
  const { environment, agent } = await createAgent();
  const runTriage = traceTriage(environment.id, agent.id, agent.version);
  console.log(await runTriage(REQUEST));
  await provider.shutdown();
}

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

// main.go
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "strings"
    "time"

    "github.com/anthropics/anthropic-sdk-go"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/codes"
    "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"
    "go.opentelemetry.io/otel/trace"
)

type issue struct {
    Number   int      `json:"number"`
    Title    string   `json:"title"`
    Labels   []string `json:"labels"`
    Comments int      `json:"comments"`
}

var issues = []issue{
    {101, "Login fails with SSO for all EU users",
        []string{"bug", "auth"}, 14},
    {102, "Typo in the README install section", []string{"docs"}, 1},
    {103, "Export to CSV drops the last row",
        []string{"bug", "export"}, 6},
    {104, "Add dark mode to the settings page",
        []string{"enhancement"}, 9},
}

const request = "Triage the open issues. Use bash to count the open " +
    "issues for each label, then name the single most urgent issue " +
    "and explain why in two sentences."

var tracer = otel.Tracer("issue-triage")

// listIssuesParameters is the list_issues input schema, recorded on its
// TOOL span.
const listIssuesParameters = `{"type":"object",` +
    `"properties":{"state":{"type":"string","enum":["open"]}},` +
    `"required":["state"]}`

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

// run returns errors instead of exiting, so the deferred Shutdown flushes
// the spans to Phoenix even when a request fails.
func run(ctx context.Context) error {
    tp, err := initTracer(ctx)
    if err != nil {
        return fmt.Errorf("register tracer: %w", err)
    }
    defer shutdownTracer(tp)

    client := anthropic.NewClient()

    environmentID, agentID, agentVersion, err := createAgent(ctx, client)
    if err != nil {
        return fmt.Errorf("create agent: %w", err)
    }

    answer, err := runTriage(ctx, client, environmentID, agentID,
        agentVersion)
    if err != nil {
        return fmt.Errorf("run triage: %w", err)
    }
    fmt.Println(answer)
    return nil
}

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-triage"
    }
    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 createAgent(ctx context.Context, client anthropic.Client) (
    string, string, int64, error) {
    environment, err := client.Beta.Environments.New(ctx,
        anthropic.BetaEnvironmentNewParams{
            Name: "issue-triage",
            Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
                OfCloud: &anthropic.BetaCloudConfigParams{
                    Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
                        OfLimited: &anthropic.BetaLimitedNetworkParams{},
                    },
                },
            },
        })
    if err != nil {
        return "", "", 0, err
    }

    listIssuesTool := anthropic.BetaManagedAgentsCustomToolParams{
        Type:        anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
        Name:        "list_issues",
        Description: "List the repository's issues as JSON.",
    }
    listIssuesTool.InputSchema.Properties = map[string]any{
        "state": map[string]any{"type": "string", "enum": []string{"open"}},
    }
    listIssuesTool.InputSchema.Required = []string{"state"}

    agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
        Name: "Issue Triage Agent",
        Model: anthropic.BetaManagedAgentsModelConfigParams{
            ID: "claude-opus-5-5",
        },
        System: anthropic.String(
            "You triage GitHub issues for a small open-source project. " +
                "Call list_issues to read the issues. Use bash for any " +
                "counting or sorting."),
        Tools: []anthropic.BetaAgentNewParamsToolUnion{
            {OfAgentToolset20260401: toolset()},
            {OfCustom: &listIssuesTool},
        },
    })
    if err != nil {
        return "", "", 0, err
    }
    return environment.ID, agent.ID, agent.Version, nil
}

// listIssues records your own span for the tool your application runs.
// The Claude API can't see inside this function.
func listIssues(ctx context.Context, input map[string]any) string {
    _, span := tracer.Start(ctx, "list_issues")
    defer span.End()
    inputJSON, _ := json.Marshal(input)
    result, _ := json.Marshal(issues)
    span.SetAttributes(
        attribute.String("openinference.span.kind", "TOOL"),
        attribute.String("tool.name", "list_issues"),
        attribute.String("tool.description",
            "List the repository's issues as JSON."),
        attribute.String("tool.parameters", listIssuesParameters),
        attribute.String("input.value", string(inputJSON)),
        attribute.String("output.value", string(result)),
    )
    span.SetStatus(codes.Ok, "")
    return string(result)
}

func runTriage(ctx context.Context, client anthropic.Client,
    environmentID, agentID string,
    agentVersion int64) (answer string, err error) {
    ctx, root := tracer.Start(ctx, "triage-request", trace.WithAttributes(
        attribute.String("openinference.span.kind", "CHAIN"),
        attribute.String("input.value", request),
    ))
    defer func() {
        if err != nil {
            root.RecordError(err)
            root.SetStatus(codes.Error, err.Error())
        } else {
            root.SetStatus(codes.Ok, "")
        }
        root.End()
    }()

    sessionParams := anthropic.BetaSessionNewParams{
        Agent: anthropic.BetaSessionNewParamsAgentUnion{
            OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
                Type:    anthropic.BetaManagedAgentsAgentParamsTypeAgent,
                ID:      agentID,
                Version: anthropic.Int(agentVersion),
            },
        },
        EnvironmentID: environmentID,
    }
    session, err := client.Beta.Sessions.New(ctx, sessionParams)
    if err != nil {
        return "", 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()

    if err := send(ctx, client, session.ID,
        anthropic.BetaManagedAgentsEventParamsUnion{
            OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
                Type: anthropic.
                    BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
                Content: []anthropic.
                    BetaManagedAgentsUserMessageEventParamsContentUnion{{
                    OfText: textBlock(request),
                }},
            },
        }); err != nil {
        return "", 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.BetaManagedAgentsAgentCustomToolUseEvent:
            result := toolResult(event.ID, listIssues(ctx, event.Input))
            if err := send(ctx, client, session.ID, result); err != nil {
                return "", err
            }
        case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
            if event.StopReason.Type != "requires_action" {
                break events
            }
        case anthropic.BetaManagedAgentsSessionStatusTerminatedEvent:
            break events
        }
    }
    if err := stream.Err(); err != nil {
        return "", err
    }

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

func send(ctx context.Context, client anthropic.Client, sessionID string,
    event anthropic.BetaManagedAgentsEventParamsUnion) error {
    _, err := client.Beta.Sessions.Events.Send(ctx, sessionID,
        anthropic.BetaSessionEventSendParams{
            Events: []anthropic.BetaManagedAgentsEventParamsUnion{event},
        })
    return err
}

// toolResult answers a custom tool call. The SDK's
// BetaManagedAgentsEventParamsOfUserCustomToolResult helper leaves the
// event type unset, which the API rejects.
func toolResult(id, text string) anthropic.BetaManagedAgentsEventParamsUnion {
    var result anthropic.BetaManagedAgentsUserCustomToolResultEventParams
    result.Type = anthropic.
        BetaManagedAgentsUserCustomToolResultEventParamsTypeUserCustomToolResult
    result.CustomToolUseID = id
    result.Content = []anthropic.
        BetaManagedAgentsUserCustomToolResultEventParamsContentUnion{{
        OfText: textBlock(text),
    }}
    return anthropic.BetaManagedAgentsEventParamsUnion{
        OfUserCustomToolResult: &result,
    }
}

func textBlock(text string) *anthropic.BetaManagedAgentsTextBlockParam {
    return &anthropic.BetaManagedAgentsTextBlockParam{
        Type: anthropic.BetaManagedAgentsTextBlockTypeText,
        Text: text,
    }
}

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.core.JsonValue;
import com.anthropic.core.ObjectMappers;
import com.anthropic.models.beta.agents.*;
import com.anthropic.models.beta.environments.BetaCloudConfigParams;
import com.anthropic.models.beta.environments.BetaEnvironment;
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 com.fasterxml.jackson.core.JsonProcessingException;
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.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.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class Main {

    // The list_issues input schema, recorded on its TOOL span.
    private static final String LIST_ISSUES_PARAMETERS =
        "{\"type\":\"object\",\"properties\":{\"state\":"
            + "{\"type\":\"string\",\"enum\":[\"open\"]}},"
            + "\"required\":[\"state\"]}";

    private static final String ISSUES = """
        [
          {"number": 101, "title": "Login fails with SSO for all EU users",
           "labels": ["bug", "auth"], "comments": 14},
          {"number": 102, "title": "Typo in the README install section",
           "labels": ["docs"], "comments": 1},
          {"number": 103, "title": "Export to CSV drops the last row",
           "labels": ["bug", "export"], "comments": 6},
          {"number": 104, "title": "Add dark mode to the settings page",
           "labels": ["enhancement"], "comments": 9}
        ]
        """;

    private static final String REQUEST =
        "Triage the open issues. Use bash to count the open issues for "
            + "each label, then name the single most urgent issue and "
            + "explain why in two sentences.";

    private static AnthropicClient client;
    private static Tracer tracer;

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

        Resource resource = Resource.getDefault().merge(Resource.create(
            Attributes.of(
                AttributeKey.stringKey("service.name"), project,
                AttributeKey.stringKey("openinference.project.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();

        client = AnthropicOkHttpClient.fromEnv();
        tracer = otel.getTracer("issue-triage");

        BetaEnvironment environment = createEnvironment();
        BetaManagedAgentsAgent agent = createAgent();
        System.out.println(runTriage(environment, agent));

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

    private static BetaEnvironment createEnvironment() {
        return client.beta().environments().create(
            EnvironmentCreateParams.builder()
                .name("issue-triage")
                .config(BetaCloudConfigParams.builder()
                    .networking(BetaLimitedNetworkParams.builder().build())
                    .build())
                .build());
    }

    private static BetaManagedAgentsAgent createAgent() {
        var toolset = 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();

        var listIssues = BetaManagedAgentsCustomToolParams.builder()
            .type(BetaManagedAgentsCustomToolParams.Type.CUSTOM)
            .name("list_issues")
            .description("List the repository's issues as JSON.")
            .inputSchema(BetaManagedAgentsCustomToolInputSchema.builder()
                .properties(BetaManagedAgentsCustomToolInputSchema.Properties
                    .builder()
                    .putAdditionalProperty("state", JsonValue.from(Map.of(
                        "type", "string", "enum", List.of("open"))))
                    .build())
                .addRequired("state")
                .build())
            .build();

        return client.beta().agents().create(AgentCreateParams.builder()
            .name("Issue Triage Agent")
            .model(BetaManagedAgentsModel.of("claude-opus-5-5"))
            .system("You triage GitHub issues for a small open-source "
                + "project. Call list_issues to read the issues. Use bash "
                + "for any counting or sorting.")
            .addTool(toolset)
            .addTool(listIssues)
            .build());
    }

    // Your own span for the tool your application runs. The Claude API
    // can't see inside this method, so nothing else would trace it.
    private static String listIssues(
            BetaManagedAgentsAgentCustomToolUseEvent call)
            throws JsonProcessingException {
        Span span = tracer.spanBuilder("list_issues").startSpan();
        try (Scope scope = span.makeCurrent()) {
            span.setAttribute("openinference.span.kind", "TOOL");
            span.setAttribute("tool.name", "list_issues");
            span.setAttribute("tool.description",
                "List the repository's issues as JSON.");
            span.setAttribute("tool.parameters", LIST_ISSUES_PARAMETERS);
            span.setAttribute("input.value",
                ObjectMappers.jsonMapper().writeValueAsString(call.input()));
            span.setAttribute("output.value", ISSUES);
            span.setStatus(StatusCode.OK);
            return ISSUES;
        } catch (Exception e) {
            span.recordException(e);
            span.setStatus(StatusCode.ERROR, e.getMessage());
            throw e;
        } finally {
            span.end();
        }
    }

    private static BetaManagedAgentsUserCustomToolResultEventParams
            toolResult(BetaManagedAgentsAgentCustomToolUseEvent call)
            throws JsonProcessingException {
        return BetaManagedAgentsUserCustomToolResultEventParams.builder()
            .type(BetaManagedAgentsUserCustomToolResultEventParams.Type
                .USER_CUSTOM_TOOL_RESULT)
            .customToolUseId(call.id())
            .addTextContent(listIssues(call))
            .build();
    }

    private static String runTriage(BetaEnvironment environment,
            BetaManagedAgentsAgent agent) throws JsonProcessingException {
        Span root = tracer.spanBuilder("triage-request").startSpan();
        try (Scope scope = root.makeCurrent()) {
            root.setAttribute("openinference.span.kind", "CHAIN");
            root.setAttribute("input.value", REQUEST);

            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 events = client.beta().sessions().events();
            List<String> replies = new ArrayList<>();

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

                Iterable<BetaManagedAgentsStreamSessionEvents> received =
                    stream.stream()::iterator;
                for (var event : received) {
                    if (event.isAgentMessage()) {
                        event.asAgentMessage().content()
                            .forEach(block -> block.text()
                                .ifPresent(text -> replies.add(text.text())));
                    } else if (event.isAgentCustomToolUse()) {
                        var call = event.asAgentCustomToolUse();
                        events.send(session.id(), EventSendParams.builder()
                            .addEvent(toolResult(call))
                            .build());
                    } else if (event.isSessionStatusIdle()) {
                        if (!event.asSessionStatusIdle().stopReason()
                                .isRequiresAction()) {
                            break;
                        }
                    } else if (event.isSessionStatusTerminated()) {
                        break;
                    }
                }
            }

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

    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;
    }
}

python triage.py

npx tsx triage.ts

go run main.go

gradle run