---
title: 결과 정의하기
url: https://platform.claude.com/docs/ko/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: 자체 호스팅 Managed Agents를 제외하고 ZDR 적격 대상이 아닙니다. 세션은 상태를 유지하는 리소스이며, 트랜스크립트는 삭제할 때까지 유지됩니다.
  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”(결과)은 세션에 최종 결과물이 어떤 모습이어야 하는지, 그리고 그 품질을 어떻게 측정할지를 알려줍니다. 에이전트는 해당 목표를 향해 작업하며, 결과가 충족될 때까지 스스로 평가하고 반복합니다.

결과를 정의하면 하네스가 자동으로 *grader*(채점기)를 프로비저닝하여 루브릭에 따라 아티팩트를 평가합니다. 채점기는 메인 에이전트의 구현 선택에 영향을 받지 않도록 별도의 “context window”(컨텍스트 윈도우)를 사용합니다.

채점기는 어떤 기준이 통과 또는 실패했는지 요약하거나, 아티팩트가 루브릭을 충족함을 확인하는 설명을 반환합니다. 이 피드백은 다음 반복을 위해 에이전트에게 다시 전달됩니다.

## 루브릭 만들기

“Rubric”(루브릭)은 기준별 채점 방식을 설명하는 마크다운 문서입니다. 루브릭은 필수입니다.

<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/ko/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/ko/managed-agents/agent-setup)와 [환경](https://platform.claude.com/docs/ko/managed-agents/environments)(둘 다 별도로 생성됨)에 대한 [세션](https://platform.claude.com/docs/ko/managed-agents/sessions)을 생성한 다음 `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>
  생성 요청 자체에서 결과를 정의할 수도 있습니다. [`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)](https://platform.claude.com/docs/ko/managed-agents/sessions#seed-the-session-with-initial-events)에 단일 `user.define_outcome` 이벤트를 전달하면 한 번의 호출로 세션을 만들고 결과를 향한 작업을 시작할 수 있습니다.
</Note>

## 결과 이벤트

결과 지향 세션의 진행 상황은 이벤트 [스트림](https://platform.claude.com/docs/ko/managed-agents/events-and-streaming)에 표시됩니다.

* `agent.*` 이벤트(메시지 및 도구 사용 등)는 결과를 향한 진행 상황을 보여줍니다.
* `span.outcome_evaluation_*` 이벤트는 결과 지향 세션에서만 발생하며, 반복 루프 횟수와 채점기의 피드백 과정을 보여줍니다.
* 결과 지향 세션에 `user.message` [이벤트](https://platform.claude.com/docs/ko/managed-agents/reference#event-types)를 전송하여 진행 중인 에이전트의 작업을 지시할 수도 있지만, 필수는 아닙니다. 에이전트는 스스로 결과를 향해 작업하며, 성공하거나 반복 횟수가 소진될 때까지 반복합니다.
* `user.interrupt` 이벤트는 현재 결과에 대한 작업을 일시 중지하고 `span.outcome_evaluation_end` 이벤트의 `result` (csharp, go: `Result`)를 `interrupted`로 표시하여 새 결과를 시작할 수 있게 합니다.
* 최종 결과 평가 후, 세션은 대화형 세션으로 계속하거나 새로운 결과를 시작할 수 있습니다. 세션은 이전 결과의 기록을 유지합니다.

### 결과 정의 사용자 이벤트

<Note>
  한 번에 하나의 결과만 지원되지만, 결과를 순차적으로 연결할 수 있습니다. 이렇게 하려면 이전 결과의 종료 `span.outcome_evaluation_end` 이벤트 이후에 새 `user.define_outcome` 이벤트를 보내세요.
</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"
}
```

### 결과 평가 진행 중

채점기가 실행되는 동안 발생하는 하트비트입니다. 채점기의 내부 추론은 공개되지 않으며, 이 이벤트는 채점기가 작업 중이라는 사실만 보여줍니다.

```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/ko/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/`에 출력 파일을 작성합니다. 이를 가져오려면 세션 ID를 `scope_id` (java: `scopeId`; php: `scopeID`; csharp, go: `ScopeID`)로 사용하여 [Files API](https://platform.claude.com/docs/ko/build-with-claude/files)를 통해 파일 목록을 조회한 다음, ID로 다운로드하세요. `scope_id` (java: `scopeId`; php: `scopeID`; csharp, go: `ScopeID`)로 필터링하려면 목록 요청에 `managed-agents-2026-04-01` 베타 헤더가 필요하므로, SDK 및 CLI 예시는 `beta` 네임스페이스를 통해 해당 호출을 수행하고 헤더를 명시적으로 전달합니다. 파일은 에이전트가 작성을 마친 직후 목록에 나타나며, 때로는 세션이 유휴 상태가 된 후 몇 초 뒤에 나타나기도 합니다. 예상한 파일이 아직 목록에 없다면 잠시 후 다시 목록을 조회하세요. 파일이 목록에 나타나면 업로드가 완료된 것입니다.

<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 베타가 필요합니다
  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 필터링은 files 요청에 managed-agents 베타가 필요합니다
  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 베타가 필요합니다
  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 필터링에는 files 요청에 managed-agents 베타가 필요합니다)
  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 필터링은 files 요청에 managed-agents 베타가 필요합니다)
  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 필터링에는 files 요청에 managed-agents 베타가 필요합니다)
  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 필터링은 files 요청에 managed-agents 베타가 필요합니다
  $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 필터링은 files 요청에 managed-agents 베타가 필요합니다
  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/ko/managed-agents/vaults">
    세션을 만들 때 사용자별 자격 증명을 등록하세요.
  </Card>

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

  <Card title="파일 추가하기" icon="file" href="https://platform.claude.com/docs/ko/managed-agents/files">
    파일을 업로드하고 샌드박스에 마운트하여 읽고 처리하세요.
  </Card>
</CardGroup>

## 제공 여부

결과은(는) 모든 모델에서 베타 상태입니다.

### API 지원

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

* 제공 여부: 사용 가능

| 상태 | 클라우드 플랫폼 |
| ----- | ----- |
| 베타 | 지원되는 모든 플랫폼 |

### 필수 베타 헤더

[베타 헤더 개요](https://platform.claude.com/docs/ko/api/beta-headers)

베타 헤더를 사용하면 실험적 기능과 새로운 모델 기능이 표준 API에 포함되기 전에 액세스할 수 있습니다.

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

### 데이터 처리

[데이터 처리 개요](https://platform.claude.com/docs/ko/manage-claude/api-and-data-retention#feature-eligibility)

| 항목 | 제로 데이터 보존 | HIPAA |
| ----- | ----- | ----- |
| 상태 | 적격 아님 | 적격 아님 |
| 세부 정보 | 자체 호스팅 Managed Agents를 제외하고 ZDR 적격 대상이 아닙니다. 세션은 상태를 유지하는 리소스이며, 트랜스크립트는 삭제할 때까지 유지됩니다. [자세히 알아보기](https://platform.claude.com/docs/ko/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | HIPAA 적격 대상이 아닙니다. 모든 Managed Agents 하위 기능에 적용됩니다. |

적용 엔드포인트:

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