---
title: Définir votre agent
url: https://platform.claude.com/docs/fr/managed-agents/agent-setup
description: Créez une configuration d'agent réutilisable et versionnée.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Un agent est une configuration réutilisable et versionnée qui définit un persona et des capacités. Il regroupe le modèle, l'invite système, les outils, les serveurs MCP et les skills qui déterminent le comportement de Claude pendant une session.
Créez l'agent une seule fois en tant que ressource réutilisable et référencez-le par son ID chaque fois que vous [démarrez une session](https://platform.claude.com/docs/fr/managed-agents/sessions). Les agents sont versionnés et plus faciles à gérer sur de nombreuses sessions.
## Champs de configuration de l'agent
| Champ | Description |
| ------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name` (csharp, go: `Name`) | Obligatoire. Un nom lisible par un humain pour l'agent. |
| `model` (csharp, go: `Model`) | Obligatoire. Le [modèle](https://platform.claude.com/docs/fr/models/overview) Claude qui alimente l'agent. Accepte une chaîne d'ID de modèle ou un objet, par exemple `{"id": "claude-opus-5-5"}`. Les modèles Claude 4.5 et ultérieurs sont pris en charge. La forme objet accepte également les champs `speed`, `effort` et `inference_geo` ; consultez les conseils sous [Créer un agent](https://platform.claude.com/docs/fr/managed-agents/agent-setup#create-an-agent), [Niveaux d'effort](https://platform.claude.com/docs/fr/build-with-claude/effort#effort-levels) et [Épingler la géographie d'inférence](https://platform.claude.com/docs/fr/managed-agents/agent-setup#pin-the-inference-geo). |
| `system` (csharp, go: `System`; ruby: `system_`) | Une [invite système](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/claude-prompting-best-practices#give-claude-a-role) qui définit le comportement et le persona de l'agent. L'invite système est distincte des [messages utilisateur](https://platform.claude.com/docs/fr/managed-agents/reference#event-types), qui doivent décrire le travail à effectuer. |
| `tools` (csharp, go: `Tools`) | Les outils disponibles pour l'agent. Combine les [outils d'agent prédéfinis](https://platform.claude.com/docs/fr/managed-agents/tools), les [outils MCP](https://platform.claude.com/docs/fr/managed-agents/mcp-connector) et les [outils personnalisés](https://platform.claude.com/docs/fr/managed-agents/tools#custom-tools). |
| `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) | [Serveurs MCP](https://platform.claude.com/docs/fr/managed-agents/mcp-connector) qui fournissent des capacités tierces standardisées. |
| `skills` (csharp, go: `Skills`) | [Skills](https://platform.claude.com/docs/fr/managed-agents/skills) qui fournissent un contexte spécifique au domaine avec une divulgation progressive. |
| `multiagent` (csharp, go: `Multiagent`) | Permet à l'agent de confier du travail à d'autres agents, en tant que sous-agents ou dans des [workflows dynamiques](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration#dynamic-workflows), et éventuellement de consulter un modèle [conseiller](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration#give-the-session-an-advisor). Avec le type `multiagent_20261001`, les workflows dynamiques sont activés sauf si vous les désactivez. Consultez [Orchestration multiagent](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration). |
| `description` (csharp, go: `Description`) | Une description de ce que fait l'agent. |
| `metadata` (csharp, go: `Metadata`) | Paires clé-valeur arbitraires pour votre propre suivi. |
Vous pouvez également remplacer `model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`), `tools` (csharp, go: `Tools`), `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) et `skills` (csharp, go: `Skills`) pour une seule session sans modifier l'agent. Un remplacement de `model` (csharp, go: `Model`) remplace entièrement l'objet `model` (csharp, go: `Model`) de l'agent, de sorte que l'`effort` (csharp, go: `Effort`) propre à l'agent n'est pas conservé. Pour exécuter la session à un niveau d'effort spécifique, définissez `effort` (csharp, go: `Effort`) dans l'objet `model` (csharp, go: `Model`) du remplacement. Consultez [Remplacer la configuration de l'agent pour une session](https://platform.claude.com/docs/fr/managed-agents/sessions#override-agent-configuration-for-a-session).
## Créer un agent
L'exemple suivant définit un agent de programmation qui utilise le modèle Claude Opus le plus récent avec accès à l'ensemble d'outils d'agent prédéfini. Cet ensemble d'outils permet à l'agent d'écrire du code, de lire des fichiers, d'effectuer des recherches sur le web, et plus encore. Consultez la [référence des outils d'agent](https://platform.claude.com/docs/fr/managed-agents/tools) pour la liste complète des outils pris en charge.
Les exemples utilisent curl, la CLI `ant` ou l'un des SDK. Si vous n'en avez pas encore configuré, le [guide de démarrage rapide](https://platform.claude.com/docs/fr/managed-agents/quickstart#install-the-cli) couvre l'installation et la configuration du client.
```bash cURL
curl -fsSL https://api.anthropic.com/v1/agents \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "Coding Assistant",
"model": "claude-opus-5-5",
"system": "You are a helpful coding agent.",
"tools": [{"type": "agent_toolset_20260401"}]
}'
```
```bash CLI
ant apply coding-assistant.md
```
```markdown
---
name: Coding Assistant
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
---
You are a helpful coding agent.
```
[`ant apply`](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/apply) crée l'agent à partir de `coding-assistant.md`, affiche son ID et l'enregistre dans `claude-lock.json`. Commitez `claude-lock.json` afin que le prochain `ant apply` mette à jour cet agent au lieu d'en créer un second.
```python Python
agent = client.beta.agents.create(
name="Coding Assistant",
model="claude-opus-5-5",
system="You are a helpful coding agent.",
tools=[
{"type": "agent_toolset_20260401"},
],
)
```
```typescript TypeScript
const agent = await client.beta.agents.create({
name: "Coding Assistant",
model: "claude-opus-5-5",
system: "You are a helpful coding agent.",
tools: [{ type: "agent_toolset_20260401" }]
});
```
```csharp C#
var agent = await client.Beta.Agents.Create(new()
{
Name = "Coding Assistant",
Model = BetaManagedAgentsModel.ClaudeOpus5_5,
System = "You are a helpful coding agent.",
Tools =
[
new BetaManagedAgentsAgentToolset20260401Params
{
Type = "agent_toolset_20260401",
},
],
});
```
```go Go
agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
Name: "Coding Assistant",
Model: anthropic.BetaManagedAgentsModelConfigParams{
ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
},
System: anthropic.String("You are a helpful coding agent."),
Tools: []anthropic.BetaAgentNewParamsToolUnion{{
OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
},
}},
})
if err != nil {
panic(err)
}
```
```java Java
var agent = client.beta().agents().create(
AgentCreateParams.builder()
.name("Coding Assistant")
.model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
.system("You are a helpful coding agent.")
.addTool(
BetaManagedAgentsAgentToolset20260401Params.builder()
.type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
.build()
)
.build()
);
```
```php PHP
$agent = $client->beta->agents->create(
name: 'Coding Assistant',
model: 'claude-opus-5-5',
system: 'You are a helpful coding agent.',
tools: [
BetaManagedAgentsAgentToolset20260401Params::with(
type: 'agent_toolset_20260401',
),
],
);
```
```ruby Ruby
agent = client.beta.agents.create(
name: "Coding Assistant",
model: "claude-opus-5-5",
system_: "You are a helpful coding agent.",
tools: [{type: "agent_toolset_20260401"}]
)
```
La réponse reprend votre configuration et ajoute les champs `id`, `type`, `version`, `created_at`, `updated_at` et `archived_at`, et renseigne les champs de `model` que vous omettez, comme `effort`, avec leurs valeurs par défaut. La `version` commence à 1 et s'incrémente chaque fois qu'une mise à jour modifie l'agent.
```json
{
"id": "agent_01HqR2k7vXbZ9mNpL3wYcT8f",
"type": "agent",
"name": "Coding Assistant",
"model": {
"id": "claude-opus-5-5",
"effort": { "type": "medium" },
"speed": "standard"
},
"system": "You are a helpful coding agent.",
"description": null,
"tools": [
{
"type": "agent_toolset_20260401",
"default_config": {
"permission_policy": { "type": "always_allow" }
}
}
],
"skills": [],
"mcp_servers": [],
"multiagent": null,
"metadata": {},
"version": 1,
"created_at": "2026-04-03T18:24:10.412Z",
"updated_at": "2026-04-03T18:24:10.412Z",
"archived_at": null
}
```
Le `default_config` de l'ensemble d'outils indique sa [politique d'autorisation](https://platform.claude.com/docs/fr/managed-agents/permission-policies) par défaut, `always_allow`, qui s'applique sauf si vous en configurez une.
Pour utiliser Claude Opus 5.5, Claude Opus 5 ou Claude Opus 4.8 avec le [mode rapide](https://platform.claude.com/docs/fr/build-with-claude/fast-mode), passez `model` sous forme d'objet, par exemple : `{"id": "claude-opus-5-5", "speed": "fast"}`. Consultez les [modèles pris en charge](https://platform.claude.com/docs/fr/build-with-claude/fast-mode#supported-models) sur la page du mode rapide.
Pour définir le niveau d'effort du modèle, passez `model` sous forme d'objet, par exemple : `{"id": "claude-opus-5-5", "effort": "high"}`. Le champ `effort` accepte une chaîne de niveau (`low`, `medium`, `high`, `xhigh` ou `max`) ou un objet tel que `{"type": "high"}`. Consultez [Niveaux d'effort](https://platform.claude.com/docs/fr/build-with-claude/effort#effort-levels) pour savoir ce que fait chaque niveau.
### Épingler la géographie d'inférence
Comme `speed` (csharp, go: `Speed`) et `effort` (csharp, go: `Effort`), `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) se définit via la forme objet de `model` (csharp, go: `Model`) : passez `model` (csharp, go: `Model`) sous forme d'objet et définissez `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) à côté de `id` (csharp, go: `ID`). Le champ accepte `"us"` ou `"global"`. Lorsqu'il n'est pas défini, chaque requête au modèle suit la géographie d'inférence par défaut de l'espace de travail au moment où elle est servie. Consultez [Résidence des données](https://platform.claude.com/docs/fr/manage-claude/data-residency) pour les contrôles de géographie au niveau de l'espace de travail et la tarification.
L'exemple suivant épingle un agent à l'inférence aux États-Unis et affiche la valeur `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) de l'objet `model` (csharp, go: `Model`) de l'agent :
```bash cURL
curl -fsSL https://api.anthropic.com/v1/agents \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "Geo-pinned assistant",
"model": {"id": "claude-opus-5-5", "inference_geo": "us"},
"system": "You are a helpful assistant."
}'
```
```bash CLI
ant apply geo-pinned-assistant.md
```
```markdown
---
name: Geo-pinned assistant
model:
id: claude-opus-5-5
inference_geo: us
---
You are a helpful assistant.
```
```python Python
agent = client.beta.agents.create(
name="Geo-pinned assistant",
model={
"id": "claude-opus-5-5",
"inference_geo": "us",
},
system="You are a helpful assistant.",
)
print(f"Inference geo: {agent.model.inference_geo}")
```
```typescript TypeScript
const agent = await client.beta.agents.create({
name: "Geo-pinned assistant",
model: { id: "claude-opus-5-5", inference_geo: "us" },
system: "You are a helpful assistant."
});
console.log(`Inference geo: ${agent.model.inference_geo}`);
```
```csharp C#
var agent = await client.Beta.Agents.Create(new()
{
Name = "Geo-pinned assistant",
Model = new BetaManagedAgentsModelConfigParams
{
ID = BetaManagedAgentsModel.ClaudeOpus5_5,
InferenceGeo = "us",
},
System = "You are a helpful assistant.",
});
Console.WriteLine($"Inference geo: {agent.Model.InferenceGeo}");
```
```go Go
agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
Name: "Geo-pinned assistant",
Model: anthropic.BetaManagedAgentsModelConfigParams{
ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
InferenceGeo: anthropic.String("us"),
},
System: anthropic.String("You are a helpful assistant."),
})
if err != nil {
panic(err)
}
fmt.Printf("Inference geo: %s\n", agent.Model.InferenceGeo)
```
```java Java
var agent = client.beta().agents().create(
AgentCreateParams.builder()
.name("Geo-pinned assistant")
.model(
BetaManagedAgentsModelConfigParams.builder()
.id(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
.inferenceGeo("us")
.build()
)
.system("You are a helpful assistant.")
.build()
);
IO.println("Inference geo: " + agent.model().inferenceGeo().orElseThrow());
```
```php PHP
$agent = $client->beta->agents->create(
name: 'Geo-pinned assistant',
model: BetaManagedAgentsModelConfigParams::with(
id: 'claude-opus-5-5',
inferenceGeo: 'us',
),
system: 'You are a helpful assistant.',
);
echo "Inference geo: {$agent->model->inferenceGeo}\n";
```
```ruby Ruby
agent = client.beta.agents.create(
name: "Geo-pinned assistant",
model: {id: "claude-opus-5-5", inference_geo: "us"},
system_: "You are a helpful assistant."
)
puts "Inference geo: #{agent.model.inference_geo}"
```
Un épinglage `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) est validé par rapport aux [`allowed_inference_geos`](https://platform.claude.com/docs/fr/manage-claude/data-residency#workspace-level-restrictions) de l'espace de travail lorsque l'agent est enregistré, lorsqu'une session est créée à partir de celui-ci, et à chaque tour servi par la session. Si la liste d'autorisation de l'espace de travail se restreint de sorte qu'un épinglage n'est plus autorisé, de nouvelles sessions ne peuvent plus être créées à partir de l'agent et les sessions en cours refusent les tours suivants ; les épinglages ne sont jamais exemptés, car les espaces de travail s'appuient sur eux pour la conformité et la résidence des données.
Définir `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) sur un modèle qui ne prend pas en charge l'épinglage géographique de l'inférence renvoie une erreur 400 ; consultez [Disponibilité des modèles](https://platform.claude.com/docs/fr/manage-claude/data-residency#model-availability) pour les modèles qui le prennent en charge. Dans une configuration `multiagent` (csharp, go: `Multiagent`), l'épinglage de l'agent et celui de chaque agent figurant dans la liste `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) de `subagents` (csharp, go: `Subagents`) ou de `workflows` (csharp, go: `Workflows`) doivent tous être définis sur la même valeur ou tous être non définis ; consultez [Orchestration multiagent](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration). Pour modifier ou supprimer l'épinglage ultérieurement, mettez à jour l'objet `model` (csharp, go: `Model`) de l'agent ; fournir `model` (csharp, go: `Model`) sans `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) le supprime, comme décrit dans [Sémantique de mise à jour](https://platform.claude.com/docs/fr/managed-agents/agent-setup#update-semantics).
## Mettre à jour un agent
La mise à jour d'un agent génère une nouvelle version lorsque la configuration change. Le champ `version` (csharp, go: `Version`) est facultatif : fournissez-le pour une concurrence optimiste (une non-correspondance renvoie une erreur 409), ou omettez-le pour appliquer la mise à jour sans condition (la dernière écriture l'emporte). Les mises à jour des agents archivés sont rejetées.
Avec la CLI, modifiez le fichier de l'agent et exécutez à nouveau `ant apply` ; apply fournit `version` pour vous.
```bash cURL
curl -fsSL "https://api.anthropic.com/v1/agents/$AGENT_ID" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"version": '"$AGENT_VERSION"',
"system": "You are a helpful coding agent. Always write tests."
}'
```
```bash CLI
ant apply coding-assistant.md
```
```markdown
---
name: Coding Assistant
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
---
You are a helpful coding agent. Always write tests.
```
```python Python
updated_agent = client.beta.agents.update(
agent.id,
version=agent.version,
system="You are a helpful coding agent. Always write tests.",
)
print(f"New version: {updated_agent.version}")
```
```typescript TypeScript
const updatedAgent = await client.beta.agents.update(agent.id, {
version: agent.version,
system: "You are a helpful coding agent. Always write tests."
});
console.log(`New version: ${updatedAgent.version}`);
```
```csharp C#
var updatedAgent = await client.Beta.Agents.Update(agent.ID, new()
{
Version = agent.Version,
System = "You are a helpful coding agent. Always write tests.",
});
Console.WriteLine($"New version: {updatedAgent.Version}");
```
```go Go
updatedAgent, err := client.Beta.Agents.Update(ctx, agent.ID, anthropic.BetaAgentUpdateParams{
Version: anthropic.Int(agent.Version),
System: anthropic.String("You are a helpful coding agent. Always write tests."),
})
if err != nil {
panic(err)
}
fmt.Printf("New version: %d\n", updatedAgent.Version)
```
```java Java
var updatedAgent = client.beta().agents().update(
agent.id(),
AgentUpdateParams.builder()
.version(agent.version())
.system("You are a helpful coding agent. Always write tests.")
.build()
);
IO.println("New version: " + updatedAgent.version());
```
```php PHP
$updatedAgent = $client->beta->agents->update(
$agent->id,
version: $agent->version,
system: 'You are a helpful coding agent. Always write tests.',
);
echo "New version: {$updatedAgent->version}\n";
```
```ruby Ruby
updated_agent = client.beta.agents.update(
agent.id,
version: agent.version,
system_: "You are a helpful coding agent. Always write tests."
)
puts "New version: #{updated_agent.version}"
```
L'exemple précédent fournit `version` à partir de la réponse de création, de sorte que la mise à jour ne s'applique que si rien d'autre n'a modifié l'agent depuis que vous l'avez lu. Pour appliquer une mise à jour sans condition, omettez `version` de la requête :
```bash cURL
curl -fsSL "https://api.anthropic.com/v1/agents/$AGENT_ID" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"description": "Writes and reviews code."
}'
```
```bash CLI
ant beta:agents update \
--agent-id "$AGENT_ID" \
--description "Writes and reviews code."
```
```python Python
unconditional_agent = client.beta.agents.update(
agent.id,
description="Writes and reviews code.",
)
print(f"New version: {unconditional_agent.version}")
```
```typescript TypeScript
const unconditionalAgent = await client.beta.agents.update(agent.id, {
description: "Writes and reviews code."
});
console.log(`New version: ${unconditionalAgent.version}`);
```
```csharp C#
var unconditionalAgent = await client.Beta.Agents.Update(agent.ID, new()
{
Description = "Writes and reviews code.",
});
Console.WriteLine($"New version: {unconditionalAgent.Version}");
```
```go Go
unconditionalAgent, err := client.Beta.Agents.Update(ctx, agent.ID, anthropic.BetaAgentUpdateParams{
Description: anthropic.String("Writes and reviews code."),
})
if err != nil {
panic(err)
}
fmt.Printf("New version: %d\n", unconditionalAgent.Version)
```
```java Java
var unconditionalAgent = client.beta().agents().update(
agent.id(),
AgentUpdateParams.builder()
.description("Writes and reviews code.")
.build()
);
IO.println("New version: " + unconditionalAgent.version());
```
```php PHP
$unconditionalAgent = $client->beta->agents->update(
$agent->id,
description: 'Writes and reviews code.',
);
echo "New version: {$unconditionalAgent->version}\n";
```
```ruby Ruby
unconditional_agent = client.beta.agents.update(
agent.id,
description: "Writes and reviews code."
)
puts "New version: #{unconditional_agent.version}"
```
### Sémantique de mise à jour
* **`version` (csharp, go: `Version`)** est facultatif et doit être au moins égal à 1 lorsqu'il est fourni. Lorsqu'il est fourni, la requête renvoie une erreur 409 s'il ne correspond pas à la version actuelle de l'agent, même lorsque les champs que vous envoyez correspondent déjà aux valeurs stockées ; relisez l'agent et réessayez. Lorsqu'il est omis, la mise à jour s'applique sans condition et la mise à jour la plus récente remplace silencieusement toute mise à jour concurrente, sans erreur pour aucun des appelants. Fournir `version` (csharp, go: `Version`) est le comportement par défaut recommandé pour les appelants interactifs, et l'omettre convient aux boucles d'application déclaratives, comme une tâche CI qui synchronise des définitions d'agents versionnées dans le dépôt, où la boucle est propriétaire de l'agent.
* **Les champs omis sont conservés.** Vous n'avez besoin d'inclure que les champs que vous souhaitez modifier.
* **Les champs scalaires** (`model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`), `name` (csharp, go: `Name`), `description` (csharp, go: `Description`)) sont remplacés par la nouvelle valeur. `system` (csharp, go: `System`; ruby: `system_`) et `description` (csharp, go: `Description`) peuvent être effacés en passant `null` (python: `None`; ruby: `nil`; java: `Optional.empty()`; go: `param.Null[string]()`; php: `requestOptions: ['extraBodyParams' => ['system' => null, 'description' => null]]`). `model` (csharp, go: `Model`) et `name` (csharp, go: `Name`) sont obligatoires et ne peuvent pas être effacés. Dans un objet `model` (csharp, go: `Model`) que vous fournissez, `effort` (csharp, go: `Effort`) est la seule exception : si l'`id` (csharp, go: `ID`) du modèle est inchangé, omettre `effort` (csharp, go: `Effort`) laisse le niveau d'effort stocké inchangé. Si vous modifiez l'`id` (csharp, go: `ID`) du modèle, un `effort` (csharp, go: `Effort`) omis est réinitialisé à la valeur par défaut du nouveau modèle. Les autres champs de `model` (csharp, go: `Model`) sont remplacés avec l'objet : fournir `model` (csharp, go: `Model`) sans `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) supprime l'épinglage de géographie d'inférence de l'agent.
* **Les champs de type tableau** (`tools` (csharp, go: `Tools`), `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`), `skills` (csharp, go: `Skills`)) sont entièrement remplacés par le nouveau tableau. Pour effacer complètement un champ de type tableau, passez `null` (python: `None`; ruby: `nil`; java: `Optional.empty()`; go: `param.NullSlice[[]anthropic.BetaAgentUpdateParamsToolUnion]()`; php: `requestOptions: ['extraBodyParams' => ['mcp_servers' => null]]`) ou un tableau vide.
* **`multiagent` (csharp, go: `Multiagent`)** est fusionné niveau par niveau dans le bloc stocké lorsque la mise à jour conserve le type `multiagent_20261001`. Un paramètre que vous omettez conserve sa valeur stockée, et une liste `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) que vous envoyez remplace la liste stockée. Toute autre mise à jour qui envoie `multiagent` (csharp, go: `Multiagent`) remplace le bloc stocké dans son ensemble, et les paramètres qu'elle omet prennent leurs valeurs par défaut. Passez `"multiagent": null` (python: `multiagent=None`; typescript: `multiagent: null`; ruby: `multiagent: nil`; go: `Multiagent: param.NullStruct[anthropic.BetaManagedAgentsMultiagentParamsUnion]()`; java: `.multiagent(Optional.empty())`; csharp: `Multiagent = null`; php: `requestOptions: ['extraBodyParams' => ['multiagent' => null]]`) pour effacer l'ensemble du bloc. À l'intérieur du bloc, `null` réinitialise un paramètre à sa valeur par défaut, de sorte que définir `workflows` (csharp, go: `Workflows`) sur `null` active les workflows dynamiques. Consultez [Activer les workflows dynamiques](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration#turn-on-dynamic-workflows).
* **Les métadonnées** sont fusionnées au niveau des clés. Les clés que vous fournissez sont ajoutées ou mises à jour. Les clés que vous omettez sont conservées. Pour supprimer une clé spécifique, définissez sa valeur sur `null`.
* **Détection des opérations sans effet.** Si la mise à jour ne produit aucun changement par rapport à la version actuelle, aucune nouvelle version n'est créée et la version existante est renvoyée.
* **Les listes `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) des autres agents ne sont pas mises à jour.** Les agents qui répertorient cet agent dans la liste `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) de `subagents` (csharp, go: `Subagents`) ou de `workflows` (csharp, go: `Workflows`) conservent la version qui était épinglée lors de leur création ou lors de la dernière mise à jour ayant envoyé cette liste, même si la référence omet `version` (csharp, go: `Version`). Pour déléguer à la nouvelle version, [mettez à jour l'agent qui la répertorie](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration#list-the-subagents) afin que la liste référence la nouvelle version.
La mise à jour suivante efface la description, supprime la clé `team` de `metadata` (csharp, go: `Metadata`) et définit `workflows` (csharp, go: `Workflows`) sur `null`, ce qui active les workflows dynamiques :
```bash cURL
curl -fsSL "https://api.anthropic.com/v1/agents/$AGENT_ID" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"description": null,
"metadata": {"team": null},
"multiagent": {"type": "multiagent_20261001", "workflows": null}
}'
```
```bash CLI
ant apply code-reviewer.md
```
```markdown
---
name: Code Reviewer
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
metadata:
owner: docs
multiagent:
type: multiagent_20261001
workflows: null
---
You are a helpful coding agent.
```
Le fichier ne contient plus `description` ni la clé `team`, donc `ant apply` envoie `null` pour ceux-ci. Supprimer un paramètre à l'intérieur de `multiagent` conserve sa valeur stockée, c'est pourquoi le fichier définit `workflows` sur `null`.
```python Python
cleared_agent = client.beta.agents.update(
agent.id,
description=None,
metadata={"team": None},
multiagent={"type": "multiagent_20261001", "workflows": None},
)
print(f"Description: {cleared_agent.description}")
```
```typescript TypeScript
const clearedAgent = await client.beta.agents.update(agent.id, {
description: null,
metadata: { team: null },
multiagent: { type: "multiagent_20261001", workflows: null }
});
console.log(`Description: ${clearedAgent.description}`);
```
```csharp C#
var clearedAgent = await client.Beta.Agents.Update(agent.ID, new()
{
Description = null,
Metadata = new Dictionary { ["team"] = null },
Multiagent = new BetaManagedAgentsMultiagent20261001Params { Workflows = null },
});
Console.WriteLine($"Description: {clearedAgent.Description}");
```
```go Go
// Metadata est un map[string]string, donc envoyez le null pour team comme option de requête.
clearedAgent, err := client.Beta.Agents.Update(ctx, agent.ID, anthropic.BetaAgentUpdateParams{
Description: param.Null[string](),
Multiagent: anthropic.BetaManagedAgentsMultiagentParamsUnion{
OfMultiagent20261001: &anthropic.BetaManagedAgentsMultiagent20261001Params{
Workflows: param.NullStruct[anthropic.BetaManagedAgentsMultiagentWorkflowsParamsUnion](),
},
},
}, option.WithJSONSet("metadata.team", nil))
if err != nil {
panic(err)
}
fmt.Printf("Description: %q\n", clearedAgent.Description)
```
```java Java
var clearedAgent = client.beta().agents().update(
agent.id(),
AgentUpdateParams.builder()
.description(Optional.empty())
.metadata(
AgentUpdateParams.Metadata.builder()
.putAdditionalProperty("team", JsonValue.from(null))
.build()
)
.multiagent(
BetaManagedAgentsMultiagent20261001Params.builder()
.workflows(Optional.empty())
.build()
)
.build()
);
IO.println("Description: " + clearedAgent.description().orElse(null));
```
```php PHP
// update() ignore les arguments null, passez donc les null dans extraBodyParams.
$clearedAgent = $client->beta->agents->update(
$agent->id,
requestOptions: [
'extraBodyParams' => [
'description' => null,
'metadata' => ['team' => null],
'multiagent' => ['type' => 'multiagent_20261001', 'workflows' => null],
],
],
);
echo 'Description: ' . json_encode($clearedAgent->description) . "\n";
```
```ruby Ruby
cleared_agent = client.beta.agents.update(
agent.id,
description: nil,
metadata: {team: nil},
multiagent: {type: :multiagent_20261001, workflows: nil}
)
puts "Description: #{cleared_agent.description.inspect}"
```
## Cycle de vie de l'agent
| Opération | Comportement |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| **Mettre à jour** | Génère une nouvelle version de l'agent lorsque la configuration change. |
| **Lister les versions** | Renvoie l'historique complet des versions afin que vous puissiez suivre les modifications au fil du temps. |
| **Archiver** | Rend l'agent en lecture seule. Les nouvelles sessions ne peuvent pas le référencer, mais les sessions existantes continuent de s'exécuter. |
### Lister les versions
Récupérez l'historique complet des versions pour suivre l'évolution d'un agent au fil du temps. Les résultats sont paginés, et les exemples de SDK récupèrent automatiquement toutes les pages.
```bash cURL
curl -fsSL "https://api.anthropic.com/v1/agents/$AGENT_ID/versions" \
-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:agents:versions list --agent-id "$AGENT_ID"
```
```python Python
for version in client.beta.agents.versions.list(agent.id):
print(f"Version {version.version}: {version.updated_at.isoformat()}")
```
```typescript TypeScript
for await (const version of client.beta.agents.versions.list(agent.id)) {
console.log(`Version ${version.version}: ${version.updated_at}`);
}
```
```csharp C#
var versions = await client.Beta.Agents.Versions.List(agent.ID);
await foreach (var version in versions.Paginate())
{
Console.WriteLine($"Version {version.Version}: {version.UpdatedAt:O}");
}
```
```go Go
iter := client.Beta.Agents.Versions.ListAutoPaging(ctx, agent.ID, anthropic.BetaAgentVersionListParams{})
for iter.Next() {
version := iter.Current()
fmt.Printf("Version %d: %s\n", version.Version, version.UpdatedAt.Format(time.RFC3339))
}
if err := iter.Err(); err != nil {
panic(err)
}
```
```java Java
for (var version : client.beta().agents().versions().list(agent.id()).autoPager()) {
IO.println("Version " + version.version() + ": " + version.updatedAt());
}
```
```php PHP
foreach ($client->beta->agents->versions->list($agent->id)->pagingEachItem() as $version) {
echo "Version {$version->version}: {$version->updatedAt->format(\DateTimeInterface::ATOM)}\n";
}
```
```ruby Ruby
client.beta.agents.versions.list(agent.id).auto_paging_each do |agent_version|
puts "Version #{agent_version.version}: #{agent_version.updated_at.iso8601}"
end
```
### Archiver un agent
L'archivage rend l'agent en lecture seule et ne peut pas être annulé. Les sessions existantes continuent de s'exécuter, mais les nouvelles sessions ne peuvent pas référencer l'agent. La réponse définit `archived_at` (java, php: `archivedAt`; csharp, go: `ArchivedAt`) sur l'horodatage de l'archivage.
```bash cURL
curl -fsSL -X POST "https://api.anthropic.com/v1/agents/$AGENT_ID/archive" \
-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:agents archive --agent-id "$AGENT_ID"
```
```python Python
archived = client.beta.agents.archive(agent.id)
print(f"Archived at: {archived.archived_at.isoformat()}")
```
```typescript TypeScript
const archived = await client.beta.agents.archive(agent.id);
console.log(`Archived at: ${archived.archived_at}`);
```
```csharp C#
var archived = await client.Beta.Agents.Archive(agent.ID);
Console.WriteLine($"Archived at: {archived.ArchivedAt:O}");
```
```go Go
archived, err := client.Beta.Agents.Archive(ctx, agent.ID, anthropic.BetaAgentArchiveParams{})
if err != nil {
panic(err)
}
fmt.Printf("Archived at: %s\n", archived.ArchivedAt.Format(time.RFC3339))
```
```java Java
var archived = client.beta().agents().archive(agent.id());
IO.println("Archived at: " + archived.archivedAt().orElseThrow());
```
```php PHP
$archived = $client->beta->agents->archive($agent->id);
echo "Archived at: {$archived->archivedAt->format(\DateTimeInterface::ATOM)}\n";
```
```ruby Ruby
archived = client.beta.agents.archive(agent.id)
puts "Archived at: #{archived.archived_at.iso8601}"
```
## Étapes suivantes
Configurez les outils disponibles pour votre agent.
Associez à votre agent une expertise réutilisable basée sur le système de fichiers pour des workflows spécifiques à un domaine.
Créez une session pour exécuter votre agent et commencer à exécuter des tâches.
Types d'événements, options de la CLI des workers auto-hébergés, types de serveurs MCP pris en charge, limites de débit et directives de marque pour Claude Managed Agents.