---
title: Ergebnisse definieren
url: https://platform.claude.com/docs/de/managed-agents/define-outcomes
description: Teile dem Agenten mit, wie „fertig“ aussieht, und lass ihn iterieren, bis er es erreicht.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Ein Ergebnis teilt der Session mit, wie das Endresultat aussehen soll und wie seine Qualität gemessen wird. Der Agent arbeitet auf dieses Ziel hin, bewertet sich selbst und iteriert, bis das Ergebnis erreicht ist.

Wenn du ein Ergebnis definierst, stellt das Harness automatisch einen *Grader* (Bewerter) bereit, um das Artefakt anhand einer Rubrik zu bewerten. Der Grader verwendet ein separates Kontextfenster, um nicht von den Implementierungsentscheidungen des Hauptagenten beeinflusst zu werden.

Der Grader gibt eine Erklärung zurück, die zusammenfasst, welche Kriterien bestanden oder nicht bestanden wurden, oder bestätigt, dass das Artefakt die Rubrik erfüllt. Dieses Feedback wird an den Agenten für die nächste Iteration zurückgegeben.

## Eine Rubrik erstellen

Eine Rubrik ist ein Markdown-Dokument, das die Bewertung pro Kriterium beschreibt. Die Rubrik ist erforderlich.

<Accordion title="Tipps zum Schreiben effektiver Rubriken">
  Strukturiere die Rubrik als explizite, bewertbare Kriterien, wie „Die CSV enthält eine Preisspalte mit numerischen Werten“ statt „Die Daten sehen gut aus.“ Der Grader bewertet jedes Kriterium unabhängig, daher erzeugen vage Kriterien verrauschte Bewertungen.

  Wenn du keine Rubrik zur Hand hast, versuche, Claude ein Beispiel für ein als gut bekanntes Artefakt zu geben und es zu bitten, zu analysieren, was diesen Inhalt gut macht, und diese Analyse dann in eine Rubrik umzuwandeln. Dieser Mittelweg erzeugt oft bessere Ergebnisse als das Schreiben von Kriterien von Grund auf.
</Accordion>

Beispielrubrik:

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

Übergib die Rubrik als Inline-Text an `user.define_outcome` (siehe [Eine Session mit einem Ergebnis erstellen](https://platform.claude.com/docs/de/managed-agents/define-outcomes#create-a-session-with-an-outcome)), oder lade sie über die Files API hoch, um sie über mehrere Sessions hinweg wiederzuverwenden.

<CodeGroup>
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -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"
  )

  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>

## Eine Session mit einem Ergebnis erstellen

Die folgenden Beispiele erstellen eine [Session](https://platform.claude.com/docs/de/managed-agents/sessions) für einen bestehenden [Agenten](https://platform.claude.com/docs/de/managed-agents/agent-setup) und eine [Umgebung](https://platform.claude.com/docs/de/managed-agents/environments) (beide separat erstellt) und senden dann ein `user.define_outcome`-Event. Der Agent beginnt sofort mit der Arbeit. Es ist kein zusätzliches User-Message-Event erforderlich.

<CodeGroup>
  ```bash cURL
  # Create a session
  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" \
    --json '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'",
      "title": "Financial analysis on Costco"
    }'

  # Define the outcome: SESSION_ID is the id from the create response
  # The agent starts working when it receives the event
  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" \
    --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
        }
      ]
    }'
  # or: "rubric": {"type": "file", "file_id": "'"$RUBRIC_ID"'"}
  # "max_iterations" is optional; default 3, max 20
  ```

  ```bash CLI
  # Create a session
  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$ENVIRONMENT_ID" \
    --title "Financial analysis on Costco"

  # Define the outcome: SESSION_ID is the id from the create response
  # The agent starts working when it receives the event
  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
  # Erstelle eine Session
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      title="Financial analysis on Costco",
  )

  # Definiere das Ergebnis — der Agent beginnt bei Erhalt mit der Arbeit
  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},
              # oder: "rubric": {"type": "file", "file_id": rubric.id},
              "max_iterations": 5,  # optional; default 3, max 20
          }
      ],
  )
  ```

  ```typescript TypeScript
  // Eine Session erstellen
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    title: "Financial analysis on Costco"
  });

  // Das Ergebnis definieren — der Agent beginnt bei Erhalt mit der Arbeit
  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 },
        // oder: rubric: { type: "file", file_id: rubric.id },
        max_iterations: 5 // optional; default 3, max 20
      }
    ]
  });
  ```

  ```csharp C#
  // Eine Session erstellen
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Title = "Financial analysis on Costco",
  });

  // Das Ergebnis definieren — der Agent beginnt bei Erhalt mit der Arbeit
  await client.Beta.Sessions.Events.Send(session.ID, new()
  {
      Events =
      [
          new BetaManagedAgentsUserDefineOutcomeEventParams
          {
              Type = BetaManagedAgentsUserDefineOutcomeEventParamsType.UserDefineOutcome,
              Description = "Build a DCF model for Costco in .xlsx",
              Rubric = new BetaManagedAgentsTextRubricParams
              {
                  Type = BetaManagedAgentsTextRubricParamsType.Text,
                  Content = Rubric,
              },
              // oder: Rubric = new BetaManagedAgentsFileRubricParams
              //     { Type = BetaManagedAgentsFileRubricParamsType.File, FileID = rubric.ID },
              MaxIterations = 5, // optional; default 3, max 20
          },
      ],
  });
  ```

  ```go Go
  // Eine Session erstellen
  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)
  }

  // Das Ergebnis definieren — der Agent beginnt bei Erhalt mit der Arbeit
  _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
  	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
  		OfUserDefineOutcome: &anthropic.BetaManagedAgentsUserDefineOutcomeEventParams{
  			Type:        anthropic.BetaManagedAgentsUserDefineOutcomeEventParamsTypeUserDefineOutcome,
  			Description: "Build a DCF model for Costco in .xlsx",
  			Rubric: anthropic.BetaManagedAgentsUserDefineOutcomeEventParamsRubricUnion{
  				OfText: &anthropic.BetaManagedAgentsTextRubricParams{
  					Type:    anthropic.BetaManagedAgentsTextRubricParamsTypeText,
  					Content: rubric,
  				},
  			},
  			// oder: OfFile: &anthropic.BetaManagedAgentsFileRubricParams{
  			//     Type: anthropic.BetaManagedAgentsFileRubricParamsTypeFile, FileID: uploaded.ID},
  			MaxIterations: anthropic.Int(5), // optional; default 3, max 20
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  // Erstelle eine Session
  var session = client.beta().sessions().create(
      SessionCreateParams.builder()
          .agent(agent.id())
          .environmentId(environment.id())
          .title("Financial analysis on Costco")
          .build());

  // Definiere das Ergebnis — der Agent beginnt bei Erhalt mit der Arbeit
  client.beta().sessions().events().send(
      session.id(),
      EventSendParams.builder()
          .addEvent(BetaManagedAgentsUserDefineOutcomeEventParams.builder()
              .type(BetaManagedAgentsUserDefineOutcomeEventParams.Type.USER_DEFINE_OUTCOME)
              .description("Build a DCF model for Costco in .xlsx")
              .rubric(BetaManagedAgentsTextRubricParams.builder()
                  .type(BetaManagedAgentsTextRubricParams.Type.TEXT)
                  .content(RUBRIC)
                  .build())
              // oder: .rubric(BetaManagedAgentsFileRubricParams.builder()
              //     .type(BetaManagedAgentsFileRubricParams.Type.FILE).fileId(rubric.id()).build())
              .maxIterations(5) // optional; default 3, max 20
              .build())
          .build());
  ```

  ```php PHP
  // Erstelle eine Session
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      title: 'Financial analysis on Costco',
  );

  // Definiere das Ergebnis — der Agent beginnt bei Erhalt mit der Arbeit
  $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],
              // oder: 'rubric' => ['type' => 'file', 'file_id' => $rubric->id],
              'max_iterations' => 5, // optional; default 3, max 20
          ],
      ],
  );
  ```

  ```ruby Ruby
  # Erstelle eine Session
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    title: "Financial analysis on Costco"
  )

  # Definiere das Ergebnis — der Agent beginnt bei Erhalt mit der Arbeit
  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},
        # oder: rubric: {type: "file", file_id: rubric.id},
        max_iterations: 5 # optional; default 3, max 20
      }
    ]
  )
  ```
</CodeGroup>

<Note>
  Du kannst das Ergebnis auch direkt in der Erstellungsanfrage definieren: Übergib ein einzelnes `user.define_outcome`-Event in [`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)](https://platform.claude.com/docs/de/managed-agents/sessions#seed-the-session-with-initial-events), um die Session zu erstellen und die Arbeit am Ergebnis in einem einzigen Aufruf zu starten.
</Note>

## Ergebnis-Events

Der Fortschritt bei einer ergebnisorientierten Session wird im Events-[Stream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming) angezeigt.

* `agent.*`-Events (wie Nachrichten und Tool-Nutzung) zeigen den Fortschritt in Richtung des Ergebnisses.
* `span.outcome_evaluation_*`-Events werden nur für ergebnisorientierte Sessions ausgegeben und zeigen die Anzahl der Iterationsschleifen und den Feedback-Prozess des Graders.
* Du kannst auch `user.message`-[Events](https://platform.claude.com/docs/de/managed-agents/reference#event-types) an eine ergebnisorientierte Session senden, um die Arbeit des Agenten im Verlauf zu lenken, aber das ist nicht erforderlich: Der Agent arbeitet eigenständig auf das Ergebnis hin und iteriert, bis er erfolgreich ist oder die Iterationen aufgebraucht sind.
* Ein `user.interrupt`-Event pausiert die Arbeit am aktuellen Ergebnis und setzt das `result` (csharp, go: `Result`) des `span.outcome_evaluation_end`-Events auf `interrupted`, sodass du ein neues Ergebnis starten kannst.
* Nach der finalen Ergebnisbewertung kann die Session als Gesprächssession fortgesetzt werden, oder es kann ein neues Ergebnis gestartet werden. Die Session behält den Verlauf des vorherigen Ergebnisses bei.

### Define-Outcome-User-Event

<Note>
  Es wird jeweils nur ein Ergebnis unterstützt, aber du kannst Ergebnisse nacheinander verketten. Sende dazu ein neues `user.define_outcome`-Event nach dem abschließenden `span.outcome_evaluation_end`-Event des vorherigen Ergebnisses.
</Note>

Dies ist das Event, das du sendest, um ein Ergebnis zu initiieren. Es wird beim Empfang zurückgespiegelt, einschließlich eines `processed_at` (java, php: `processedAt`; csharp, go: `ProcessedAt`)-Zeitstempels und einer `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
}
```

### Ergebnisbewertung Start

Wird ausgegeben, sobald der Grader eine Bewertung über eine Iterationsschleife startet. Das Feld `iteration` ist ein 0-indizierter Revisionszähler: `0` ist die erste Bewertung, `1` ist die erneute Bewertung nach der ersten Revision und so weiter.

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

### Ergebnisbewertung laufend

Heartbeat, der ausgegeben wird, während der Grader läuft. Die interne Argumentation des Graders ist undurchsichtig: Du siehst, dass er arbeitet, nicht was er denkt.

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

### Ergebnisbewertung Ende

Wird ausgegeben, wenn ein Ergebnisbewertungszyklus endet: nachdem der Grader die Bewertung einer Iteration abgeschlossen hat, oder wenn die Session unterbrochen wird, während ein Ergebnis aktiv ist. Das Feld `result` gibt an, was als Nächstes passiert.

| Resultat                 | Nächstes                                                                                                                                                                                                                                                                   |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `satisfied`              | Session wechselt zu `idle`.                                                                                                                                                                                                                                                |
| `needs_revision`         | Agent startet einen neuen Iterationszyklus.                                                                                                                                                                                                                                |
| `max_iterations_reached` | Eine letzte Bestätigungsrunde folgt, bevor die Session zu `idle` wechselt. Es läuft keine weitere Bewertung.                                                                                                                                                               |
| `failed`                 | Session wechselt zu `idle`. Wird zurückgegeben, wenn die Rubrik nicht auf die Deliverables zutrifft, zum Beispiel wenn sich die Beschreibung und die Rubrik widersprechen.                                                                                                 |
| `interrupted`            | Wird ausgegeben, wenn die Session unterbrochen wird, während ein Ergebnis aktiv ist, selbst wenn die Bewertung noch nicht begonnen hatte. Wenn vor der Unterbrechung kein `outcome_evaluation_start` ausgelöst wurde, ist `outcome_evaluation_start_id` ein leerer String. |

```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"
}
```

## Ergebnisstatus prüfen

Du kannst entweder im [Event-Stream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming) auf `span.outcome_evaluation_end` lauschen oder `GET /v1/sessions/{session_id}` abfragen und `outcome_evaluations[].result` auslesen. Bis eine Bewertung abgeschlossen ist, meldet `result` `pending`, `running` oder `evaluating`:

<CodeGroup>
  ```bash cURL
  curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -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>

## Deliverables abrufen

Der Agent schreibt Ausgabedateien nach `/mnt/session/outputs/` innerhalb der Sandbox. Um sie abzurufen, liste die Dateien über die [Files API](https://platform.claude.com/docs/de/build-with-claude/files) mit der Session-ID als `scope_id` (java: `scopeId`; php: `scopeID`; csharp, go: `ScopeID`) auf und lade sie dann per ID herunter. Das Filtern nach `scope_id` (java: `scopeId`; php: `scopeID`; csharp, go: `ScopeID`) erfordert den Beta-Header `managed-agents-2026-04-01` in der List-Anfrage, daher führen die SDK- und CLI-Beispiele diesen Aufruf über den `beta`-Namespace aus und übergeben den Header explizit. Dateien erscheinen kurz nachdem der Agent sie fertig geschrieben hat in der Liste, manchmal einige Sekunden nachdem die Session in den Leerlauf gewechselt ist. Wenn eine erwartete Datei noch nicht aufgeführt ist, liste die Dateien nach einer kurzen Verzögerung erneut auf; sobald sie in der Liste erscheint, ist ihr Upload abgeschlossen.

<CodeGroup>
  ```bash cURL
  # List files produced by this session
  # scope_id filtering requires the managed-agents beta
  curl -fsSL "https://api.anthropic.com/v1/files?scope_id=$SESSION_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Download a file by the ID from the list
  curl -fsSL "https://api.anthropic.com/v1/files/$FILE_ID/content" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -o /tmp/output.txt
  ```

  ```bash CLI
  # List files produced by this session
  # scope_id filtering requires the managed-agents beta on the files request
  ant beta:files list --scope-id "$SESSION_ID" --beta managed-agents-2026-04-01

  # Download a file by the ID from the list
  ant files download --file-id "$FILE_ID" --output /tmp/output.txt
  ```

  ```python Python
  # Liste die von dieser Session erzeugten Dateien auf
  # scope_id-Filterung erfordert die managed-agents-Beta bei der Files-Anfrage
  files = client.beta.files.list(scope_id=session.id, betas=["managed-agents-2026-04-01"])
  for file in files:
      print(file.id, file.filename)

  # Lade eine Datei herunter
  if files.data:
      content = client.files.download(files.data[0].id)
      content.write_to_file("/tmp/output.txt")
  ```

  ```typescript TypeScript
  // Von dieser Session erzeugte Dateien auflisten
  // scope_id-Filterung erfordert die managed-agents-Beta in der Files-Anfrage
  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);
  }

  // Eine Datei herunterladen
  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#
  // Von dieser Session erzeugte Dateien auflisten
  // (scope_id-Filterung erfordert die managed-agents-Beta bei der Files-Anfrage)
  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}");
  }

  // Eine Datei herunterladen
  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
  // Von dieser Session erzeugte Dateien auflisten
  // (scope_id-Filterung erfordert die managed-agents-Beta bei der Files-Anfrage)
  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)
  }

  // Eine Datei herunterladen
  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
  // Liste die von dieser Session erzeugten Dateien auf
  // (scope_id-Filterung erfordert die managed-agents-Beta bei der Files-Anfrage)
  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());
  }

  // Lade eine Datei herunter
  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
  // Von dieser Session erzeugte Dateien auflisten
  // scope_id-Filterung erfordert die managed-agents-Beta bei der Files-Anfrage
  $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";
  }

  // Eine Datei herunterladen
  if (count($files->getItems()) > 0) {
      $content = $client->files->download($files->getItems()[0]->id);
      file_put_contents('/tmp/output.txt', $content);
  }
  ```

  ```ruby Ruby
  # Liste die von dieser Session erzeugten Dateien auf
  # scope_id-Filterung erfordert die managed-agents-Beta bei der Files-Anfrage
  files = client.beta.files.list(scope_id: session.id, betas: ["managed-agents-2026-04-01"])
  files.data.each { |file| puts "#{file.id} #{file.filename}" }

  # Lade eine Datei herunter
  if (first = files.data.first)
    content = client.files.download(first.id)
    File.binwrite("/tmp/output.txt", content.read)
  end
  ```
</CodeGroup>

## Nächste Schritte

<CardGroup cols={3}>
  <Card title="Mit Vaults authentifizieren" icon="fingerprint" href="https://platform.claude.com/docs/de/managed-agents/vaults">
    Registriere benutzerspezifische Anmeldedaten beim Erstellen von Sessions.
  </Card>

  <Card title="Session-Event-Stream" icon="lightning" href="https://platform.claude.com/docs/de/managed-agents/events-and-streaming">
    Sende Events, streame Antworten und unterbrich oder leite deine Session während der Ausführung um.
  </Card>

  <Card title="Dateien hinzufügen" icon="file" href="https://platform.claude.com/docs/de/managed-agents/files">
    Lade Dateien hoch und binde sie in deine Sandbox zum Lesen und Verarbeiten ein.
  </Card>
</CardGroup>