---
title: 세션 시작하기
url: https://platform.claude.com/docs/ko/managed-agents/sessions
description: 에이전트를 실행하고 작업 수행을 시작하기 위해 세션을 생성합니다.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

세션은 환경 내의 에이전트 인스턴스입니다. 각 세션은 [에이전트](https://platform.claude.com/docs/ko/managed-agents/agent-setup)와 [환경](https://platform.claude.com/docs/ko/managed-agents/environments)(둘 다 별도로 생성됨)을 참조하며, 여러 상호작용에 걸쳐 대화 기록을 유지합니다. 세션은 2단계 수명 주기를 따릅니다. 먼저 [세션을 생성](https://platform.claude.com/docs/ko/managed-agents/sessions#creating-a-session)한 다음, [사용자 이벤트를 전송](https://platform.claude.com/docs/ko/managed-agents/sessions#starting-the-session)하여 작업을 시작합니다. [`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)](https://platform.claude.com/docs/ko/managed-agents/sessions#seed-the-session-with-initial-events)를 사용하면 두 단계를 하나의 호출로 합칠 수도 있습니다.

## 세션 생성하기

세션에는 `agent` ID와 `environment` ID가 필요합니다. 에이전트는 버전이 관리되는 리소스이며, `agent` (csharp, go: `Agent`) ID를 문자열로 전달하면 최신 에이전트 버전으로 세션이 생성됩니다.

<CodeGroup>
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$ENVIRONMENT_ID"
  ```

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

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

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

  ```go Go
  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)
  }
  ```

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

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

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id
  )
  ```
</CodeGroup>

세션을 특정 에이전트 버전에 고정하려면 객체를 전달하세요. 이를 통해 어떤 버전이 실행될지 정확하게 제어하고 새 버전의 롤아웃을 독립적으로 단계별로 진행할 수 있습니다.

<CodeGroup>
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": {"type": "agent", "id": "'"$AGENT_ID"'", "version": 1},
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  ant beta:sessions create <<YAML
  agent:
    type: agent
    id: $AGENT_ID
    version: 1
  environment_id: $ENVIRONMENT_ID
  YAML
  ```

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

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

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

  ```go Go
  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)
  }
  ```

  ```java Java
  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());
  ```

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

  ```ruby Ruby
  pinned_session = client.beta.sessions.create(
    agent: {type: :agent, id: agent.id, version: 1},
    environment_id: environment.id
  )
  ```
</CodeGroup>

### 초기 이벤트로 세션 시작하기

하나의 호출로 세션을 생성하고 작업을 시작할 수 있습니다. `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)는 생성 시 세션에 전송할 초기 [이벤트](https://platform.claude.com/docs/ko/managed-agents/reference#event-types)의 선택적 배열이며, 순서대로 처리됩니다. `user.message` 및 [`user.define_outcome`](https://platform.claude.com/docs/ko/managed-agents/define-outcomes) 이벤트를 지원하며, 최대 50개의 이벤트를 허용합니다. 비어 있지 않은 목록은 같은 호출에서 에이전트 루프를 시작합니다. 즉, 추가 요청 없이 세션이 바로 `running` 상태로 생성됩니다.

다음 예제는 `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)에 단일 `user.message`를 포함하여 세션을 생성합니다:

<CodeGroup>
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'",
      "initial_events": [
        {
          "type": "user.message",
          "content": [{"type": "text", "text": "List the files in the working directory."}]
        }
      ]
    }'
  ```

  ```bash CLI
  ant beta:sessions create <<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
  ```

  ```python Python
  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는 생성 응답에 에코되지 않으므로 세션의
  # 이벤트 목록에서 다시 읽어옵니다.
  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}")
  ```

  ```typescript TypeScript
  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는 생성 응답에 에코되지 않으므로 세션의 이벤트를
  // 나열하여 시드된 메시지를 다시 읽습니다.
  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}`);
        }
      }
    }
  }
  ```

  ```csharp C#
  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는 생성 응답에 에코되지 않으므로 세션의 이벤트
  // 목록에서 다시 읽어옵니다.
  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}");
              }
          }
      }
  }
  ```

  ```go Go
  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는 생성 응답에 포함되지 않으므로 세션의 이벤트를
  // 나열하여 시드된 user.message를 다시 읽습니다.
  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)
  		}
  	}
  }
  ```

  ```java Java
  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는 생성 응답에 다시 표시되지 않으므로, 세션의
  // 이벤트를 나열하여 시드된 user.message를 다시 읽습니다.
  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());
              }
          }
      }
  }
  ```

  ```php PHP
  $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는 생성 응답에 그대로 반환되지 않으므로 세션의
  // 이벤트 목록에서 다시 읽어옵니다.
  $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";
      }
  }
  ```

  ```ruby Ruby
  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는 생성 응답에 에코되지 않으므로 세션의 이벤트
  # 목록에서 다시 읽어옵니다.
  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
  ```
</CodeGroup>

`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)는 생성 응답에 다시 포함되지 않습니다. 초기 이벤트로 전송한 메시지를 확인하려면 세션의 이벤트 목록을 조회하세요.

다른 이벤트 유형은 허용되지 않습니다. 에이전트 턴에 응답하는 이벤트(`user.tool_confirmation`, `user.tool_result`, `user.custom_tool_result`)는 아직 에이전트 턴이 존재하지 않으므로 허용되지 않으며, `user.interrupt`는 중지할 턴이 없으므로 허용되지 않습니다. 예약된 배포의 `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)와 달리, 세션의 `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)는 `system.message`를 허용하지 않습니다.

`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)의 각 이벤트는 생성 응답이 반환되기 전에 목록 순서대로 검증되고 서버가 할당한 ID와 함께 저장되며, 이는 생성 직후 [이벤트 전송](https://platform.claude.com/docs/ko/managed-agents/events-and-streaming#send-events) 엔드포인트에 게시한 것과 정확히 동일합니다. 이벤트별 콘텐츠 규칙도 해당 엔드포인트와 동일합니다. 빈 목록은 필드를 생략한 것과 같습니다. 검증은 전부 아니면 전무 방식입니다. 어떤 이벤트라도 검증에 실패하면 전체 요청이 거부되고 세션이 생성되지 않습니다.

생성 요청은 다음과 같은 경우에 거부됩니다:

| 조건                                                                                                                        | 상태  |
| ------------------------------------------------------------------------------------------------------------------------- | --- |
| 두 개 이상의 `user.define_outcome` 이벤트                                                                                         | 400 |
| `rubric`이 없는 `user.define_outcome` 이벤트                                                                                    | 400 |
| 전체 목록에 걸쳐 파일 기반 [`document` 콘텐츠 블록](https://platform.claude.com/docs/ko/build-with-claude/files#document-blocks)이 100개 초과 | 400 |
| 32 MB를 초과하는 요청 본문                                                                                                         | 413 |

`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)의 `user.define_outcome` 이벤트는 기존 세션에 전송하는 경우와 동일한 조건에서 허용됩니다. [결과 정의하기](https://platform.claude.com/docs/ko/managed-agents/define-outcomes)를 참조하세요.

### 세션에 대한 에이전트 구성 재정의하기

`agent` (csharp, go: `Agent`)는 세 가지 형태로 전달할 수 있습니다. 에이전트 ID 문자열, 고정 버전 객체(`type: "agent"`), 또는 재정의 객체(`type: "agent_with_overrides"`)입니다. 재정의 형태는 단일 세션에 대해 에이전트 구성의 일부를 변경합니다. 에이전트의 버전을 새로 만들지 않고 한 세션에서 다른 모델을 시도하거나 추가 도구를 부여할 때 사용하세요. 재정의 형태의 경우 에이전트의 `id` (csharp, go: `ID`)와 선택적으로 `version` (csharp, go: `Version`)을 전달하세요(에이전트의 최신 버전을 사용하려면 `version` (csharp, go: `Version`)을 생략하세요). 그런 다음 세션에서 사용할 값과 함께 `model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`), `tools` (csharp, go: `Tools`), `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`), 또는 `skills` (csharp, go: `Skills`) 중 원하는 항목을 포함하세요.

재정의 가능한 각 필드는 동일한 세 가지 규칙을 따릅니다:

* **필드 생략:** 세션은 참조하는 에이전트 버전의 값을 상속합니다.

* **필드를 `null`로 설정하거나, 목록 필드의 경우 빈 배열로 설정:** 세션은 해당 필드가 비워진 상태로 실행됩니다. 이 규칙은 `system` (csharp, go: `System`; ruby: `system_`)와 `skills` (csharp, go: `Skills`)에 완전히 적용됩니다. 세 가지 예외가 있습니다:

  * `model`은 절대 비울 수 없습니다. 세션에는 항상 모델이 필요하므로 `model: null`은 400 `agent_model_required` 오류를 반환합니다.
  * 세션의 유효 `skills` (csharp, go: `Skills`)가 비어 있지 않은 경우 `tools`를 비우면 400 오류가 반환됩니다. 스킬에는 `read` 도구가 필요하기 때문입니다. 그렇지 않은 경우 `tools: null`과 `tools: []`는 필드를 비웁니다.
  * 세션의 유효 `tools` (csharp, go: `Tools`)에 에이전트의 서버 중 하나를 참조하는 `mcp_toolset`이 여전히 포함되어 있는 경우 `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`)를 비우면 400 오류가 반환됩니다. 같은 요청에서 `tools` (csharp, go: `Tools`)를 재정의하여 해당 `mcp_toolset` 항목을 제거한 다음 `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`)를 비우세요.

* **필드를 값으로 설정:** 해당 값이 에이전트의 값을 완전히 대체합니다. 재정의는 에이전트의 구성과 병합되지 않으므로, `tools` (csharp, go: `Tools`) 재정의에는 세션이 가져야 할 모든 도구를 나열해야 합니다. 마찬가지로 `model` (csharp, go: `Model`) 재정의는 에이전트의 `model` (csharp, go: `Model`) 객체를 완전히 대체하므로, 에이전트 자체의 `effort` (csharp, go: `Effort`)는 이어지지 않습니다. 특정 effort 수준으로 세션을 실행하려면 재정의의 `model` (csharp, go: `Model`) 객체 안에 `effort` (csharp, go: `Effort`)를 설정하세요. 모델이 지원하지 않는 수준은 400 오류를 반환하며, `effort` (csharp, go: `Effort`)가 없는 `model` (csharp, go: `Model`) 재정의는 해당 모델의 기본 effort 수준으로 실행됩니다.

재정의는 생성하는 세션에만 적용됩니다. 에이전트 리소스를 수정하거나 새 에이전트 버전을 생성하지 않으므로, 같은 에이전트를 참조하는 다른 세션은 영향을 받지 않습니다.

응답에서 `agent` (csharp, go: `Agent`) 객체는 재정의가 적용된 후 세션이 실행되는 구성을 반영합니다. 해당 객체의 `id` (csharp, go: `ID`)와 `version` (csharp, go: `Version`)은 여전히 재정의가 적용된 에이전트와 버전을 식별합니다. 이를 통해 세션을 기본 에이전트까지 추적할 수 있습니다.

다음 예제는 모델을 재정의하고 시스템 프롬프트를 비우는 세션을 시작합니다:

<CodeGroup>
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": {
        "type": "agent_with_overrides",
        "id": "'"$AGENT_ID"'",
        "model": {"id": "claude-sonnet-5-5"},
        "system": null
      },
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  # 응답의 `agent`는 해석된 스냅샷입니다. 각 오버라이드는 이 세션에 대해서만
  # 해당 필드를 대체하며, 에이전트 리소스는 id와 버전을 유지합니다.
  ant beta:sessions create <<YAML
  agent:
    type: agent_with_overrides
    id: $AGENT_ID
    model:
      id: claude-sonnet-5-5
    system: null
  environment_id: $ENVIRONMENT_ID
  YAML
  ```

  ```python Python
  override_session = client.beta.sessions.create(
      agent={
          "type": "agent_with_overrides",
          "id": agent.id,
          "model": {"id": "claude-sonnet-5-5"},
          "system": None,  # clear the agent's system prompt for this session
      },
      environment_id=environment.id,
  )
  # 응답의 agent는 재정의가 적용된 확정 스냅샷입니다.
  print(f"Model: {override_session.agent.model.id}")
  print(f"System: {override_session.agent.system}")
  ```

  ```typescript TypeScript
  const overrideSession = await client.beta.sessions.create({
    agent: {
      type: "agent_with_overrides",
      id: agent.id,
      model: { id: "claude-sonnet-5-5" },
      system: null // clear the agent's system prompt for this session
    },
    environment_id: environment.id
  });
  // 응답의 agent는 재정의가 적용되어 해석된 스냅샷입니다.
  console.log(`Model: ${overrideSession.agent.model.id}`);
  console.log(`System: ${overrideSession.agent.system}`);
  ```

  ```csharp C#
  var overrideSession = await client.Beta.Sessions.Create(new()
  {
      Agent = new BetaManagedAgentsAgentWithOverridesParams
      {
          Type = BetaManagedAgentsAgentWithOverridesParamsType.AgentWithOverrides,
          ID = agent.ID,
          Model = new BetaManagedAgentsModelConfigParams
          {
              ID = BetaManagedAgentsModel.ClaudeSonnet5_5,
          },
          System = null, // clear the agent's system prompt for this session
      },
      EnvironmentID = environment.ID,
  });
  // 응답의 에이전트는 재정의가 적용된 확정 스냅샷입니다.
  Console.WriteLine($"Model: {overrideSession.Agent.Model.ID.Raw()}");
  Console.WriteLine($"System: {overrideSession.Agent.System ?? "null"}");
  ```

  ```go Go
  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_5,
  			},
  			// 이 세션에 대한 에이전트의 시스템 프롬프트를 지웁니다.
  			System: param.Null[string](),
  		},
  	},
  	EnvironmentID: environment.ID,
  })
  if err != nil {
  	panic(err)
  }
  // 응답의 agent는 오버라이드가 적용된 확정 스냅샷입니다.
  fmt.Printf("Model: %s\n", overrideSession.Agent.Model.ID)
  fmt.Printf("System: %q\n", overrideSession.Agent.System)
  ```

  ```java Java
  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_5)
              .build())
          .system((String) null) // clear the agent's system prompt for this session
          .build())
      .environmentId(environment.id())
      .build());
  // 응답의 agent는 재정의가 적용된 확정 스냅샷입니다.
  IO.println("Model: " + overrideSession.agent().model().id());
  IO.println("System: " + overrideSession.agent().system().orElse("null"));
  ```

  ```php PHP
  $overrides = BetaManagedAgentsAgentWithOverridesParams::with(
      id: $agent->id,
      type: 'agent_with_overrides',
      model: ['id' => 'claude-sonnet-5-5'],
  );
  // 이 세션의 시스템 프롬프트를 지웁니다. 여기서는 배열 접근이 핵심입니다:
  // create()는 원시 배열에서 null을 제거하고 ::with()는 null 인수를 생략된 것으로 처리합니다.
  $overrides['system'] = null;

  $overrideSession = $client->beta->sessions->create(
      agent: $overrides,
      environmentID: $environment->id,
  );
  // 응답의 agent는 재정의가 적용되어 해석된 스냅샷입니다.
  echo "Model: {$overrideSession->agent->model->id}\n";
  echo 'System: ' . ($overrideSession->agent->system ?? 'null') . "\n";
  ```

  ```ruby Ruby
  # 시스템 프롬프트 재정의는 `system_`(밑줄 접미사)입니다. 일반 `system`은
  # Ruby의 Kernel#system이기 때문입니다. nil로 설정하면 프롬프트가 지워집니다.
  override_session = client.beta.sessions.create(
    agent: Anthropic::Beta::BetaManagedAgentsAgentWithOverridesParams.new(
      type: :agent_with_overrides,
      id: agent.id,
      model: {id: "claude-sonnet-5-5"},
      system_: nil
    ),
    environment_id: environment.id
  )
  # 응답의 에이전트는 재정의가 적용된 확정 스냅샷입니다.
  puts "Model: #{override_session.agent.model.id}"
  puts "System: #{override_session.agent.system_.inspect}"
  ```
</CodeGroup>

#### 세션의 추론 지역 고정하기

`model` (csharp, go: `Model`) 재정의는 에이전트의 `model` (csharp, go: `Model`) 객체를 완전히 대체하므로, 세션에 대한 모델의 [inference geo](https://platform.claude.com/docs/ko/manage-claude/data-residency)(추론 지역) 고정도 설정하거나 해제합니다. `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`)를 포함하는 재정의는 세션의 모델 요청을 처리하는 지역을 고정하고, 이를 생략하는 재정의는 에이전트의 고정을 해제하여 세션이 워크스페이스의 `default_inference_geo`를 따르도록 합니다. 재정의된 값은 세션이 생성될 때 워크스페이스의 `allowed_inference_geos`에 대해 검증됩니다.

다음 예제는 모델에 지역 고정이 없는 에이전트로부터 세션을 시작하고, `model` (csharp, go: `Model`) 재정의에 `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`)를 포함하여 세션의 모델 요청을 US 추론으로 고정합니다. 응답은 `agent.model` (csharp, go: `Agent.Model`)에 해당 값을 반환합니다:

<CodeGroup>
  ```bash cURL
  # 에이전트의 모델 객체 전체를 대체합니다: id를 다시 명시하고 inference_geo를 추가하여 고정합니다.
  curl -fsSL https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": {
        "type": "agent_with_overrides",
        "id": "'"$AGENT_ID"'",
        "model": {"id": "claude-opus-5-5", "inference_geo": "us"}
      },
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  # 에이전트의 모델 객체 전체를 대체합니다: id를 다시 명시하고 inference_geo를 추가하여 고정합니다.
  ant beta:sessions create <<YAML
  agent:
    type: agent_with_overrides
    id: $AGENT_ID
    model:
      id: claude-opus-5-5
      inference_geo: us
  environment_id: $ENVIRONMENT_ID
  YAML
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent={
          "type": "agent_with_overrides",
          "id": agent.id,
          # 에이전트의 `model`을 완전히 대체: `id`를 다시 명시하고 `inference_geo`를 추가해 고정합니다.
          "model": {"id": "claude-opus-5-5", "inference_geo": "us"},
      },
      environment_id=environment.id,
  )
  print(f"Inference geo: {session.agent.model.inference_geo}")
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: {
      type: "agent_with_overrides",
      id: agent.id,
      // 에이전트의 `model`을 완전히 대체합니다: `id`를 다시 명시하고 `inference_geo`를 추가해 고정하세요.
      model: { id: "claude-opus-5-5", inference_geo: "us" }
    },
    environment_id: environment.id
  });
  console.log(`Inference geo: ${session.agent.model.inference_geo}`);
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = new BetaManagedAgentsAgentWithOverridesParams
      {
          Type = BetaManagedAgentsAgentWithOverridesParamsType.AgentWithOverrides,
          ID = agent.ID,
          // 에이전트의 `model`을 완전히 대체합니다: `id`를 다시 명시하고 고정을 위해 `inference_geo`를 추가하세요.
          Model = new BetaManagedAgentsModelConfigParams
          {
              ID = BetaManagedAgentsModel.ClaudeOpus5_5,
              InferenceGeo = "us",
          },
      },
      EnvironmentID = environment.ID,
  });
  Console.WriteLine($"Inference geo: {session.Agent.Model.InferenceGeo}");
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfBetaManagedAgentsAgentWithOverridess: &anthropic.BetaManagedAgentsAgentWithOverridesParams{
  			Type: anthropic.BetaManagedAgentsAgentWithOverridesParamsTypeAgentWithOverrides,
  			ID:   agent.ID,
  			// 에이전트의 `model`을 완전히 대체: `id`를 다시 명시하고 고정을 위해 `inference_geo`를 추가합니다.
  			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)
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(BetaManagedAgentsAgentWithOverridesParams.builder()
          .type(BetaManagedAgentsAgentWithOverridesParams.Type.AGENT_WITH_OVERRIDES)
          .id(agent.id())
          // 에이전트의 `model`을 완전히 대체합니다: `id`를 다시 명시하고 `inference_geo`를 추가해 고정합니다.
          .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());
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: BetaManagedAgentsAgentWithOverridesParams::with(
          id: $agent->id,
          type: 'agent_with_overrides',
          // 에이전트의 `model`을 완전히 대체합니다: `id`를 다시 명시하고 고정을 위해 `inference_geo`를 추가하세요.
          model: BetaManagedAgentsModelConfigParams::with(
              id: 'claude-opus-5-5',
              inferenceGeo: 'us',
          ),
      ),
      environmentID: $environment->id,
  );
  echo "Inference geo: {$session->agent->model->inferenceGeo}\n";
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: {
      type: :agent_with_overrides,
      id: agent.id,
      # 에이전트의 `model`을 완전히 대체: `id`를 다시 명시하고 `inference_geo`를 추가해 고정합니다.
      model: {id: "claude-opus-5-5", inference_geo: "us"}
    },
    environment_id: environment.id
  )
  puts "Inference geo: #{session.agent.model.inference_geo}"
  ```
</CodeGroup>

<Tip>
  에이전트는 모델, 시스템 프롬프트, 도구, MCP 서버를 포함하여 세션 내에서 Claude가 어떻게 동작하는지 정의합니다. 자세한 내용은 [에이전트 정의하기](https://platform.claude.com/docs/ko/managed-agents/agent-setup)를 참조하세요.
</Tip>

### 세션 예산 설정하기

세션이 지출할 수 있는 금액에 상한을 두려면 세션을 생성할 때 선택적 `budget` (csharp, go: `Budget`) 객체를 전달하세요. "Budget"(예산)은 세션의 정가 비용에 대한 엄격한 상한입니다. 플랫폼은 세션이 소비하는 모든 것을 공개 정가 요율로 책정하며, 누적 합계가 `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`)에 도달하면 세션은 새 모델 요청을 더 이상 보내지 않습니다. 예산의 `type` (csharp, go: `Type`)은 항상 `limit`입니다. `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`)에 `amount` (csharp, go: `Amount`)와 `currency` (csharp, go: `Currency`)를 지정하세요. `amount` (csharp, go: `Amount`)는 문자열로 작성된 미국 센트 단위의 정수이며, 예를 들어 $1.25는 `"125"`입니다. API는 부동 소수점 반올림이 절대 적용되지 않도록 숫자 대신 문자열을 받습니다. 현재 지원되는 통화는 `USD`뿐입니다. 세션이 상한에 도달하면 일시 중지되고 중지 사유 `budget_reached`와 함께 유휴 상태가 됩니다. 상한은 모델 요청 사이에 적용되므로, 상한을 넘는 요청이 먼저 완료되며 세션의 최종 정가 비용은 [상한을 약간 초과](https://platform.claude.com/docs/ko/managed-agents/budgets#when-a-session-reaches-its-budget)할 수 있습니다. 예산은 생성 시에만 연결할 수 있습니다. 나중에 [변경하거나 제거](https://platform.claude.com/docs/ko/managed-agents/session-operations#updating-the-session-budget)할 수는 있지만, 예산 없이 생성된 세션에 예산을 추가할 수는 없습니다.

다음 예제는 $1.25 예산으로 세션을 생성합니다:

<CodeGroup>
  ```bash cURL
  curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'",
      "budget": {
        "type": "limit",
        "max_list_cost": {"amount": "125", "currency": "USD"}
      }
    }'
  ```

  ```bash CLI
  # 금액이 숫자가 아닌 문자열로 전송되도록 따옴표를 유지하세요.
  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$ENVIRONMENT_ID" \
    --budget '{type: limit, max_list_cost: {amount: "125", currency: USD}}'
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      budget={
          "type": "limit",
          "max_list_cost": {"amount": "125", "currency": "USD"},
      },
  )
  print(session.id, session.budget.max_list_cost.amount)  # sesn_01... 125
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    budget: {
      type: "limit",
      max_list_cost: { amount: "125", currency: "USD" }
    }
  });
  console.log(session.id, session.budget?.max_list_cost.amount); // sesn_01... 125
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Budget = new()
      {
          Type = BetaManagedAgentsBudgetLimitType.Limit,
          MaxListCost = new() { Amount = "125", Currency = BetaCurrency.Usd },
      },
  });
  Console.WriteLine($"{session.ID} {session.Budget?.MaxListCost.Amount}");  // sesn_01... 125
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  	Budget: anthropic.BetaManagedAgentsBudgetLimitParam{
  		Type: anthropic.BetaManagedAgentsBudgetLimitTypeLimit,
  		MaxListCost: anthropic.BetaMonetaryAmountParam{
  			Amount:   "125",
  			Currency: anthropic.BetaCurrencyUsd,
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(session.ID, session.Budget.MaxListCost.Amount) // sesn_01... 125
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .budget(BetaManagedAgentsBudgetLimit.builder()
          .type(BetaManagedAgentsBudgetLimit.Type.LIMIT)
          .maxListCost(BetaMonetaryAmount.builder()
              .amount("125")
              .currency(BetaCurrency.USD)
              .build())
          .build())
      .build());
  IO.println(session.id() + " " + session.budget().orElseThrow().maxListCost().amount());  // sesn_01... 125
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      budget: [
          'type' => 'limit',
          'max_list_cost' => ['amount' => '125', 'currency' => 'USD'],
      ],
  );
  echo "{$session->id} {$session->budget->maxListCost->amount}\n"; // sesn_01... 125
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    budget: {
      type: "limit",
      max_list_cost: {amount: "125", currency: "USD"}
    }
  )
  puts "#{session.id} #{session.budget.max_list_cost.amount}" # sesn_01... 125
  ```
</CodeGroup>

적용 방식, 정가 비용에 포함되는 항목, 멀티에이전트 세션에서 예산이 동작하는 방식은 [세션 예산](https://platform.claude.com/docs/ko/managed-agents/budgets)을 참조하세요.

## 볼트를 통한 MCP 인증

에이전트가 인증이 필요한 MCP 도구를 사용하는 경우, 세션 생성 시 `vault_ids` (java: `vaultIds`; php: `vaultIDs`; csharp: `VaultIds`; go: `VaultIDs`)를 전달하여 저장된 OAuth 자격 증명이 포함된 볼트를 참조하세요. Anthropic이 사용자를 대신하여 토큰 갱신을 관리합니다. 볼트를 생성하고 자격 증명을 등록하는 방법은 [볼트로 인증하기](https://platform.claude.com/docs/ko/managed-agents/vaults)를 참조하세요.

<CodeGroup>
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'",
      "vault_ids": ["'"$VAULT_ID"'"]
    }'
  ```

  ```bash CLI
  ant beta:sessions create <<YAML
  agent: $AGENT_ID
  environment_id: $ENVIRONMENT_ID
  vault_ids:
    - $VAULT_ID
  YAML
  ```

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

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

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

  ```go Go
  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)
  }
  ```

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

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

  ```ruby Ruby
  vault_session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    vault_ids: [vault.id]
  )
  ```
</CodeGroup>

## 세션 시작하기

`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) 없이 세션을 생성하면 세션이 등록되지만 어떤 작업도 시작되지 않습니다. 환경의 샌드박스는 세션이 생성되는 즉시 프로비저닝을 시작하므로, 첫 번째 도구 호출이 이를 기다리지 않습니다. 작업을 위임하려면 [사용자 이벤트](https://platform.claude.com/docs/ko/managed-agents/reference#event-types)를 사용하여 세션에 이벤트를 전송하세요. 대신 생성 요청에서 첫 번째 이벤트를 제공하려면 [초기 이벤트로 세션 시작하기](https://platform.claude.com/docs/ko/managed-agents/sessions#seed-the-session-with-initial-events)를 참조하세요. 세션은 진행 상황을 추적하는 상태 머신 역할을 하며, 이벤트가 실제 실행을 주도합니다.

<CodeGroup>
  ```bash cURL
  curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "events": [
        {
          "type": "user.message",
          "content": [{"type": "text", "text": "List the files in the working directory."}]
        }
      ]
    }'
  ```

  ```bash CLI
  ant beta:sessions:events send \
    --session-id "$SESSION_ID" <<'YAML'
  events:
    - type: user.message
      content:
        - type: text
          text: List the files in the working directory.
  YAML
  ```

  ```python Python
  client.beta.sessions.events.send(
      session.id,
      events=[
          {
              "type": "user.message",
              "content": [
                  {"type": "text", "text": "List the files in the working directory."}
              ],
          },
      ],
  )
  ```

  ```typescript TypeScript
  await client.beta.sessions.events.send(session.id, {
    events: [
      {
        type: "user.message",
        content: [{ type: "text", text: "List the files in the working directory." }]
      }
    ]
  });
  ```

  ```csharp C#
  await client.Beta.Sessions.Events.Send(session.ID, new()
  {
      Events =
      [
          new BetaManagedAgentsUserMessageEventParams
          {
              Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
              Content =
              [
                  new BetaManagedAgentsTextBlock
                  {
                      Type = BetaManagedAgentsTextBlockType.Text,
                      Text = "List the files in the working directory.",
                  },
              ],
          },
      ],
  });
  ```

  ```go Go
  if _, err := client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
  	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
  		OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
  			Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
  			Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
  				OfText: &anthropic.BetaManagedAgentsTextBlockParam{
  					Type: anthropic.BetaManagedAgentsTextBlockTypeText,
  					Text: "List the files in the working directory.",
  				},
  			}},
  		},
  	}},
  }); err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().events().send(
      session.id(),
      EventSendParams.builder()
          .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
              .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
              .addTextContent("List the files in the working directory.")
              .build())
          .build());
  ```

  ```php PHP
  $client->beta->sessions->events->send(
      $session->id,
      events: [
          [
              'type' => 'user.message',
              'content' => [['type' => 'text', 'text' => 'List the files in the working directory.']],
          ],
      ],
  );
  ```

  ```ruby Ruby
  client.beta.sessions.events.send_(
    session.id,
    events: [
      {
        type: :"user.message",
        content: [{type: :text, text: "List the files in the working directory."}]
      }
    ]
  )
  ```
</CodeGroup>

에이전트의 응답을 스트리밍하고 도구 확인을 처리하는 방법은 [세션 이벤트 스트림](https://platform.claude.com/docs/ko/managed-agents/events-and-streaming)을 참조하세요.

세션이 거치는 상태에 대해서는 [세션 상태](https://platform.claude.com/docs/ko/managed-agents/session-operations#session-statuses)를 참조하세요.

## 다음 단계

<CardGroup cols={3}>
  <Card title="세션 작업" icon="settings" href="https://platform.claude.com/docs/ko/managed-agents/session-operations">
    Claude Managed Agents 세션을 조회, 나열, 업데이트, 보관 및 삭제합니다.
  </Card>

  <Card title="세션 이벤트 스트림" icon="lightning" href="https://platform.claude.com/docs/ko/managed-agents/events-and-streaming">
    이벤트를 전송하고, 응답을 스트리밍하며, 실행 중인 세션을 중단하거나 방향을 전환합니다.
  </Card>

  <Card title="예약된 배포" icon="arrows-clockwise" href="https://platform.claude.com/docs/ko/managed-agents/scheduled-deployments">
    Claude API로 배포를 생성하고 관리합니다. 반복되는 cron 일정에 따라 에이전트를 실행하고 실행 기록을 검사합니다.
  </Card>
</CardGroup>