---
title: Запуск сеанса
url: https://platform.claude.com/docs/ru/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
---

«Session» (сеанс) — это экземпляр агента внутри среды. Каждый сеанс ссылается на [агента](https://platform.claude.com/docs/ru/managed-agents/agent-setup) и [среду](https://platform.claude.com/docs/ru/managed-agents/environments) (оба создаются отдельно) и сохраняет историю разговора на протяжении нескольких взаимодействий. Сеансы следуют двухэтапному жизненному циклу: сначала [создайте сеанс](https://platform.claude.com/docs/ru/managed-agents/sessions#creating-a-session), затем [отправьте пользовательское событие](https://platform.claude.com/docs/ru/managed-agents/sessions#starting-the-session), чтобы начать работу. Вы также можете объединить оба шага в один вызов с помощью [`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)](https://platform.claude.com/docs/ru/managed-agents/sessions#seed-the-session-with-initial-events).

## Создание сеанса

Для сеанса требуются ID `agent` и ID `environment`. Агенты — это версионируемые ресурсы; передача ID `agent` (csharp, go: `Agent`) в виде строки создаёт сеанс с последней версией агента.

<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/ru/managed-agents/reference#event-types), отправляемых в сеанс при создании и обрабатываемых по порядку. Он поддерживает события `user.message` и [`user.define_outcome`](https://platform.claude.com/docs/ru/managed-agents/define-outcomes) и принимает не более 50 событий. Непустой список запускает цикл агента в том же вызове: сеанс создаётся сразу в статусе `running`, без дополнительного запроса.

В следующем примере создаётся сеанс с одним `user.message` в `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`):

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

Никакие другие типы событий не принимаются. События, отвечающие на ход агента (`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/ru/managed-agents/events-and-streaming#send-events) сразу после создания. Правила содержимого для каждого события также совпадают с правилами этого эндпоинта. Пустой список эквивалентен отсутствию поля. Проверка выполняется по принципу «всё или ничего»: если какое-либо событие не проходит проверку, весь запрос отклоняется и сеанс не создаётся.

Запрос на создание отклоняется в следующих случаях:

| Условие                                                                                                                                         | Статус |
| ----------------------------------------------------------------------------------------------------------------------------------------------- | ------ |
| Более одного события `user.define_outcome`                                                                                                      | 400    |
| Событие `user.define_outcome` без `rubric`                                                                                                      | 400    |
| Более 100 [блоков содержимого `document`](https://platform.claude.com/docs/ru/build-with-claude/files#document-blocks) из файлов во всём списке | 400    |
| Тело запроса размером более 32 МБ                                                                                                               | 413    |

Событие `user.define_outcome` в `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) принимается на тех же условиях, что и при отправке в существующий сеанс; см. [Определение результатов](https://platform.claude.com/docs/ru/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`.
  * Очистка `tools` возвращает ошибку 400, если действующее значение `skills` (csharp, go: `Skills`) сеанса непустое, поскольку навыкам требуется инструмент `read`. В остальных случаях `tools: null` и `tools: []` очищают поле.
  * Очистка `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) возвращает ошибку 400, если действующее значение `tools` (csharp, go: `Tools`) сеанса всё ещё содержит `mcp_toolset`, ссылающийся на один из серверов агента. Переопределите `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` (csharp, go: `Effort`) внутри объекта `model` (csharp, go: `Model`) переопределения. Уровень, который модель не поддерживает, возвращает ошибку 400, а переопределение `model` (csharp, go: `Model`) без `effort` (csharp, go: `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
  # The response's `agent` is the resolved snapshot: each override replaces that
  # field for this session only, and the agent resource keeps its id and version.
  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,
  )
  # Агент в ответе — это разрешённый снимок с применёнными переопределениями.
  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
  });
  // Агент в ответе — это разрешённый снимок с применёнными переопределениями.
  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());
  // Агент в ответе — это разрешённый снимок с применёнными переопределениями.
  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,
  );
  // Агент в ответе — это разрешённый снимок с применёнными переопределениями.
  echo "Model: {$overrideSession->agent->model->id}\n";
  echo 'System: ' . ($overrideSession->agent->system ?? 'null') . "\n";
  ```

  ```ruby Ruby
  # Переопределение системной подсказки — `system_` (с подчёркиванием в конце), потому что
  # просто `system` — это Kernel#system в Ruby. Установка в 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/ru/manage-claude/data-residency) модели для сеанса: переопределение, включающее `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`), закрепляет географию, обслуживающую запросы к модели в сеансе, а переопределение без него очищает закрепление агента, так что сеанс следует значению `default_inference_geo` рабочего пространства. Переопределённое значение проверяется по `allowed_inference_geos` рабочего пространства при создании сеанса.

В следующем примере запускается сеанс от агента, модель которого не имеет закрепления географии, запросы к модели в сеансе закрепляются за инференсом в США путём включения `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) в переопределение `model` (csharp, go: `Model`), и выводится значение, возвращённое в `agent.model` (csharp, go: `Agent.Model`) ответа:

<CodeGroup>
  ```bash cURL
  # Replaces the whole model object of the agent: restate id, add inference_geo to pin.
  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
  # Replaces the whole model object of the agent: restate id, add inference_geo to pin.
  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>
  Агент определяет, как Claude ведёт себя в сеансе, включая модель, системную подсказку, инструменты и серверы MCP. Подробнее см. в разделе [Определение агента](https://platform.claude.com/docs/ru/managed-agents/agent-setup).
</Tip>

### Установка бюджета сеанса

Чтобы ограничить расходы сеанса, передайте необязательный объект `budget` (csharp, go: `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`) — это целое число центов США, записанное в виде строки, например `"125"` для $1,25. API принимает строку, а не число, чтобы никогда не применялось округление с плавающей запятой. `USD` — единственная поддерживаемая в настоящее время валюта. Когда сеанс достигает лимита, он приостанавливается и переходит в состояние простоя с причиной остановки `budget_reached`. Лимит применяется между запросами к модели, поэтому запрос, который его превышает, сначала завершается, и итоговая прейскурантная стоимость сеанса может оказаться [немного выше лимита](https://platform.claude.com/docs/ru/managed-agents/budgets#when-a-session-reaches-its-budget). Бюджет можно прикрепить только при создании: позже вы можете [изменить или удалить](https://platform.claude.com/docs/ru/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/ru/managed-agents/budgets), чтобы узнать, как работает применение лимита, что учитывается в прейскурантной стоимости и как бюджеты ведут себя в многоагентных сеансах.

## Аутентификация MCP через хранилища

Если ваш агент использует инструменты MCP, требующие аутентификации, передайте `vault_ids` (java: `vaultIds`; php: `vaultIDs`; csharp: `VaultIds`; go: `VaultIDs`) при создании сеанса, чтобы сослаться на «vault» (хранилище), содержащее сохранённые учётные данные OAuth. Anthropic управляет обновлением токенов от вашего имени. См. [Аутентификация с помощью хранилищ](https://platform.claude.com/docs/ru/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`) регистрирует сеанс, но не запускает никакой работы; «sandbox» (песочница) среды начинает подготовку сразу после создания сеанса, поэтому первый вызов инструмента не ждёт её. Чтобы делегировать задачу, отправьте события в сеанс с помощью [пользовательского события](https://platform.claude.com/docs/ru/managed-agents/reference#event-types). Чтобы вместо этого передать первое событие в запросе на создание, см. [Заполнение сеанса начальными событиями](https://platform.claude.com/docs/ru/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/ru/managed-agents/events-and-streaming), чтобы узнать, как использовать потоковую передачу ответов агента и обрабатывать подтверждения инструментов.

См. [Статусы сеанса](https://platform.claude.com/docs/ru/managed-agents/session-operations#session-statuses), чтобы узнать, через какие статусы проходит сеанс.

## Следующие шаги

<CardGroup cols={3}>
  <Card title="Операции с сеансами" icon="settings" href="https://platform.claude.com/docs/ru/managed-agents/session-operations">
    Получение, перечисление, обновление, архивирование и удаление сеансов Claude Managed Agents.
  </Card>

  <Card title="Поток событий сеанса" icon="lightning" href="https://platform.claude.com/docs/ru/managed-agents/events-and-streaming">
    Отправляйте события, получайте ответы в режиме потоковой передачи, а также прерывайте или перенаправляйте сеанс во время выполнения.
  </Card>

  <Card title="Развёртывания по расписанию" icon="arrows-clockwise" href="https://platform.claude.com/docs/ru/managed-agents/scheduled-deployments">
    Создавайте развёртывания и управляйте ими с помощью Claude API: запускайте агента по повторяющемуся расписанию cron и просматривайте историю его запусков.
  </Card>
</CardGroup>