세션 시작하기

session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
)

const session = await client.beta.sessions.create({
  agent: agent.id,
  environment_id: environment.id
});

var session = await client.Beta.Sessions.Create(new()
{
    Agent = agent.ID,
    EnvironmentID = environment.ID,
});

session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
	Agent: anthropic.BetaSessionNewParamsAgentUnion{
		OfString: anthropic.String(agent.ID),
	},
	EnvironmentID: environment.ID,
})
if err != nil {
	panic(err)
}

var session = client.beta().sessions().create(SessionCreateParams.builder()
    .agent(agent.id())
    .environmentId(environment.id())
    .build());

$session = $client->beta->sessions->create(
    agent: $agent->id,
    environmentID: $environment->id,
);

session = client.beta.sessions.create(
  agent: agent.id,
  environment_id: environment.id
)

pinned_session = client.beta.sessions.create(
    agent={"type": "agent", "id": agent.id, "version": 1},
    environment_id=environment.id,
)

const pinnedSession = await client.beta.sessions.create({
  agent: { type: "agent", id: agent.id, version: 1 },
  environment_id: environment.id
});

var pinnedSession = await client.Beta.Sessions.Create(new()
{
    Agent = new BetaManagedAgentsAgentParams
    {
        Type = BetaManagedAgentsAgentParamsType.Agent,
        ID = agent.ID,
        Version = 1,
    },
    EnvironmentID = environment.ID,
});

pinnedSession, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
	Agent: anthropic.BetaSessionNewParamsAgentUnion{
		OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
			Type:    anthropic.BetaManagedAgentsAgentParamsTypeAgent,
			ID:      agent.ID,
			Version: anthropic.Int(1),
		},
	},
	EnvironmentID: environment.ID,
})
if err != nil {
	panic(err)
}

var pinnedSession = client.beta().sessions().create(SessionCreateParams.builder()
    .agent(BetaManagedAgentsAgentParams.builder()
        .type(BetaManagedAgentsAgentParams.Type.AGENT)
        .id(agent.id())
        .version(1)
        .build())
    .environmentId(environment.id())
    .build());

$pinnedSession = $client->beta->sessions->create(
    agent: ['type' => 'agent', 'id' => $agent->id, 'version' => 1],
    environmentID: $environment->id,
);

pinned_session = client.beta.sessions.create(
  agent: {type: :agent, id: agent.id, version: 1},
  environment_id: environment.id
)

events to see the seeded message.

seeded_events=$(curl -fsSL
"https://api.anthropic.com/v1/sessions/$SEEDED_SESSION_ID/events"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: managed-agents-2026-04-01") echo "Seeded event: $(jq -r
'.data[] | select(.type == "user.message") | .content[0].text' <<< "$seeded_events")"

```bash CLI
SEEDED_SESSION_ID=$(ant beta:sessions create \
  --transform id --raw-output <<YAML
agent: $AGENT_ID
environment_id: $ENVIRONMENT_ID
initial_events:
  - type: user.message
    content:
      - type: text
        text: List the files in the working directory.
YAML
)

# initial_events aren't echoed on the create response; list the session's
# events to see the seeded message.
echo "Seeded event: $(ant beta:sessions:events list \
  --session-id "$SEEDED_SESSION_ID" \
  --format raw \
  --transform 'data.#(type=="user.message").content.0.text' --raw-output)"

seeded_session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    initial_events=[
        {
            "type": "user.message",
            "content": [
                {"type": "text", "text": "List the files in the working directory."}
            ],
        },
    ],
)
# initial_events are not echoed on the create response; read them back
# from the session's event list.
for event in client.beta.sessions.events.list(seeded_session.id):
    if event.type == "user.message":
        for block in event.content:
            if block.type == "text":
                print(f"Seeded event: {block.text}")

const seededSession = await client.beta.sessions.create({
  agent: agent.id,
  environment_id: environment.id,
  initial_events: [
    {
      type: "user.message",
      content: [{ type: "text", text: "List the files in the working directory." }]
    }
  ]
});

// initial_events are not echoed on the create response; list the session's
// events to read the seeded message back.
for await (const event of client.beta.sessions.events.list(seededSession.id)) {
  if (event.type === "user.message") {
    for (const block of event.content) {
      if (block.type === "text") {
        console.log(`Seeded event: ${block.text}`);
      }
    }
  }
}

var seededSession = await client.Beta.Sessions.Create(new()
{
    Agent = agent.ID,
    EnvironmentID = environment.ID,
    InitialEvents =
    [
        new BetaManagedAgentsUserMessageEventParams
        {
            Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
            Content =
            [
                new BetaManagedAgentsTextBlock
                {
                    Type = BetaManagedAgentsTextBlockType.Text,
                    Text = "List the files in the working directory.",
                },
            ],
        },
    ],
});
// initial_events are not echoed on the create response; read them back
// from the session's event list.
var seededEvents = await client.Beta.Sessions.Events.List(seededSession.ID);
await foreach (var sessionEvent in seededEvents.Paginate())
{
    if (sessionEvent.TryPickUserMessage(out var userMessage))
    {
        foreach (var contentBlock in userMessage.Content)
        {
            if (contentBlock.TryPickBetaManagedAgentsTextBlock(out var textBlock))
            {
                Console.WriteLine($"Seeded event: {textBlock.Text}");
            }
        }
    }
}

seededSession, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
	Agent: anthropic.BetaSessionNewParamsAgentUnion{
		OfString: anthropic.String(agent.ID),
	},
	EnvironmentID: environment.ID,
	InitialEvents: []anthropic.BetaSessionNewParamsInitialEventUnion{{
		OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
			Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
			Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
				OfText: &anthropic.BetaManagedAgentsTextBlockParam{
					Type: anthropic.BetaManagedAgentsTextBlockTypeText,
					Text: "List the files in the working directory.",
				},
			}},
		},
	}},
})
if err != nil {
	panic(err)
}
// initial_events are not echoed on the create response, so list the
// session's events to read the seeded user.message back.
seededEvents, err := client.Beta.Sessions.Events.List(ctx, seededSession.ID, anthropic.BetaSessionEventListParams{})
if err != nil {
	panic(err)
}
for _, event := range seededEvents.Data {
	if event.Type != "user.message" {
		continue
	}
	for _, contentBlock := range event.AsUserMessage().Content {
		if contentBlock.Type == "text" {
			fmt.Printf("Seeded event: %s\n", contentBlock.AsText().Text)
		}
	}
}

var seededSession = client.beta().sessions().create(SessionCreateParams.builder()
    .agent(agent.id())
    .environmentId(environment.id())
    .addInitialEvent(BetaManagedAgentsUserMessageEventParams.builder()
        .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
        .addTextContent("List the files in the working directory.")
        .build())
    .build());
// initial_events are not echoed on the create response; list the
// session's events to read the seeded user.message back.
for (var event : client.beta().sessions().events().list(seededSession.id()).autoPager()) {
    if (event.isUserMessage()) {
        for (var contentBlock : event.asUserMessage().content()) {
            if (contentBlock.isText()) {
                IO.println("Seeded event: " + contentBlock.asText().text());
            }
        }
    }
}

$seededSession = $client->beta->sessions->create(
    agent: $agent->id,
    environmentID: $environment->id,
    initialEvents: [
        [
            'type' => 'user.message',
            'content' => [['type' => 'text', 'text' => 'List the files in the working directory.']],
        ],
    ],
);

// initial_events are not echoed on the create response; read them back
// from the session's event list.
$seededEvents = $client->beta->sessions->events->list($seededSession->id);
foreach ($seededEvents->getItems() as $event) {
    if ($event->type === 'user.message') {
        echo "Seeded event: {$event->content[0]->text}\n";
    }
}

seeded_session = client.beta.sessions.create(
  agent: agent.id,
  environment_id: environment.id,
  initial_events: [
    {
      type: :"user.message",
      content: [{type: :text, text: "List the files in the working directory."}]
    }
  ]
)

# initial_events are not echoed on the create response; read them back from
# the session's event list.
client.beta.sessions.events.list(seeded_session.id).auto_paging_each do |event|
  next unless event.type == :"user.message"
  event.content.each do |block|
    puts "Seeded event: #{block.text}" if block.type == :text
  end
end

override_session = client.beta.sessions.create(
    agent={
        "type": "agent_with_overrides",
        "id": agent.id,
        "model": {"id": "claude-sonnet-5"},
        "system": None,  # clear the agent's system prompt for this session
    },
    environment_id=environment.id,
)
# The response's agent is the resolved snapshot with the overrides applied.
print(f"Model: {override_session.agent.model.id}")
print(f"System: {override_session.agent.system}")

const overrideSession = await client.beta.sessions.create({
  agent: {
    type: "agent_with_overrides",
    id: agent.id,
    model: { id: "claude-sonnet-5" },
    system: null // clear the agent's system prompt for this session
  },
  environment_id: environment.id
});
// The response's agent is the resolved snapshot with the overrides applied.
console.log(`Model: ${overrideSession.agent.model.id}`);
console.log(`System: ${overrideSession.agent.system}`);

var overrideSession = await client.Beta.Sessions.Create(new()
{
    Agent = new BetaManagedAgentsAgentWithOverridesParams
    {
        Type = BetaManagedAgentsAgentWithOverridesParamsType.AgentWithOverrides,
        ID = agent.ID,
        Model = new BetaManagedAgentsModelConfigParams
        {
            ID = BetaManagedAgentsModel.ClaudeSonnet5,
        },
        System = null, // clear the agent's system prompt for this session
    },
    EnvironmentID = environment.ID,
});
// The response's agent is the resolved snapshot with the overrides applied.
Console.WriteLine($"Model: {overrideSession.Agent.Model.ID.Raw()}");
Console.WriteLine($"System: {overrideSession.Agent.System ?? "null"}");

overrideSession, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
	Agent: anthropic.BetaSessionNewParamsAgentUnion{
		OfBetaManagedAgentsAgentWithOverridess: &anthropic.BetaManagedAgentsAgentWithOverridesParams{
			Type: anthropic.BetaManagedAgentsAgentWithOverridesParamsTypeAgentWithOverrides,
			ID:   agent.ID,
			Model: anthropic.BetaManagedAgentsModelConfigParams{
				ID: anthropic.BetaManagedAgentsModelClaudeSonnet5,
			},
			// Clear the agent's system prompt for this session.
			System: param.Null[string](),
		},
	},
	EnvironmentID: environment.ID,
})
if err != nil {
	panic(err)
}
// The response's agent is the resolved snapshot with the overrides applied.
fmt.Printf("Model: %s\n", overrideSession.Agent.Model.ID)
fmt.Printf("System: %q\n", overrideSession.Agent.System)

var overrideSession = client.beta().sessions().create(SessionCreateParams.builder()
    .agent(BetaManagedAgentsAgentWithOverridesParams.builder()
        .type(BetaManagedAgentsAgentWithOverridesParams.Type.AGENT_WITH_OVERRIDES)
        .id(agent.id())
        .model(BetaManagedAgentsModelConfigParams.builder()
            .id(BetaManagedAgentsModel.CLAUDE_SONNET_5)
            .build())
        .system((String) null) // clear the agent's system prompt for this session
        .build())
    .environmentId(environment.id())
    .build());
// The response's agent is the resolved snapshot with the overrides applied.
IO.println("Model: " + overrideSession.agent().model().id());
IO.println("System: " + overrideSession.agent().system().orElse("null"));

$overrides = BetaManagedAgentsAgentWithOverridesParams::with(
    id: $agent->id,
    type: 'agent_with_overrides',
    model: ['id' => 'claude-sonnet-5'],
);
// Clear the system prompt for this session. Array access is load-bearing here:
// create() strips nulls from raw arrays and ::with() treats null args as omitted.
$overrides['system'] = null;

$overrideSession = $client->beta->sessions->create(
    agent: $overrides,
    environmentID: $environment->id,
);
// The response's agent is the resolved snapshot with the overrides applied.
echo "Model: {$overrideSession->agent->model->id}\n";
echo 'System: ' . ($overrideSession->agent->system ?? 'null') . "\n";

# The system prompt override is `system_` (trailing underscore) because plain
# `system` is Ruby's Kernel#system. Setting it to nil clears the prompt.
override_session = client.beta.sessions.create(
  agent: Anthropic::Beta::BetaManagedAgentsAgentWithOverridesParams.new(
    type: :agent_with_overrides,
    id: agent.id,
    model: {id: "claude-sonnet-5"},
    system_: nil
  ),
  environment_id: environment.id
)
# The response's agent is the resolved snapshot with the overrides applied.
puts "Model: #{override_session.agent.model.id}"
puts "System: #{override_session.agent.system_.inspect}"

session = client.beta.sessions.create(
    agent={
        "type": "agent_with_overrides",
        "id": agent.id,
        # Replaces the agent's `model` in full: restate `id`, add `inference_geo` to pin.
        "model": {"id": "claude-opus-5-5", "inference_geo": "us"},
    },
    environment_id=environment.id,
)
print(f"Inference geo: {session.agent.model.inference_geo}")

const session = await client.beta.sessions.create({
  agent: {
    type: "agent_with_overrides",
    id: agent.id,
    // Replaces the agent's `model` in full: restate `id`, add `inference_geo` to pin.
    model: { id: "claude-opus-5-5", inference_geo: "us" }
  },
  environment_id: environment.id
});
console.log(`Inference geo: ${session.agent.model.inference_geo}`);

var session = await client.Beta.Sessions.Create(new()
{
    Agent = new BetaManagedAgentsAgentWithOverridesParams
    {
        Type = BetaManagedAgentsAgentWithOverridesParamsType.AgentWithOverrides,
        ID = agent.ID,
        // Replaces the agent's `model` in full: restate `id`, add `inference_geo` to pin.
        Model = new BetaManagedAgentsModelConfigParams
        {
            ID = BetaManagedAgentsModel.ClaudeOpus5_5,
            InferenceGeo = "us",
        },
    },
    EnvironmentID = environment.ID,
});
Console.WriteLine($"Inference geo: {session.Agent.Model.InferenceGeo}");

session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
	Agent: anthropic.BetaSessionNewParamsAgentUnion{
		OfBetaManagedAgentsAgentWithOverridess: &anthropic.BetaManagedAgentsAgentWithOverridesParams{
			Type: anthropic.BetaManagedAgentsAgentWithOverridesParamsTypeAgentWithOverrides,
			ID:   agent.ID,
			// Replaces the agent's `model` in full: restate `id`, add `inference_geo` to pin.
			Model: anthropic.BetaManagedAgentsModelConfigParams{
				ID:           anthropic.BetaManagedAgentsModelClaudeOpus5_5,
				InferenceGeo: anthropic.String("us"),
			},
		},
	},
	EnvironmentID: environment.ID,
})
if err != nil {
	panic(err)
}
fmt.Printf("Inference geo: %s\n", session.Agent.Model.InferenceGeo)

var session = client.beta().sessions().create(SessionCreateParams.builder()
    .agent(BetaManagedAgentsAgentWithOverridesParams.builder()
        .type(BetaManagedAgentsAgentWithOverridesParams.Type.AGENT_WITH_OVERRIDES)
        .id(agent.id())
        // Replaces the agent's `model` in full: restate `id`, add `inference_geo` to pin.
        .model(BetaManagedAgentsModelConfigParams.builder()
            .id(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
            .inferenceGeo("us")
            .build())
        .build())
    .environmentId(environment.id())
    .build());
IO.println("Inference geo: " + session.agent().model().inferenceGeo().orElseThrow());

$session = $client->beta->sessions->create(
    agent: BetaManagedAgentsAgentWithOverridesParams::with(
        id: $agent->id,
        type: 'agent_with_overrides',
        // Replaces the agent's `model` in full: restate `id`, add `inference_geo` to pin.
        model: BetaManagedAgentsModelConfigParams::with(
            id: 'claude-opus-5-5',
            inferenceGeo: 'us',
        ),
    ),
    environmentID: $environment->id,
);
echo "Inference geo: {$session->agent->model->inferenceGeo}\n";

session = client.beta.sessions.create(
  agent: {
    type: :agent_with_overrides,
    id: agent.id,
    # Replaces the agent's `model` in full: restate `id`, add `inference_geo` to pin.
    model: {id: "claude-opus-5-5", inference_geo: "us"}
  },
  environment_id: environment.id
)
puts "Inference geo: #{session.agent.model.inference_geo}"

vault_session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    vault_ids=[vault.id],
)

const vaultSession = await client.beta.sessions.create({
  agent: agent.id,
  environment_id: environment.id,
  vault_ids: [vault.id]
});

var vaultSession = await client.Beta.Sessions.Create(new()
{
    Agent = agent.ID,
    EnvironmentID = environment.ID,
    VaultIds = [vault.ID],
});

vaultSession, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
	Agent: anthropic.BetaSessionNewParamsAgentUnion{
		OfString: anthropic.String(agent.ID),
	},
	EnvironmentID: environment.ID,
	VaultIDs:      []string{vault.ID},
})
if err != nil {
	panic(err)
}

var vaultSession = client.beta().sessions().create(SessionCreateParams.builder()
    .agent(agent.id())
    .environmentId(environment.id())
    .addVaultId(vault.id())
    .build());

$vaultSession = $client->beta->sessions->create(
    agent: $agent->id,
    environmentID: $environment->id,
    vaultIDs: [$vault->id],
);

vault_session = client.beta.sessions.create(
  agent: agent.id,
  environment_id: environment.id,
  vault_ids: [vault.id]
)