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) : pour chaque tùche, un LLM manager choisit l'agent qui la réclame ; quand cet agent échoue et autorise la délégation, la tùche est confiée à un pair via un canal agent-à-agent. Toute l'exécution est contrainte par un AgentExecutionBudget multi-dimensionnel qui garantit la terminaison.

API expérimentale. Les types du budget, IAgentChannel et ses records, AutonomousProcessStrategy et SpawnAgentTool portent [Experimental("ORKEXP002")] : le code qui les utilise doit acquitter le diagnostic (voir les API expérimentales). Exécuter une crew YAML en process: autonomous ne demande rien.

Contrairement au mode Sequential, oĂč l'ordre dĂ©clarĂ© et l'agent: de la tĂąche dĂ©cident, le mode Autonomous laisse le LLM manager dĂ©cider qui fait quoi, et donne Ă  une tĂąche Ă©chouĂ©e une deuxiĂšme chance auprĂšs d'un pair. L'orchestrateur fait respecter le budget et collecte les rĂ©sultats.

Positionnement par rapport aux autres stratégies

Stratégie Décision de routage Délégation Spawn dynamique Budget multi-dimensionnel Communication A2A
Sequential Agent déclaré, sinon sélecteur Via delegate_work_to_coworker (agents avec allowDelegation) Non Non Non
Hierarchical LLM manager Non (revue du manager Ă  la place) Non Non Non
Graph Agent déclaré, sinon sélecteur Via delegate_work_to_coworker Non Non (circuit breaker) Non
Autonomous LLM manager Sur Ă©chec, vers un pair (profondeur bornĂ©e) Via SpawnAgentTool (enregistrĂ© par l'hĂŽte) Oui (5 dimensions) RequĂȘte/RĂ©ponse

Architecture

Couche Domain — Budget d'exĂ©cution

Classe Fichier RĂŽle
AgentExecutionBudget Autonomous/AgentExecutionBudget.cs Budget multi-dimensionnel : appels d'outils, profondeur de délégation, durée, tokens, spawns
BudgetSnapshot Autonomous/AgentExecutionBudget.cs Instantané immuable pour les logs et la télémétrie
BudgetExhaustedException Autonomous/AgentExecutionBudget.cs Exception typée avec BudgetDimension (ToolCalls, DelegationDepth, WallTime, Tokens, SpawnedAgents)
BudgetDimension Autonomous/AgentExecutionBudget.cs Enum des 5 dimensions du budget

Les limites sont en init uniquement ; les compteurs sont thread-safe (Interlocked). Chaque appel Record* (RecordToolCall, RecordDelegation, RecordSpawn, RecordTokens(n)) vĂ©rifie la durĂ©e, incrĂ©mente son compteur et lĂšve BudgetExhaustedException quand le compteur dĂ©passe sa limite. ThrowIfExhausted() est la vĂ©rification prĂ©alable qui ne consomme rien, AssertWallTime() ne vĂ©rifie que l'horloge, et IsExhausted indique si une dimension est Ă©puisĂ©e. L'horloge est injectable (TimeProvider) pour les tests. PauseWallClock() arrĂȘte l'horloge murale jusqu'Ă  ce que la poignĂ©e qu'elle rend soit libĂ©rĂ©e (les pauses s'imbriquent) : ctx.llm.act en tient une pendant que le contrĂŽle des permissions attend la rĂ©ponse d'un opĂ©rateur, si bien qu'une approbation qui prend des minutes ne met pas fin Ă  un agent dont le propre run reste sous MaxWallTime.

Couche Domain — ProcessType

ProcessType.Autonomous est un membre du value object, et IProcessStrategy a un point d'entrée dédié :

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 requĂȘte/rĂ©ponse bidirectionnel entre agents
AgentChannelRequest Interfaces/Services/IAgentChannel.cs RequĂȘte avec ID de corrĂ©lation, intention, charge utile, mĂ©tadonnĂ©es optionnelles (Create(from, to, intent, payload))
AgentChannelResponse Interfaces/Services/IAgentChannel.cs Réponse corrélée (Ok(...) / Fail(...)) avec succÚs/erreur
NullMemoryScope Context/NullMemoryScope.cs Singleton no-op pour les contextes sans mémoire

IAgentChannel offre trois opérations :

  • RequestAsync : requĂȘte/rĂ©ponse avec un timeout (30 s par dĂ©faut) ; une cible qui ne rĂ©pond pas Ă  temps lĂšve TimeoutException, une cible sans handler enregistrĂ© reçoit une rĂ©ponse en Ă©chec
  • RegisterHandler : enregistrement d'un handler par agent (renvoie un IDisposable qui le dĂ©senregistre)
  • BroadcastAsync : notification aux autres agents d'une crew, sans rĂ©ponse attendue ; InMemoryAgentChannel atteint les agents enregistrĂ©s via RegisterCrewMember(crewId, agentId)

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), enregistrée comme IAgentChannel scoped
SpawnAgentTool Tools/SpawnAgentTool.cs Outil qui permet à un agent de créer un sous-agent
DelegateWorkTool Tools/DelegateWorkTool.cs Accepte un AgentExecutionBudget optionnel et appelle RecordDelegation() avant chaque délégation

Branchement

Endroit RĂŽle
ProcessStrategyFactory "Autonomous" → AutonomousProcessStrategy
SequentialCrewOrchestrator Dirige "Autonomous" vers ExecuteAutonomousAsync avec le budget de la crew (crew.Budget.ToExecutionBudget())
AddOrkeonInfrastructure() Enregistre AutonomousProcessStrategy et IAgentChannel → InMemoryAgentChannel (scoped)

Flux d'exécution

                    ┌──────────────────────────────────────────────────┐
                    │         AutonomousProcessStrategy                │
                    │                                                  │
  tñches de la      │  enregistrer chaque agent sur l'IAgentChannel    │
  crew (ordre des   │  pour chaque tñche :                             │
  dĂ©pendances)      │    0. budget.AssertWallTime()                    │
                    │    1. manager.AssignTaskAsync (LLM) → agent      │
                    │    2. budget.RecordToolCall()                    │
                    │    3. ExecuteTaskAsync(agent, tñche)             │
                    │    4. Ă©chec + AllowDelegation + profondeur + pair│
                    │       ├─ budget.RecordDelegation()               │
                    │       ├─ channel.RequestAsync("delegate",        │
                    │       │    premier autre agent, timeout 2 min)   │
                    │       └─ le pair exĂ©cute sous un budget enfant   │
                    │    5. BudgetExhausted dans la tñche → sortie     │
                    │       partielle « [BUDGET EXHAUSTED] 
 », arrĂȘt  │
                    │  BudgetExhausted entre deux tĂąches → arrĂȘt       │
                    └──────────────────────────────────────────────────┘

Les détails qui comptent pour dimensionner un run :

  • L'assignation passe par IManagerAgent (LlmBasedManager), qui appelle le LLM manager de la crew, rĂ©solu une fois par run comme en mode Hierarchical : le fournisseur que pose CrewBuilder.WithManagerLlm (C#), sinon le profil par dĂ©faut de l'hĂŽte — une crew autonome n'a pas d'agent manager : managerAgent: (.manager(agent) en .ork.ts, .WithManager(agent) en C#) est refusĂ© au chargement ou Ă  la construction de la crew. L'agent: d'une tĂąche n'est pas consultĂ©. Une erreur du LLM retombe sur le premier agent.
  • Appels d'outils : la stratĂ©gie enregistre un RecordToolCall() par tĂąche distribuĂ©e (l'assignation) ; les appels d'outils de l'agent dans sa boucle ne sont pas imputĂ©s au budget. MaxToolCalls borne donc le nombre de tĂąches tentĂ©es.
  • Profondeur de dĂ©lĂ©gation : RecordDelegation() incrĂ©mente un compteur commun Ă  la crew qui n'est jamais dĂ©crĂ©mentĂ©, si bien que MaxDelegationDepth se comporte comme le nombre de dĂ©lĂ©gations permises dans le run. Le dĂ©lĂ©guĂ© est le premier autre agent dans l'ordre de la crew ; il reprend la tĂąche elle-mĂȘme — son plan aussi, quand la crew planifie —, dans le contexte de la tentative Ă©chouĂ©e, dĂ©rivĂ© de lui : l'id et la portĂ©e mĂ©moire de la crew, les variables d'entrĂ©e du run et les sorties dĂ©jĂ  produites, plus delegation_context et autonomous_child_budget_snapshot. Il rappelle la mĂ©moire de la crew comme toute exĂ©cution qui rĂ©pond Ă  une tĂąche, sa sortie — quand elle rĂ©ussit — est le rĂ©sultat de la tĂąche, rangĂ©e une fois sous le pair avec memory: true, et il ne dĂ©lĂšgue pas plus loin. L'agent qui a Ă©chouĂ© fait Ă©chouer la tĂąche (AgentFailedTaskEvent), la tĂąche est assignĂ©e au pair, et se termine sous lui (ÉvĂ©nements).
  • Tokens : MaxTokensConsumed couvre tout le run. Les tokens d'une exĂ©cution directe sont imputĂ©s au budget de la crew Ă  son retour, ceux d'une tentative Ă©chouĂ©e compris ; ceux d'une exĂ©cution dĂ©lĂ©guĂ©e une fois sur chaque budget de la chaĂźne de l'enfant et de celle de la crew (RecordChildTokens) : un budget commun aux deux chaĂźnes est comptĂ© une fois, si bien que chaque token compte une fois par budget. Un travail dont les tokens dĂ©passent le budget, direct ou dĂ©lĂ©guĂ©, garde sa sortie : la tĂąche est consignĂ©e avec elle, puis le run s'arrĂȘte sur le budget comme pour tout autre Ă©puisement. Une tentative directe Ă©chouĂ©e qui a Ă©puisĂ© le budget n'est pas confiĂ©e Ă  un pair. Le refus se lit Token budget exhausted: <sum> tokens sent and received over <n> calls (limit <limit>).
  • RĂ©sultat : la sortie de la crew concatĂšne les sorties des tĂąches. Une tĂąche en Ă©chec — directement, sans pair Ă  qui dĂ©lĂ©guer, ou dĂ©lĂ©guĂ©e Ă  un pair qui Ă©choue aussi — fait Ă©chouer la crew, et les tĂąches qui en dĂ©pendent sont sautĂ©es sans ĂȘtre rĂ©clamĂ©es. Un budget Ă©puisĂ© fait aussi Ă©chouer la crew, son erreur commençant par Execution budget exhausted: <dimension> et nommant chaque tĂąche qu'il n'a pas atteinte ; ICrewExecutionHook reçoit Failed avec cette raison (Canceled reste rĂ©servĂ© Ă  une vraie annulation). orkeon run sort en 2 dans les deux cas.

Budget multi-dimensionnel

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 Default Strict Permissive Description
MaxToolCalls 15 8 50 Nombre maximal d'appels d'outils
MaxDelegationDepth 2 1 4 Profondeur de dĂ©lĂ©gation maximale (A→B→C = 2)
MaxWallTime 5 min 2 min 15 min Durée maximale (temps réel)
MaxTokensConsumed 16 000 8 000 64 000 Somme courante des tokens (prompt + complétion de chaque appel compté)
MaxSpawnedAgents 3 1 10 Nombre maximal de sous-agents créés

AgentExecutionBudget a une sixiĂšme limite, MaxContextTokens (dĂ©faut int.MaxValue, sans limite) : les tokens comptĂ©s en ne comptant le contexte qu'une fois, rapportĂ©s sous la dimension Tokens (BudgetDimension garde ses 5 membres) et propagĂ©s aux budgets enfants. Elle se fixe par la clĂ© contextTokens d'un budget .ork.ts — le crewBuilder().budget(...) procĂ©dural et l'option budget de crew.runAgent / ctx.delegate (DSL de script) ; le budget: YAML de la crew n'a pas cette clĂ©, et le budget .ork.ts d'une crew autonome la refuse.

Presets

#pragma warning disable ORKEXP002
// Production : limites conservatrices
var strict = AgentExecutionBudget.Strict;

// Développement : limites larges
var permissive = AgentExecutionBudget.Permissive;

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

// Un budget construit en code plutÎt que celui de la crew : appeler la stratégie directement
var strategy = serviceProvider.GetRequiredService<AutonomousProcessStrategy>();
var output = await strategy.ExecuteAutonomousAsync(crew, custom, inputVariables: null, ct);
#pragma warning restore ORKEXP002

KickoffAsync ne prend pas de budget : une crew exĂ©cutĂ©e via ICrewOrchestrationService (le runner, l'hĂŽte) dĂ©pense son propre budget — budget: en YAML (schĂ©ma), crewBuilder().budget({...}) en .ork.ts, CrewBuilder.Budget(new CrewBudget { ... }) en C#. Une crew qui n'en fixe aucun tourne sans plafond de tokens ni de temps mural, sous les limites structurelles de 50 tĂąches distribuĂ©es, 4 dĂ©lĂ©gations et 10 spawns (CrewBudget.DefaultToolCalls, DefaultDelegationDepth, DefaultSpawnedAgents) : tokens et durĂ©e ne sont bornĂ©s que si l'auteur le demande, si bien qu'une crew ordinaire n'est jamais Ă©courtĂ©e par un chiffre qu'elle n'a pas choisi. Une clĂ© omise prend le mĂȘme dĂ©faut. Un budget donnĂ© Ă  une crew d'un autre process est refusĂ© au chargement ou Ă  la construction de la crew, comme une limite infĂ©rieure Ă  1. Appeler ExecuteAutonomousAsync directement contourne ce que l'orchestrateur ajoute autour d'un run (planification, checkpointing, transitions d'Ă©tat de la crew).

Budgets enfants

Quand la stratégie délÚgue, ou que SpawnAgentTool crée un agent, le sous-agent reçoit un budget enfant dérivé :

var childBudget = parentBudget.CreateChildBudget();
// MaxToolCalls       = max(1, parent.Max - parent.Current)
// MaxDelegationDepth = max(0, parent.Max - parent.Current - 1)
// MaxWallTime        = parent.MaxWallTime - parent.Elapsed
// MaxTokensConsumed  = max(100, parent.Max - parent.Current)
// MaxSpawnedAgents   = max(0, parent.Max - parent.Current)

Un budget enfant est une copie indĂ©pendante de l'allocation restante du parent, avec ses propres compteurs : deux enfants dĂ©rivĂ©s l'un aprĂšs l'autre reçoivent chacun la totalitĂ© du reste. Le plafond du parent n'est tenu que lĂ  oĂč la consommation lui est aussi imputĂ©e — les tokens d'une exĂ©cution dĂ©lĂ©guĂ©e, et chaque spawn. Un budget peut aussi en imputer un autre (ChargedTo, posĂ© par l'option charge: "crew" du DSL de script) : chaque appel d'outil, token et spawn qu'il enregistre l'est aussi sur celui-lĂ , CreateChildBudget() transmet cette imputation Ă  l'enfant (il n'impute pas le parent lui-mĂȘme), et IsExhausted est vrai quand le budget lui-mĂȘme ou celui qu'il impute est Ă©puisĂ©.

Communication A2A (IAgentChannel)

Le canal bidirectionnel permet aux agents de communiquer en mode requĂȘte/rĂ©ponse :

// L'agent A demande une clarification Ă  l'agent B
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}");

Intentions

L'intention est une chaĂźne libre. Dans un run autonome, le handler que chaque agent enregistre comprend :

Intention Traitement
delegate Exécute la charge utile comme une tùche sous un budget enfant et renvoie sa sortie (ou Budget exhausted: 
)
toute autre (clarify, 
) Accusé de réception : Agent <role> acknowledges: <intent>
broadcast L'intention que BroadcastAsync appose sur ses notifications

L'implémentation InMemoryAgentChannel est in-process et lock-free. Pour un déploiement multi-hÎtes, implémentez IAgentChannel avec Redis Streams ou un broker de messages.

SpawnAgentTool — Auto-crĂ©ation d'agents

Un outil (spawn_agent) qui permet Ă  un agent de crĂ©er Ă  la volĂ©e un sous-agent spĂ©cialisĂ©. La classe est livrĂ©e dans Orkeon.Infrastructure mais ni la stratĂ©gie ni aucune racine de composition livrĂ©e ne la fournit : son constructeur prend l'id de l'agent parent, l'id de la crew, l'AgentExecutionBudget qu'il fait respecter et un IAgentFactory (plus, pour un spawn synchrone, un IAgentExecutionService), si bien qu'un hĂŽte qui veut l'auto-crĂ©ation en construit un par agent et l'ajoute Ă  cet agent — voir l'inventaire des outils. Le budget qu'il fait respecter est celui que l'hĂŽte lui remet, pas le budget du run.

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

role, goal et task sont obligatoires ; backstory, allow_delegation et wait_for_result sont facultatifs. Chaque spawn appelle RecordSpawn() sur le budget (un budget épuisé refuse l'appel). L'agent créé l'est avec MaxIterations = 5 et un budget enfant (transmis dans les métadonnées de la demande de spawn et dans le contexte d'exécution). Avec wait_for_result: true (le défaut), l'outil exécute la tùche et renvoie sa sortie ; false se contente de créer l'agent.

Observabilité

Métadonnées de sortie

Le CrewOutput en mode Autonomous inclut des métadonnées de budget, à cÎté de la télémétrie de tokens :

{
    "process_type": "autonomous",
    "agent_count": 3,
    "budget_tool_calls": "12/50",
    "budget_delegation_depth": "1/4",
    "budget_tokens": "9200/64000",
    "budget_spawned": "0/10",
    "budget_exhausted": false
}

BudgetSnapshot

budget.ToSnapshot() renvoie Ă  tout moment un BudgetSnapshot immuable (ToolCalls/MaxToolCalls, DelegationDepth/MaxDelegationDepth, TokensConsumed/MaxTokensConsumed, SpawnedAgents/MaxSpawnedAgents, Elapsed/MaxWallTime, IsExhausted), journalisable et sĂ©rialisable. Charged porte l'instantanĂ© du budget que celui-ci impute (ChargedTo), et IsExhausted est aussi vrai quand ce dernier est Ă©puisĂ©, mĂȘme si chaque dimension de cet instantanĂ© est sous sa limite.

Journalisation structurée

Tous les événements clés sont journalisé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})
  • Task {TaskId} completed (success: {Success}, budget: {Snapshot})
  • Budget exhausted for crew {CrewId}: dimension={Dimension}, {Message}
  • Autonomous execution completed for crew {CrewId} in {Duration} (tool calls: {ToolCalls}, delegation depth: {Depth})
  • SpawnAgentTool journalise chaque spawn (parent, id de l'enfant, rĂŽle) et la fin d'un spawn synchrone

Comme tous les modes, la stratégie rend aussi compte via ICrewExecutionHook : le démarrage d'une tùche quand un agent la réclame, les fins de tùches et l'issue de la crew quand le run se termine.

Configuration YAML

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

agents:
  researcher:
    role: Researcher
    goal: "Trouver des sources fiables"
    allowDelegation: true   # une tùche échouée de cet agent est confiée à un pair
    tools: [web_search]

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

  writer:
    role: Writer
    goal: "Rédiger le rapport final"
    allowDelegation: false

spawn_agent n'est pas listĂ© : le loader YAML rĂ©sout les noms d'outils dans le registre d'outils, oĂč aucun SpawnAgentTool n'est enregistrĂ© par dĂ©faut (un nom inconnu est ignorĂ© avec un avertissement, ou fait Ă©chouer le chargement en mode strict des outils).

Note : le budget de la crew est budget: en YAML (tokens, wallTimeSeconds, toolCalls, delegationDepth, spawnedAgents) ; dans le DSL de scripting, crewBuilder().budget({...}) le fixe dans les deux formes — la forme dĂ©clarative d'une crew process("autonomous"), la forme procĂ©durale (await crew.run()) — et la forme dĂ©clarative d'un autre process le refuse, comme le YAML, ainsi qu'une limite infĂ©rieure Ă  1. Les dĂ©fauts sont sous Presets.

Délégation : la stratégie autonome délÚgue via l'IAgentChannel ; il n'existe pas de service de délégation de tùches.

Complémentarité avec les autres modes

Besoin Mode recommandé
Pipeline linéaire, déterminisme maximal Sequential
Manager centralisé, revue qualité Hierarchical
Tùches indépendantes, parallélisme Parallel
Relance de tùches instables, run borné Graph
Assignation pilotée par LLM, deuxiÚme chance auprÚs d'un pair, run borné par un budget Autonomous

Le mode Autonomous est le moins dĂ©terministe. Pour les charges de production sensibles, prĂ©fĂ©rez Sequential ou Hierarchical et rĂ©servez Autonomous aux cas oĂč laisser le manager distribuer le travail apporte plus que le coĂ»t du non-dĂ©terminisme (recherche exploratoire, Ă©criture crĂ©ative, rĂ©solution de problĂšmes multi-domaines complexes).

Tests

Fichier de test Couverture
Orkeon.Infrastructure.Tests/Strategies/CovAutonomous_AutonomousProcessStrategyTests.cs Points d'entrée, repli d'assignation, délégation via le canal, épuisement des appels d'outils et de la durée, télémétrie de tokens, handlers du canal
Orkeon.Domain.Tests/Autonomous/AgentExecutionBudgetTimeProviderTests.cs Budget de durée avec une horloge contrÎlable
Orkeon.Infrastructure.Tests/Communication/CovStubs_InMemoryAgentChannelTests.cs RequĂȘte/rĂ©ponse, timeout, handler absent, broadcast
Orkeon.Infrastructure.Tests/Tools/SpawnAgentTool/SpawnAgentToolTests.cs Spawn imputé au budget parent, propagation du budget enfant (métadonnées, variables de contexte), décompte des tokens
Orkeon.Infrastructure.Tests/Orchestration/CovAutonomous_SequentialCrewOrchestratorTests.cs Aiguillage des six modes (Autonomous sous le budget de la crew, sans plafond quand elle n'en fixe aucun)

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