Table of Contents

🇬🇧 English version

Voir aussi : Guide comparatif ProcessTypes · Schéma YAML · Retour à l'index

Orchestration agentique autonome

Vue d'ensemble

Orkeon fournit un mode d'orchestration autonome (ProcessType.Autonomous) oĂč les agents s'auto-organisent pour rĂ©clamer des tĂąches, dĂ©lĂ©guer rĂ©cursivement Ă  leurs pairs, et spawner des sous-agents spĂ©cialisĂ©s Ă  la volĂ©e. Toute l'exĂ©cution est contrainte par un AgentExecutionBudget multi-dimensions qui garantit la terminaison.

DĂ©faut DI Ă  connaĂźtre : de base, ITaskDelegator est un stub qui refuse toute demande de dĂ©lĂ©gation (il avertit une fois, avec le correctif) — voir Comportements par dĂ©faut avant de cĂąbler une crew qui dĂ©lĂšgue beaucoup.

Contrairement aux modes Sequential/Hierarchical oĂč l'orchestrateur contrĂŽle le flux, et au mode Graph oĂč le graphe d'Ă©tat dĂ©finit la topologie, le mode Autonomous laisse les agents prendre les dĂ©cisions de dĂ©lĂ©gation et de spawn. L'orchestrateur n'intervient que pour enforcer le budget et collecter les rĂ©sultats.

Positionnement par rapport aux autres stratégies

Stratégie Décision de routing Délégation récursive Spawn dynamique Budget multi-dimensions Communication A2A
Sequential Fixe (ordre liste) Non Non Non Non
Hierarchical Manager LLM 1 niveau Non Non Unidirectionnel
Graph Edges conditionnels Non Non Non (circuit breaker) Non
Autonomous Agent auto-selection Oui (profondeur contrÎlée) Oui (quota) Oui (5 dimensions) Request/Response

Architecture

Couche Domain — Budget d'execution

Classe Fichier Role
AgentExecutionBudget Autonomous/AgentExecutionBudget.cs Budget multi-dimensions : tool calls, delegation depth, wall time, tokens, spawns
BudgetSnapshot Autonomous/AgentExecutionBudget.cs Snapshot immutable pour logging et telemetrie
BudgetExhaustedException Autonomous/AgentExecutionBudget.cs Exception typee avec BudgetDimension (ToolCalls, DelegationDepth, WallTime, Tokens, SpawnedAgents)
BudgetDimension Autonomous/AgentExecutionBudget.cs Enum des 5 dimensions du budget

Le budget est thread-safe (compteurs Interlocked) et immutable aprÚs construction (limites en init). Chaque action (RecordToolCall, RecordDelegation, RecordSpawn, RecordTokens) décrémente le budget et lÚve BudgetExhaustedException si la limite est atteinte.

Couche Domain — ProcessType

ProcessType.Autonomous est ajouté au value object existant. IProcessStrategy expose une nouvelle méthode :

Task<CrewOutput> ExecuteAutonomousAsync(
    Crew crew,
    AgentExecutionBudget budget,
    IReadOnlyDictionary<string, string>? inputVariables = null,
    CancellationToken cancellationToken = default);

Couche Application — Communication A2A

Classe Fichier RĂŽle
IAgentChannel Interfaces/Services/IAgentChannel.cs Canal bidirectionnel request/response entre agents
AgentChannelRequest Interfaces/Services/IAgentChannel.cs Request avec correlation ID, intent, payload
AgentChannelResponse Interfaces/Services/IAgentChannel.cs Response corrélée avec succÚs/erreur
NullMemoryScope Context/NullMemoryScope.cs Singleton no-op pour les contextes sans mémoire

IAgentChannel supporte trois modes :

  • RequestAsync : request/response synchrone avec timeout configurable
  • RegisterHandler : enregistrement d'un handler par agent (retourne IDisposable)
  • BroadcastAsync : notification Ă  tous les agents d'un crew (fire-and-forget)

Couche Infrastructure — StratĂ©gie autonome

Classe Fichier RĂŽle
AutonomousProcessStrategy Crew/Strategies/AutonomousProcessStrategy.cs Implémente IProcessStrategy.ExecuteAutonomousAsync
InMemoryAgentChannel Communication/InMemoryAgentChannel.cs Implémentation in-process du canal A2A (lock-free, ConcurrentDictionary)
SpawnAgentTool Tools/SpawnAgentTool.cs Outil permettant aux agents de spawner des sous-agents

Couche Infrastructure — Modifications existantes

Classe Modification
ProcessStrategyFactory Ajout du case "Autonomous" → AutonomousProcessStrategy
SequentialCrewOrchestrator Ajout du dispatch "Autonomous" avec AgentExecutionBudget.Permissive
DelegateWorkTool Ajout du paramÚtre AgentExecutionBudget? optionnel, appel RecordDelegation() avant chaque délégation

Flux d'execution

                    ┌────────────────────────────────────────────┐
                    │         AutonomousProcessStrategy          │
                    │                                            │
  Crew.Tasks ──â–ș    │  pour chaque task :                        │
                    │    1. AssignTaskAsync (LLM-based)           │
                    │    2. budget.RecordToolCall()               │
                    │    3. ExecuteTaskAsync(agent, task)         │
                    │    4. Si Ă©chec + AllowDelegation :          │
                    │       ├─ budget.RecordDelegation()          │
                    │       ├─ channel.RequestAsync(peer, task)   │
                    │       └─ peer exĂ©cute avec childBudget      │
                    │    5. BudgetExhausted? → partial output     │
                    │                                            │
                    └────────────────────────────────────────────┘

  SpawnAgentTool (optionnel, injecté dans l'agent) :
    1. budget.RecordSpawn()
    2. IAgentFactory.CreateAgentAsync(spawnRequest)
    3. ExecuteTaskAsync(spawnedAgent, task) avec childBudget

Budget multi-dimensions

Le budget contrÎle 5 dimensions indépendantes. Chaque dimension a un compteur thread-safe et une limite. L'épuisement de n'importe quelle dimension lÚve BudgetExhaustedException.

Dimension DĂ©faut Strict Permissive Description
MaxToolCalls 15 8 50 Nombre max d'appels outils
MaxDelegationDepth 2 1 4 Profondeur max de dĂ©lĂ©gation rĂ©cursive (A→B→C = 2)
MaxWallTime 5 min 2 min 15 min Temps réel maximum
MaxTokensConsumed 16 000 8 000 64 000 Tokens totaux (prompt + completion)
MaxSpawnedAgents 3 1 10 Nombre max de sous-agents créés

Presets

// Production : limites conservatrices
var budget = AgentExecutionBudget.Strict;

// DĂ©veloppement : limites larges
var budget = AgentExecutionBudget.Permissive;

// Custom
var budget = new AgentExecutionBudget
{
    MaxToolCalls = 20,
    MaxDelegationDepth = 3,
    MaxWallTime = TimeSpan.FromMinutes(10),
    MaxTokensConsumed = 32_000,
    MaxSpawnedAgents = 5
};

Child budgets

Quand un agent delegue ou spawne, le sous-agent recoit un child budget derive avec les quotas restants :

var childBudget = parentBudget.CreateChildBudget();
// MaxToolCalls = parent.Max - parent.Current
// MaxDelegationDepth = parent.Max - parent.Current - 1
// MaxWallTime = parent.Max - parent.Elapsed
// etc.

Cela garantit que la somme des consommations enfants ne dépasse jamais le budget parent.

Communication A2A (IAgentChannel)

Le canal bidirectionnel permet aux agents de communiquer en mode request/response :

// Agent A demande a Agent B de clarifier
var request = AgentChannelRequest.Create(
    from: agentA.Id,
    to: agentB.Id,
    intent: "clarify",
    payload: "Quel format de données pour le rapport ?");

var response = await channel.RequestAsync(request, timeout: TimeSpan.FromSeconds(30));

if (response.Success)
    Console.WriteLine($"RĂ©ponse: {response.Payload}");

Intents standards

Intent Description
delegate Délégation de travail (traitement par le handler du target)
clarify Demande d'information ou de précision
broadcast Notification Ă  tous les agents du crew

L'implémentation InMemoryAgentChannel est in-process et lock-free. Pour un déploiement multi-host, implémenter IAgentChannel avec Redis Streams ou un message broker.

SpawnAgentTool — Self-spawn d'agents

Outil injectĂ© dans les agents autonomes pour crĂ©er des sous-agents spĂ©cialisĂ©s Ă  la volĂ©e. La classe est livrĂ©e dans Orkeon.Infrastructure mais aucune racine de composition livrĂ©e ne l'enregistre : un hĂŽte qui veut le self-spawn enregistre SpawnAgentTool explicitement (il exige un IAgentFactory) — voir l'inventaire des tools.

// Le LLM de l'agent génÚre cet appel d'outil :
{
    "tool": "spawn_agent",
    "parameters": {
        "role": "data_analyst",
        "goal": "Analyser les tendances de ventes Q4",
        "task": "Produire un rapport CSV des ventes par region",
        "wait_for_result": true,
        "allow_delegation": false
    }
}

Chaque spawn est contrÎlé par le budget (RecordSpawn). L'agent spawné reçoit un child budget avec des limites réduites (5 itérations max, quotas restants).

Observabilite

Metadata de sortie

Le CrewOutput en mode Autonomous inclut des metadata de budget :

{
    "process_type": "autonomous",
    "agent_count": 3,
    "budget_tool_calls": "12/15",
    "budget_delegation_depth": "1/2",
    "budget_tokens": "9200/16000",
    "budget_spawned": "1/3",
    "budget_exhausted": false
}

BudgetSnapshot

budget.ToSnapshot() retourne un BudgetSnapshot immutable à tout moment, loggable et sérialisable.

Logging structuré

Tous les événements clés sont loggés via LoggerMessage :

  • Starting autonomous execution for crew {CrewId} (budget: {MaxToolCalls} tool calls, depth {MaxDepth})
  • Agent {AgentId} claimed task {TaskId}: {Reason}
  • Delegation: {From} -> {To} for task {TaskId} (depth: {Depth})
  • Budget exhausted for crew {CrewId}: dimension={Dimension}, {Message}
  • Agent {ParentId} spawned sub-agent {ChildId} (role: {Role})

Configuration YAML

# Racine plate — pas d'enveloppe crew: ; agents: est un mapping indexĂ© par id.
name: research-team
process: autonomous        # ← active le mode autonome
goal: "Produire un rapport de recherche complet"

agents:
  researcher:
    role: Chercheur
    goal: "Trouver des sources fiables"
    allowDelegation: true
    tools: [web_search, spawn_agent]  # ← spawn_agent pour self-spawn (enregistrĂ© par l'hĂŽte)

  analyst:
    role: Analyste
    goal: "Analyser et synthétiser les données"
    allowDelegation: true
    tools: [json_tool, csv_reader]

  writer:
    role: RĂ©dacteur
    goal: "RĂ©diger le rapport final"
    allowDelegation: false

Note : il n'existe pas de clĂ© YAML autonomousBudget — le loader n'en parse pas. Dans les crews YAML, le mode Autonomous s'exĂ©cute toujours avec AgentExecutionBudget.Permissive (50 appels d'outils, profondeur 4, 15 min, 64 000 tokens, 10 spawns) ; un budget personnalisĂ© (presets Strict/Default/Permissive ou valeurs custom) n'est disponible que via l'API C#.

Complémentarité avec les autres modes

Besoin Mode recommandé
Pipeline linéaire, déterminisme maximal Sequential
Manager centralisé, review de qualité Hierarchical
Tùches indépendantes, parallélisme Parallel
Boucles de raffinement, retry conditionnel Graph
Agents auto-organisés, délégation récursive, spawn dynamique Autonomous

Le mode Autonomous est le plus expressif mais aussi le moins dĂ©terministe. Pour les workloads de production sensibles, prĂ©fĂ©rer Sequential ou Hierarchical et rĂ©server Autonomous aux cas oĂč l'autonomie des agents apporte une valeur supĂ©rieure au coĂ»t de non-dĂ©terminisme (recherche exploratoire, creative writing, rĂ©solution de problĂšmes complexes multi-domaines).

Voir aussi : Guide comparatif ProcessTypes · Orchestration Graph · Schéma YAML · Retour à l'index

Edit this page