---
title: Определение результатов
url: https://platform.claude.com/docs/ru/managed-agents/define-outcomes
description: Сообщите агенту, как выглядит «готово», и позвольте ему выполнять итерации, пока он этого не достигнет.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
  zdr:
    eligibility: not-eligible
    note: Не подпадает под ZDR, за исключением самостоятельно размещаемых Managed Agents. Сессии — это ресурсы с состоянием; их расшифровки хранятся, пока вы их не удалите.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
    Claude Models on Google Cloud (Anthropic managed): beta
---

«Outcome» (результат) сообщает сессии, как должен выглядеть конечный итог и как измерять его качество. Агент работает над достижением этой цели, самостоятельно оценивая себя и итерируя, пока результат не будет достигнут.

Когда вы определяете результат, обвязка (harness) автоматически создаёт *grader* (оценщик) для оценки артефакта по рубрике. Оценщик использует отдельное «context window» (контекстное окно), чтобы на него не влияли решения основного агента по реализации.

Оценщик возвращает объяснение, в котором кратко указано, какие критерии пройдены или не пройдены, либо подтверждается, что артефакт удовлетворяет рубрике. Эта обратная связь передаётся обратно агенту для следующей итерации.

## Создание рубрики

«Rubric» (рубрика) — это документ в формате markdown, описывающий оценку по каждому критерию. Рубрика обязательна.

<Accordion title="Советы по написанию эффективных рубрик">
  Структурируйте рубрику в виде явных, поддающихся оценке критериев, например «CSV содержит столбец price с числовыми значениями», а не «Данные выглядят хорошо». Оценщик оценивает каждый критерий независимо, поэтому расплывчатые критерии дают зашумлённые оценки.

  Если у вас нет рубрики, попробуйте дать Claude пример заведомо хорошего артефакта и попросить проанализировать, что делает это содержимое хорошим, а затем превратите этот анализ в рубрику. Такой промежуточный подход часто даёт лучшие результаты, чем написание критериев без примера в качестве отправной точки.
</Accordion>

Пример рубрики:

```markdown
# DCF Model Rubric

## Revenue Projections
- Uses historical revenue data from the last 5 fiscal years
- Projects revenue for at least 5 years forward
- Growth rate assumptions are explicitly stated and reasonable

## Cost Structure
- COGS and operating expenses are modeled separately
- Margins are consistent with historical trends or deviations are justified

## Discount Rate
- WACC is calculated with stated assumptions for cost of equity and cost of debt
- Beta, risk-free rate, and equity risk premium are sourced or justified

## Terminal Value
- Uses either perpetuity growth or exit multiple method (stated which)
- Terminal growth rate does not exceed long-term GDP growth

## Output Quality
- All figures are in a single .xlsx file with clearly labeled sheets
- Key assumptions are on a separate "Assumptions" sheet
- Sensitivity analysis on WACC and terminal growth rate is included
```

Передайте рубрику как встроенный текст в `user.define_outcome` (см. [Создание сессии с результатом](https://platform.claude.com/docs/ru/managed-agents/define-outcomes#create-a-session-with-an-outcome)) или загрузите её через Files API для повторного использования в разных сессиях.

<CodeGroup>
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -F file=@/tmp/rubric.md
  ```

  ```bash CLI
  ant files upload --file /tmp/rubric.md
  ```

  ```python Python
  import time
  from pathlib import Path

  from anthropic import Anthropic

  client = Anthropic()

  RUBRIC = """# DCF Model Rubric

  ## Revenue Projections
  - Uses historical revenue data from the last 5 fiscal years
  - Projects revenue for at least 5 years forward

  ## Output Quality
  - All figures are in a single .xlsx file with clearly labeled sheets
  """
  Path("/tmp/rubric.md").write_text(RUBRIC)

  rubric = client.files.upload(file=Path("/tmp/rubric.md"))
  print(f"Uploaded rubric: {rubric.id}")
  ```

  ```typescript TypeScript
  import { writeFile, readFile } from "node:fs/promises";

  import Anthropic from "@anthropic-ai/sdk";
  import { toFile } from "@anthropic-ai/sdk";

  const client = new Anthropic();

  const RUBRIC = `# DCF Model Rubric

  ## Revenue Projections
  - Uses historical revenue data from the last 5 fiscal years
  - Projects revenue for at least 5 years forward

  ## Output Quality
  - All figures are in a single .xlsx file with clearly labeled sheets
  `;
  await writeFile("/tmp/rubric.md", RUBRIC);

  const rubric = await client.files.upload({
    file: await toFile(readFile("/tmp/rubric.md"), "/tmp/rubric.md")
  });
  console.log(`Uploaded rubric: ${rubric.id}`);
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta.Agents;
  using Anthropic.Models.Beta.Environments;
  using Anthropic.Models.Beta.Sessions;
  using Anthropic.Models.Beta.Sessions.Events;
  using Anthropic.Models.Files;

  var client = new AnthropicClient();

  const string Rubric = """
      # DCF Model Rubric

      ## Revenue Projections
      - Uses historical revenue data from the last 5 fiscal years
      - Projects revenue for at least 5 years forward

      ## Output Quality
      - All figures are in a single .xlsx file with clearly labeled sheets
      """;
  await File.WriteAllTextAsync("/tmp/rubric.md", Rubric);

  var rubric = await client.Files.Upload(new()
  {
      File = File.OpenRead("/tmp/rubric.md"),
  });
  Console.WriteLine($"Uploaded rubric: {rubric.ID}");
  ```

  ```go Go
  package main

  import (
  	"context"
  	"fmt"
  	"io"
  	"os"
  	"time"

  	"github.com/anthropics/anthropic-sdk-go/v2"
  )

  const rubric = `# DCF Model Rubric

  ## Revenue Projections
  - Uses historical revenue data from the last 5 fiscal years
  - Projects revenue for at least 5 years forward

  ## Output Quality
  - All figures are in a single .xlsx file with clearly labeled sheets
  `

  func main() {
  	ctx := context.Background()
  	client := anthropic.NewClient()

  	if err := os.WriteFile("/tmp/rubric.md", []byte(rubric), 0o644); err != nil {
  		panic(err)
  	}

  	f, err := os.Open("/tmp/rubric.md")
  	if err != nil {
  		panic(err)
  	}

  	uploaded, err := client.Files.Upload(ctx, anthropic.FileUploadParams{
  		File: anthropic.File(f, "rubric.md", "text/markdown"),
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("Uploaded rubric: %s\n", uploaded.ID)
  ```

  ```java Java
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.core.http.HttpResponse;
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.agents.AgentCreateParams;
  import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
  import com.anthropic.models.beta.agents.BetaManagedAgentsModel;
  import com.anthropic.models.beta.environments.BetaCloudConfigParams;
  import com.anthropic.models.beta.environments.BetaLimitedNetworkParams;
  import com.anthropic.models.beta.environments.EnvironmentCreateParams;
  import com.anthropic.models.beta.files.FileListParams;
  import com.anthropic.models.beta.sessions.SessionCreateParams;
  import com.anthropic.models.beta.sessions.events.BetaManagedAgentsTextRubricParams;
  import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserDefineOutcomeEventParams;
  import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserInterruptEventParams;
  import com.anthropic.models.beta.sessions.events.EventSendParams;
  import com.anthropic.models.files.FileUploadParams;

  import java.io.InputStream;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.StandardCopyOption;

  void main() throws Exception {
      var client = AnthropicOkHttpClient.fromEnv();

      var RUBRIC = """
          # DCF Model Rubric

          ## Revenue Projections
          - Uses historical revenue data from the last 5 fiscal years
          - Projects revenue for at least 5 years forward

          ## Output Quality
          - All figures are in a single .xlsx file with clearly labeled sheets
          """;
      Files.writeString(Path.of("/tmp/rubric.md"), RUBRIC);

      var rubric = client.files().upload(
          FileUploadParams.builder()
              .file(Path.of("/tmp/rubric.md"))
              .build());
      IO.println("Uploaded rubric: " + rubric.id());
  ```

  ```php PHP
  use Anthropic\Client;
  use Anthropic\Core\FileParam;

  $client = new Client();

  $rubricText = <<<'MD'
  # DCF Model Rubric

  ## Revenue Projections
  - Uses historical revenue data from the last 5 fiscal years
  - Projects revenue for at least 5 years forward

  ## Output Quality
  - All figures are in a single .xlsx file with clearly labeled sheets
  MD;
  file_put_contents('/tmp/rubric.md', $rubricText);

  $rubric = $client->files->upload(
      file: FileParam::fromResource(fopen('/tmp/rubric.md', 'r'), contentType: 'text/markdown'),
  );
  echo "Uploaded rubric: {$rubric->id}\n";
  ```

  ```ruby Ruby
  require "anthropic"
  require "pathname"

  client = Anthropic::Client.new

  RUBRIC = <<~MD
    # DCF Model Rubric

    ## Revenue Projections
    - Uses historical revenue data from the last 5 fiscal years
    - Projects revenue for at least 5 years forward

    ## Output Quality
    - All figures are in a single .xlsx file with clearly labeled sheets
  MD
  File.write("/tmp/rubric.md", RUBRIC)

  rubric = client.files.upload(file: Pathname.new("/tmp/rubric.md"))
  puts "Uploaded rubric: #{rubric.id}"
  ```
</CodeGroup>

## Создание сессии с результатом

Следующие примеры создают [сессию](https://platform.claude.com/docs/ru/managed-agents/sessions) для существующего [агента](https://platform.claude.com/docs/ru/managed-agents/agent-setup) и [окружения](https://platform.claude.com/docs/ru/managed-agents/environments) (оба создаются отдельно), а затем отправляют событие `user.define_outcome`. Агент сразу начинает работу. Дополнительное событие сообщения пользователя не требуется.

<CodeGroup>
  ```bash cURL
  # Создание сессии
  curl -fsSL https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    --json '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'",
      "title": "Financial analysis on Costco"
    }'

  # Определение результата: SESSION_ID — это ID из ответа на создание
  # Агент начинает работу, когда получает событие
  curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    --json '{
      "events": [
        {
          "type": "user.define_outcome",
          "description": "Build a DCF model for Costco in .xlsx",
          "rubric": {"type": "text", "content": "# DCF Model Rubric\n..."},
          "max_iterations": 5
        }
      ]
    }'
  # или: "rubric": {"type": "file", "file_id": "'"$RUBRIC_ID"'"}
  # "max_iterations" необязателен; по умолчанию 3, максимум 20
  ```

  ```bash CLI
  # Создать сессию
  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$ENVIRONMENT_ID" \
    --title "Financial analysis on Costco"

  # Определение результата: SESSION_ID — это ID из ответа на создание
  # Агент начинает работу, когда получает событие
  ant beta:sessions:events send --session-id "$SESSION_ID" <<YAML
  events:
    - type: user.define_outcome
      description: Build a DCF model for Costco in .xlsx
      rubric: {type: file, file_id: $RUBRIC_ID}
      # or: rubric: {type: text, content: "..."}
      max_iterations: 5  # optional; default 3, max 20
  YAML
  ```

  ```python Python
  # Создать сеанс
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      title="Financial analysis on Costco",
  )

  # Определите результат. Агент начинает работу сразу после получения.
  client.beta.sessions.events.send(
      session_id=session.id,
      events=[
          {
              "type": "user.define_outcome",
              "description": "Build a DCF model for Costco in .xlsx",
              "rubric": {"type": "text", "content": RUBRIC},
              # или: "rubric": {"type": "file", "file_id": rubric.id},
              "max_iterations": 5,  # optional; default 3, max 20
          }
      ],
  )
  ```

  ```typescript TypeScript
  // Создаём сессию
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    title: "Financial analysis on Costco"
  });

  // Определяем результат. Агент начинает работу сразу после получения.
  await client.beta.sessions.events.send(session.id, {
    events: [
      {
        type: "user.define_outcome",
        description: "Build a DCF model for Costco in .xlsx",
        rubric: { type: "text", content: RUBRIC },
        // или: rubric: { type: "file", file_id: rubric.id },
        max_iterations: 5 // optional; default 3, max 20
      }
    ]
  });
  ```

  ```csharp C#
  // Создание сеанса
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Title = "Financial analysis on Costco",
  });

  // Определите результат. Агент начинает работу сразу после получения.
  await client.Beta.Sessions.Events.Send(session.ID, new()
  {
      Events =
      [
          new BetaManagedAgentsUserDefineOutcomeEventParams
          {
              Description = "Build a DCF model for Costco in .xlsx",
              Rubric = new BetaManagedAgentsTextRubricParams { Content = Rubric },
              // или: Rubric = new BetaManagedAgentsFileRubricParams { FileID = rubric.ID },
              MaxIterations = 5, // optional; default 3, max 20
          },
      ],
  });
  ```

  ```go Go
  // Создание сеанса
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  	Title:         anthropic.String("Financial analysis on Costco"),
  })
  if err != nil {
  	panic(err)
  }

  // Определяем результат. Агент начинает работу сразу после получения.
  _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
  	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
  		OfUserDefineOutcome: &anthropic.BetaManagedAgentsUserDefineOutcomeEventParams{
  			Description: "Build a DCF model for Costco in .xlsx",
  			Rubric: anthropic.BetaManagedAgentsUserDefineOutcomeEventParamsRubricUnion{
  				OfText: &anthropic.BetaManagedAgentsTextRubricParams{
  					Content: rubric,
  				},
  			},
  			// или: OfFile: &anthropic.BetaManagedAgentsFileRubricParams{FileID: uploaded.ID},
  			MaxIterations: anthropic.Int(5), // optional; default 3, max 20
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  // Создание сеанса
  var session = client.beta().sessions().create(
      SessionCreateParams.builder()
          .agent(agent.id())
          .environmentId(environment.id())
          .title("Financial analysis on Costco")
          .build());

  // Определите результат. Агент начинает работу сразу после получения.
  client.beta().sessions().events().send(
      session.id(),
      EventSendParams.builder()
          .addEvent(BetaManagedAgentsUserDefineOutcomeEventParams.builder()
              .description("Build a DCF model for Costco in .xlsx")
              .rubric(BetaManagedAgentsTextRubricParams.builder()
                  .content(RUBRIC)
                  .build())
              // или: .rubric(BetaManagedAgentsFileRubricParams.builder().fileId(rubric.id()).build())
              .maxIterations(5) // optional; default 3, max 20
              .build())
          .build());
  ```

  ```php PHP
  // Создать сессию
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      title: 'Financial analysis on Costco',
  );

  // Определите результат. Агент начинает работу сразу после получения.
  $client->beta->sessions->events->send(
      $session->id,
      events: [
          [
              'type' => 'user.define_outcome',
              'description' => 'Build a DCF model for Costco in .xlsx',
              'rubric' => ['type' => 'text', 'content' => $rubricText],
              // или: 'rubric' => ['type' => 'file', 'file_id' => $rubric->id],
              'max_iterations' => 5, // optional; default 3, max 20
          ],
      ],
  );
  ```

  ```ruby Ruby
  # Создать сессию
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    title: "Financial analysis on Costco"
  )

  # Определить результат. Агент начинает работу сразу после получения.
  client.beta.sessions.events.send_(
    session.id,
    events: [
      {
        type: "user.define_outcome",
        description: "Build a DCF model for Costco in .xlsx",
        rubric: {type: "text", content: RUBRIC},
        # или: rubric: {type: "file", file_id: rubric.id},
        max_iterations: 5 # optional; default 3, max 20
      }
    ]
  )
  ```
</CodeGroup>

<Note>
  Вы также можете определить результат непосредственно в запросе на создание: передайте одно событие `user.define_outcome` в [`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)](https://platform.claude.com/docs/ru/managed-agents/sessions#seed-the-session-with-initial-events), чтобы создать сессию и начать работу над результатом за один вызов.
</Note>

## События результата

Прогресс сессии, ориентированной на результат, отображается в [потоке](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming) событий.

* События `agent.*` (такие как сообщения и использование инструментов) показывают прогресс в достижении результата.
* События `span.outcome_evaluation_*` генерируются только для сессий, ориентированных на результат, и показывают количество циклов итераций и процесс обратной связи оценщика.
* Вы также можете отправлять [события](https://platform.claude.com/docs/ru/managed-agents/reference#event-types) `user.message` в сессию, ориентированную на результат, чтобы направлять работу агента по мере её продвижения, но это не обязательно: агент работает над результатом самостоятельно, итерируя, пока не добьётся успеха или не исчерпает итерации.
* Событие `user.interrupt` приостанавливает работу над текущим результатом и устанавливает `result` (csharp, go: `Result`) события `span.outcome_evaluation_end` в значение `interrupted`, что позволяет начать новый результат.
* После финальной оценки результата сессию можно продолжить как диалоговую сессию или начать новый результат. Сессия сохраняет историю предыдущего результата.

### Пользовательское событие определения результата

<Note>
  Одновременно поддерживается только один результат, но вы можете выстраивать результаты последовательно. Для этого отправьте новое событие `user.define_outcome` после завершающего события `span.outcome_evaluation_end` предыдущего результата.
</Note>

Это событие, которое вы отправляете для запуска результата. При получении оно возвращается обратно, включая временную метку `processed_at` (java, php: `processedAt`; csharp, go: `ProcessedAt`) и `outcome_id` (java: `outcomeId`; php: `outcomeID`; csharp, go: `OutcomeID`).

```json
{
  "type": "user.define_outcome",
  "description": "Build a DCF model for Costco in .xlsx",
  "rubric": { "type": "file", "file_id": "file_01..." },
  "max_iterations": 5
}
```

### Начало оценки результата

Генерируется, когда оценщик начинает оценку одного цикла итерации. Поле `iteration` — это счётчик ревизий с индексацией от 0: `0` — первая оценка, `1` — повторная оценка после первой ревизии и так далее.

```json
{
  "type": "span.outcome_evaluation_start",
  "id": "sevt_01def...",
  "outcome_id": "outc_01a...",
  "iteration": 0,
  "processed_at": "2026-03-25T14:01:45Z"
}
```

### Оценка результата в процессе

Heartbeat-событие, генерируемое во время работы оценщика. Внутренние рассуждения оценщика скрыты: событие показывает лишь то, что оценщик работает.

```json
{
  "type": "span.outcome_evaluation_ongoing",
  "id": "sevt_01ghi...",
  "outcome_id": "outc_01a...",
  "iteration": 0,
  "processed_at": "2026-03-25T14:02:10Z"
}
```

### Завершение оценки результата

Генерируется при завершении цикла оценки результата: после того как оценщик заканчивает оценку одной итерации или когда сессия прерывается при активном результате. Поле `result` указывает, что произойдёт дальше.

| Результат | Далее |
| ----- | ----- |
| `satisfied` | Сессия переходит в состояние `idle`. |
| `needs_revision` | Агент начинает новый цикл итерации. |
| `max_iterations_reached` | Следует один финальный ход подтверждения, после чего сессия переходит в состояние `idle`. Дальнейшие оценки не выполняются. |
| `failed` | Сессия переходит в состояние `idle`. Возвращается, когда рубрика неприменима к итоговым материалам, например если описание и рубрика противоречат друг другу. |
| `interrupted` | Генерируется, когда сессия прерывается при активном результате, даже если оценка ещё не началась. Если до прерывания не сработало ни одно событие `outcome_evaluation_start`, `outcome_evaluation_start_id` будет пустой строкой. |

```json
{
  "type": "span.outcome_evaluation_end",
  "id": "sevt_01jkl...",
  "outcome_evaluation_start_id": "sevt_01def...",
  "outcome_id": "outc_01a...",
  "result": "satisfied",
  "explanation": "All 12 criteria met: revenue projections use 5 years of historical data, WACC assumptions are stated, sensitivity table is included...",
  "iteration": 0,
  "usage": {
    "input_tokens": 2400,
    "output_tokens": 350,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 1800
  },
  "processed_at": "2026-03-25T14:03:00Z"
}
```

## Проверка статуса результата

Вы можете либо слушать [поток событий](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming) в ожидании `span.outcome_evaluation_end`, либо опрашивать `GET /v1/sessions/{session_id}` и читать `outcome_evaluations[].result`. Пока оценка не завершена, `result` сообщает `pending`, `running` или `evaluating`:

<CodeGroup>
  ```bash cURL
  curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  ant beta:sessions retrieve --session-id "$SESSION_ID"
  ```

  ```python Python
  session = client.beta.sessions.retrieve(session.id)

  for outcome in session.outcome_evaluations:
      print(f"{outcome.outcome_id}: {outcome.result}")
      # outc_01a...: satisfied
  ```

  ```typescript TypeScript
  const retrieved = await client.beta.sessions.retrieve(session.id);

  for (const outcome of retrieved.outcome_evaluations) {
    console.log(`${outcome.outcome_id}: ${outcome.result}`);
    // outc_01a...: satisfied
  }
  ```

  ```csharp C#
  session = await client.Beta.Sessions.Retrieve(session.ID);

  foreach (var outcome in session.OutcomeEvaluations)
  {
      Console.WriteLine($"{outcome.OutcomeID}: {outcome.Result}");
      // outc_01a...: satisfied
  }
  ```

  ```go Go
  session, err = client.Beta.Sessions.Get(ctx, session.ID, anthropic.BetaSessionGetParams{})
  if err != nil {
  	panic(err)
  }

  for _, outcome := range session.OutcomeEvaluations {
  	fmt.Printf("%s: %s\n", outcome.OutcomeID, outcome.Result)
  	// outc_01a...: satisfied
  }
  ```

  ```java Java
  var retrieved = client.beta().sessions().retrieve(session.id());

  for (var outcome : retrieved.outcomeEvaluations()) {
      IO.println(outcome.outcomeId() + ": " + outcome.result());
      // outc_01a...: satisfied
  }
  ```

  ```php PHP
  $session = $client->beta->sessions->retrieve($session->id);

  foreach ($session->outcomeEvaluations as $outcome) {
      echo "{$outcome->outcomeID}: {$outcome->result}\n";
      // outc_01a...: satisfied
  }
  ```

  ```ruby Ruby
  session = client.beta.sessions.retrieve(session.id)

  session.outcome_evaluations.each do
    puts "#{it.outcome_id}: #{it.result}"
    # outc_01a...: satisfied
  end
  ```
</CodeGroup>

## Получение итоговых материалов

Агент записывает выходные файлы в `/mnt/session/outputs/` внутри песочницы. Чтобы получить их, выведите список файлов через [Files API](https://platform.claude.com/docs/ru/build-with-claude/files), указав ID сессии в качестве `scope_id` (java: `scopeId`; php: `scopeID`; csharp, go: `ScopeID`), а затем скачайте их по ID. Фильтрация по `scope_id` (java: `scopeId`; php: `scopeID`; csharp, go: `ScopeID`) требует бета-заголовка `managed-agents-2026-04-01` в запросе списка, поэтому примеры для SDK и CLI выполняют этот вызов через пространство имён `beta` и явно передают заголовок. Файлы появляются в списке вскоре после того, как агент заканчивает их запись, иногда через несколько секунд после перехода сессии в состояние idle. Если ожидаемый файл ещё не указан в списке, повторите запрос через небольшую паузу; как только файл появится в списке, его загрузка завершена.

<CodeGroup>
  ```bash cURL
  # Список файлов, созданных этой сессией
  # Для фильтрации по scope_id требуется бета-версия managed-agents
  curl -fsSL "https://api.anthropic.com/v1/files?scope_id=$SESSION_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Скачивание файла по ID из списка
  curl -fsSL "https://api.anthropic.com/v1/files/$FILE_ID/content" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -o /tmp/output.txt
  ```

  ```bash CLI
  # Список файлов, созданных этой сессией
  # фильтрация по scope_id требует бета-версии managed-agents в запросе files
  ant beta:files list --scope-id "$SESSION_ID" --beta managed-agents-2026-04-01

  # Скачивание файла по ID из списка
  ant files download --file-id "$FILE_ID" --output /tmp/output.txt
  ```

  ```python Python
  # Список файлов, созданных этим сеансом
  # фильтрация по scope_id требует бета-версии managed-agents в запросе к files
  files = client.beta.files.list(scope_id=session.id, betas=["managed-agents-2026-04-01"])
  for file in files:
      print(file.id, file.filename)

  # Скачать файл
  if files.data:
      content = client.files.download(files.data[0].id)
      content.write_to_file("/tmp/output.txt")
  ```

  ```typescript TypeScript
  // Список файлов, созданных этой сессией
  // фильтрация по scope_id требует бета-версии managed-agents в запросе к files
  const files = await client.beta.files.list({
    scope_id: session.id,
    betas: ["managed-agents-2026-04-01"]
  });
  for (const file of files.data) {
    console.log(file.id, file.filename);
  }

  // Скачиваем файл
  if (files.data.length > 0) {
    const content = await client.files.download(files.data[0].id);
    await writeFile("/tmp/output.txt", new Uint8Array(await content.arrayBuffer()));
  }
  ```

  ```csharp C#
  // Список файлов, созданных в этом сеансе
  // (фильтрация по scope_id требует бета-версии managed-agents в запросе files)
  var files = await client.Beta.Files.List(new()
  {
      ScopeID = session.ID,
      Betas = ["managed-agents-2026-04-01"],
  });
  foreach (var file in files.Items)
  {
      Console.WriteLine($"{file.ID} {file.Filename}");
  }

  // Скачивание файла
  if (files.Items.Count > 0)
  {
      using var download = await client.Files.Download(files.Items[0].ID);
      await using var output = File.Create("/tmp/output.txt");
      await (await download.ReadAsStream()).CopyToAsync(output);
  }
  ```

  ```go Go
  // Список файлов, созданных этим сеансом
  // (фильтрация по scope_id требует бета-версии managed-agents в запросе files)
  files, err := client.Beta.Files.List(ctx, anthropic.BetaFileListParams{
  	ScopeID: anthropic.String(session.ID),
  	Betas:   []anthropic.AnthropicBeta{anthropic.AnthropicBetaManagedAgents2026_04_01},
  })
  if err != nil {
  	panic(err)
  }
  for _, file := range files.Data {
  	fmt.Println(file.ID, file.Filename)
  }

  // Скачивание файла
  if len(files.Data) > 0 {
  	resp, err := client.Files.Download(ctx, files.Data[0].ID, anthropic.FileDownloadParams{})
  	if err != nil {
  		panic(err)
  	}
  	defer resp.Body.Close()
  	out, err := os.Create("/tmp/output.txt")
  	if err != nil {
  		panic(err)
  	}
  	defer out.Close()
  	if _, err := io.Copy(out, resp.Body); err != nil {
  		panic(err)
  	}
  }
  ```

  ```java Java
  // Список файлов, созданных этим сеансом
  // (фильтрация по scope_id требует бета-версии managed-agents в запросе files)
  var files = client.beta().files().list(
      FileListParams.builder()
          .scopeId(session.id())
          .addBeta(AnthropicBeta.MANAGED_AGENTS_2026_04_01)
          .build());
  for (var file : files.data()) {
      IO.println(file.id() + " " + file.filename());
  }

  // Скачивание файла
  if (!files.data().isEmpty()) {
      try (HttpResponse response = client.files().download(files.data().getFirst().id())) {
          try (InputStream body = response.body()) {
              Files.copy(body, Path.of("/tmp/output.txt"), StandardCopyOption.REPLACE_EXISTING);
          }
      }
  }
  ```

  ```php PHP
  // Список файлов, созданных этой сессией
  // фильтрация по scope_id требует бета-версии managed-agents в запросе к files
  $files = $client->beta->files->list(scopeID: $session->id, betas: ['managed-agents-2026-04-01']);
  foreach ($files->getItems() as $file) {
      echo "{$file->id} {$file->filename}\n";
  }

  // Скачать файл
  if (count($files->getItems()) > 0) {
      $content = $client->files->download($files->getItems()[0]->id);
      file_put_contents('/tmp/output.txt', $content);
  }
  ```

  ```ruby Ruby
  # Список файлов, созданных этой сессией
  # Фильтрация по scope_id требует бета-версии managed-agents в запросе к files
  files = client.beta.files.list(scope_id: session.id, betas: ["managed-agents-2026-04-01"])
  files.data.each { |file| puts "#{file.id} #{file.filename}" }

  # Скачать файл
  if (first = files.data.first)
    content = client.files.download(first.id)
    File.binwrite("/tmp/output.txt", content.read)
  end
  ```
</CodeGroup>

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

<CardGroup cols={3}>
  <Card title="Аутентификация с помощью хранилищ" icon="fingerprint" href="https://platform.claude.com/docs/ru/managed-agents/vaults">
    Регистрируйте учётные данные для каждого пользователя при создании сессий.
  </Card>

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

  <Card title="Добавление файлов" icon="file" href="https://platform.claude.com/docs/ru/managed-agents/files">
    Загружайте файлы и монтируйте их в песочницу для чтения и обработки.
  </Card>
</CardGroup>

## Доступность

Результаты находятся в бета-версии для всех моделей.

### Поддержка API

#### [Managed Agents](https://platform.claude.com/docs/ru/managed-agents/overview)

* Доступность: Доступно

| Статус | Облачные платформы |
| ----- | ----- |
| Бета | Все поддерживаемые платформы |

### Обязательные бета-заголовки

[Обзор бета-заголовков](https://platform.claude.com/docs/ru/api/beta-headers)

Бета-заголовки позволяют получить доступ к экспериментальным функциям и новым возможностям моделей до того, как они станут частью стандартного API.

* `managed-agents-2026-04-01`

### Обработка данных

[Обзор обработки данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#feature-eligibility)

| Элемент | Нулевое хранение данных | HIPAA |
| ----- | ----- | ----- |
| Статус | Не допускается | Не допускается |
| Подробности | Не подпадает под ZDR, за исключением самостоятельно размещаемых Managed Agents. Сессии — это ресурсы с состоянием; их расшифровки хранятся, пока вы их не удалите. [Подробнее](https://platform.claude.com/docs/ru/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Не подпадает под HIPAA. Относится ко всем подфункциям Managed Agents. |

Применимые конечные точки:

* `/v1/agents`
* `/v1/sessions`
* `/v1/environments`
