---
title: Définir des résultats attendus
url: https://platform.claude.com/docs/fr/managed-agents/define-outcomes
description: Indiquez à l'agent à quoi ressemble un travail « terminé », et laissez-le itérer jusqu'à y parvenir.
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: Non éligible à la ZDR, sauf pour Managed Agents auto-hébergé. Les sessions sont des ressources avec état ; les transcriptions persistent jusqu’à ce que vous les supprimiez.
  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
---

Un « outcome » (résultat attendu) indique à la session à quoi doit ressembler le résultat final et comment en mesurer la qualité. L’agent travaille en direction de cet objectif, en s’auto-évaluant et en itérant jusqu’à ce que le résultat attendu soit atteint.

Lorsque vous définissez un résultat attendu, le harnais provisionne automatiquement un *grader* (évaluateur) chargé d’évaluer l’artefact par rapport à une grille d’évaluation. L’évaluateur utilise une « context window » (fenêtre de contexte) distincte afin de ne pas être influencé par les choix d’implémentation de l’agent principal.

L’évaluateur renvoie une explication résumant quels critères ont été satisfaits ou non, ou confirmant que l’artefact satisfait la grille d’évaluation. Ce retour est transmis à l’agent pour l’itération suivante.

## Créer une grille d’évaluation

Une « rubric » (grille d’évaluation) est un document markdown décrivant la notation critère par critère. La grille d’évaluation est obligatoire.

<Accordion title="Conseils pour rédiger des grilles d’évaluation efficaces">
  Structurez la grille d’évaluation sous forme de critères explicites et évaluables, tels que « Le CSV contient une colonne price avec des valeurs numériques » plutôt que « Les données semblent correctes ». L’évaluateur note chaque critère indépendamment, de sorte que des critères vagues produisent des évaluations bruitées.

  Si vous n’avez pas de grille d’évaluation, essayez de donner à Claude un exemple d’artefact reconnu comme bon et de lui demander d’analyser ce qui rend ce contenu bon, puis transformez cette analyse en grille d’évaluation. Cette approche intermédiaire produit souvent de meilleurs résultats que la rédaction de critères sans exemple de départ.
</Accordion>

Exemple de grille d’évaluation :

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

Transmettez la grille d’évaluation sous forme de texte en ligne dans `user.define_outcome` (voir [Créer une session avec un résultat attendu](https://platform.claude.com/docs/fr/managed-agents/define-outcomes#create-a-session-with-an-outcome)), ou téléversez-la via l’API Files pour la réutiliser d’une session à l’autre.

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

## Créer une session avec un résultat attendu

Les exemples suivants créent une [session](https://platform.claude.com/docs/fr/managed-agents/sessions) pour un [agent](https://platform.claude.com/docs/fr/managed-agents/agent-setup) et un [environnement](https://platform.claude.com/docs/fr/managed-agents/environments) existants (tous deux créés séparément), puis envoient un événement `user.define_outcome`. L’agent commence à travailler immédiatement. Aucun événement de message utilisateur supplémentaire n’est requis.

<CodeGroup>
  ```bash cURL
  # Créer une session
  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"
    }'

  # Définir le résultat : SESSION_ID est l'ID issu de la réponse de création
  # L'agent commence à travailler lorsqu'il reçoit l'événement
  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
        }
      ]
    }'
  # ou : "rubric": {"type": "file", "file_id": "'"$RUBRIC_ID"'"}
  # "max_iterations" est optionnel ; 3 par défaut, 20 au maximum
  ```

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

  # Définir le résultat : SESSION_ID est l'ID issu de la réponse de création
  # L'agent commence à travailler lorsqu'il reçoit l'événement
  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
  # Créer une session
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      title="Financial analysis on Costco",
  )

  # Définir le résultat. L'agent commence à travailler dès réception.
  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},
              # ou : "rubric": {"type": "file", "file_id": rubric.id},
              "max_iterations": 5,  # optional; default 3, max 20
          }
      ],
  )
  ```

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

  // Définir le résultat. L'agent commence à travailler dès réception.
  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 },
        // ou : rubric: { type: "file", file_id: rubric.id },
        max_iterations: 5 // optional; default 3, max 20
      }
    ]
  });
  ```

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

  // Définir le résultat. L'agent commence à travailler dès sa réception.
  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 },
              // ou : Rubric = new BetaManagedAgentsFileRubricParams { FileID = rubric.ID },
              MaxIterations = 5, // optional; default 3, max 20
          },
      ],
  });
  ```

  ```go Go
  // Créer une session
  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)
  }

  // Définir le résultat. L'agent commence à travailler dès réception.
  _, 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,
  				},
  			},
  			// ou : OfFile: &anthropic.BetaManagedAgentsFileRubricParams{FileID: uploaded.ID},
  			MaxIterations: anthropic.Int(5), // optional; default 3, max 20
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

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

  // Définir le résultat. L'agent commence à travailler dès réception.
  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())
              // ou : .rubric(BetaManagedAgentsFileRubricParams.builder().fileId(rubric.id()).build())
              .maxIterations(5) // optional; default 3, max 20
              .build())
          .build());
  ```

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

  // Définir le résultat. L'agent commence à travailler dès sa réception.
  $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],
              // ou : 'rubric' => ['type' => 'file', 'file_id' => $rubric->id],
              'max_iterations' => 5, // optional; default 3, max 20
          ],
      ],
  );
  ```

  ```ruby Ruby
  # Créer une session
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    title: "Financial analysis on Costco"
  )

  # Définir le résultat. L'agent commence à travailler dès réception.
  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},
        # ou : rubric: {type: "file", file_id: rubric.id},
        max_iterations: 5 # optional; default 3, max 20
      }
    ]
  )
  ```
</CodeGroup>

<Note>
  Vous pouvez également définir le résultat attendu directement dans la requête de création : transmettez un seul événement `user.define_outcome` dans [`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)](https://platform.claude.com/docs/fr/managed-agents/sessions#seed-the-session-with-initial-events) pour créer la session et commencer le travail vers le résultat attendu en un seul appel.
</Note>

## Événements liés aux résultats attendus

La progression d’une session orientée résultat est exposée sur le [flux](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming) d’événements.

* Les événements `agent.*` (tels que les messages et l’utilisation d’outils) montrent la progression vers le résultat attendu.
* Les événements `span.outcome_evaluation_*` ne sont émis que pour les sessions orientées résultat et indiquent le nombre de boucles d’itération ainsi que le processus de retour de l’évaluateur.
* Vous pouvez également envoyer des [événements](https://platform.claude.com/docs/fr/managed-agents/reference#event-types) `user.message` à une session orientée résultat pour orienter le travail de l’agent au fur et à mesure de sa progression, mais ce n’est pas obligatoire : l’agent travaille de lui-même vers le résultat attendu, en itérant jusqu’à ce qu’il réussisse ou qu’il épuise ses itérations.
* Un événement `user.interrupt` met en pause le travail sur le résultat en cours et définit le `result` (csharp, go: `Result`) de l’événement `span.outcome_evaluation_end` à `interrupted`, ce qui vous permet de démarrer un nouveau résultat.
* Après l’évaluation finale du résultat attendu, la session peut être poursuivie en tant que session conversationnelle, ou un nouveau résultat attendu peut être lancé. La session conserve l’historique du résultat attendu précédent.

### Événement utilisateur de définition du résultat attendu

<Note>
  Un seul résultat est pris en charge à la fois, mais vous pouvez enchaîner des résultats successivement. Pour ce faire, envoyez un nouvel événement `user.define_outcome` après l’événement terminal `span.outcome_evaluation_end` du résultat précédent.
</Note>

Il s’agit de l’événement que vous envoyez pour initier un résultat attendu. Il est renvoyé en écho à sa réception, avec un horodatage `processed_at` (java, php: `processedAt`; csharp, go: `ProcessedAt`) et un `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
}
```

### Début de l’évaluation du résultat attendu

Émis lorsque l’évaluateur commence une évaluation sur une boucle d’itération. Le champ `iteration` est un compteur de révisions indexé à partir de 0 : `0` correspond à la première évaluation, `1` à la réévaluation après la première révision, et ainsi de suite.

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

### Évaluation du résultat attendu en cours

Signal de pulsation (heartbeat) émis pendant l’exécution de l’évaluateur. Le raisonnement interne de l’évaluateur est opaque : l’événement indique uniquement que l’évaluateur est en train de travailler.

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

### Fin de l’évaluation du résultat attendu

Émis lorsqu’un cycle d’évaluation du résultat se termine : après que l’évaluateur a fini d’évaluer une itération, ou lorsque la session est interrompue alors qu’un résultat est actif. Le champ `result` indique ce qui se passe ensuite.

| Résultat | Suite |
| ----- | ----- |
| `satisfied` | La session passe à l’état `idle`. |
| `needs_revision` | L’agent démarre un nouveau cycle d’itération. |
| `max_iterations_reached` | Un dernier tour d’accusé de réception suit avant que la session ne passe à l’état `idle`. Aucune autre évaluation n’est exécutée. |
| `failed` | La session passe à l’état `idle`. Renvoyé lorsque la grille d’évaluation ne s’applique pas aux livrables, par exemple si la description et la grille d’évaluation se contredisent. |
| `interrupted` | Émis lorsque la session est interrompue alors qu’un résultat attendu est actif, même si l’évaluation n’avait pas encore commencé. Si aucun `outcome_evaluation_start` n’a été déclenché avant l’interruption, `outcome_evaluation_start_id` est une chaîne vide. |

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

## Vérifier l’état du résultat attendu

Vous pouvez soit écouter le [flux d’événements](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming) pour détecter `span.outcome_evaluation_end`, soit interroger `GET /v1/sessions/{session_id}` et lire `outcome_evaluations[].result`. Tant qu’une évaluation n’est pas terminée, `result` indique `pending`, `running` ou `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>

## Récupérer les livrables

L’agent écrit les fichiers de sortie dans `/mnt/session/outputs/` à l’intérieur du bac à sable. Pour les récupérer, listez les fichiers via la [Files API](https://platform.claude.com/docs/fr/build-with-claude/files) avec l’ID de session comme `scope_id` (java: `scopeId`; php: `scopeID`; csharp, go: `ScopeID`), puis téléchargez-les par ID. Le filtrage par `scope_id` (java: `scopeId`; php: `scopeID`; csharp, go: `ScopeID`) nécessite l’en-tête bêta `managed-agents-2026-04-01` sur la requête de liste ; les exemples SDK et CLI effectuent donc cet appel via l’espace de noms `beta` et transmettent explicitement l’en-tête. Les fichiers apparaissent dans la liste peu après que l’agent a fini de les écrire, parfois quelques secondes après que la session est passée à l’état inactif. Si un fichier attendu n’est pas encore listé, relancez la liste après un court délai ; une fois qu’il apparaît dans la liste, son téléversement est terminé.

<CodeGroup>
  ```bash cURL
  # Lister les fichiers produits par cette session
  # le filtrage par scope_id nécessite la bêta 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"

  # Télécharger un fichier à partir de l'ID fourni par la liste
  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
  # Lister les fichiers produits par cette session
  # Le filtrage par scope_id requiert la bêta managed-agents sur la requête files
  ant beta:files list --scope-id "$SESSION_ID" --beta managed-agents-2026-04-01

  # Télécharger un fichier à partir de l'ID fourni par la liste
  ant files download --file-id "$FILE_ID" --output /tmp/output.txt
  ```

  ```python Python
  # Lister les fichiers produits par cette session
  # Le filtrage par scope_id requiert la bêta managed-agents sur la requête 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)

  # Télécharger un fichier
  if files.data:
      content = client.files.download(files.data[0].id)
      content.write_to_file("/tmp/output.txt")
  ```

  ```typescript TypeScript
  // Lister les fichiers produits par cette session
  // le filtrage par scope_id requiert la bêta managed-agents sur la requête 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);
  }

  // Télécharger un fichier
  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#
  // Lister les fichiers produits par cette session
  // (le filtrage par scope_id requiert la bêta managed-agents sur la requête 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}");
  }

  // Télécharger un fichier
  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
  // Lister les fichiers produits par cette session
  // (le filtrage par scope_id requiert la bêta managed-agents sur la requête 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)
  }

  // Télécharger un fichier
  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
  // Lister les fichiers produits par cette session
  // (le filtrage par scope_id nécessite la bêta managed-agents sur la requête 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());
  }

  // Télécharger un fichier
  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
  // Lister les fichiers produits par cette session
  // Le filtrage par scope_id requiert la bêta managed-agents sur la requête 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";
  }

  // Télécharger un fichier
  if (count($files->getItems()) > 0) {
      $content = $client->files->download($files->getItems()[0]->id);
      file_put_contents('/tmp/output.txt', $content);
  }
  ```

  ```ruby Ruby
  # Lister les fichiers produits par cette session
  # Le filtrage par scope_id nécessite la bêta managed-agents sur la requête 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}" }

  # Télécharger un fichier
  if (first = files.data.first)
    content = client.files.download(first.id)
    File.binwrite("/tmp/output.txt", content.read)
  end
  ```
</CodeGroup>

## Étapes suivantes

<CardGroup cols={3}>
  <Card title="S’authentifier avec les coffres-forts" icon="fingerprint" href="https://platform.claude.com/docs/fr/managed-agents/vaults">
    Enregistrez des identifiants par utilisateur lors de la création de sessions.
  </Card>

  <Card title="Flux d’événements de session" icon="lightning" href="https://platform.claude.com/docs/fr/managed-agents/events-and-streaming">
    Envoyez des événements, diffusez les réponses en streaming, et interrompez ou redirigez votre session pendant son exécution.
  </Card>

  <Card title="Ajouter des fichiers" icon="file" href="https://platform.claude.com/docs/fr/managed-agents/files">
    Téléversez des fichiers et montez-les dans votre sandbox pour les lire et les traiter.
  </Card>
</CardGroup>

## Disponibilité

Résultats attendus sont en bêta sur tous les modèles.

### Prise en charge de l’API

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

* Disponibilité : Disponible

| Statut | Plateformes cloud |
| ----- | ----- |
| Bêta | Toutes les plateformes prises en charge |

### En-têtes bêta requis

[Présentation des en-têtes bêta](https://platform.claude.com/docs/fr/api/beta-headers)

Les en-têtes bêta vous permettent d’accéder à des fonctionnalités expérimentales et à de nouvelles capacités des modèles avant qu’elles ne fassent partie de l’API standard.

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

### Traitement des données

[Présentation du traitement des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#feature-eligibility)

| Élément | Zéro conservation des données | HIPAA |
| ----- | ----- | ----- |
| Statut | Non éligible | Non éligible |
| Détails | Non éligible à la ZDR, sauf pour Managed Agents auto-hébergé. Les sessions sont des ressources avec état ; les transcriptions persistent jusqu’à ce que vous les supprimiez. [En savoir plus](https://platform.claude.com/docs/fr/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Non éligible à HIPAA. S’applique à toutes les sous-fonctionnalités de Managed Agents. |

Points de terminaison concernés :

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