đŹđ§ 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,
IAgentChannelet ses records,AutonomousProcessStrategyetSpawnAgentToolportent[Experimental("ORKEXP002")]: le code qui les utilise doit acquitter le diagnostic (voir les API expérimentales). Exécuter une crew YAML enprocess: autonomousne 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
IDisposablequi le désenregistre) - BroadcastAsync : notification aux autres agents d'une crew, sans réponse attendue ;
InMemoryAgentChannelatteint les agents enregistrés viaRegisterCrewMember(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 poseCrewBuilder.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.MaxToolCallsborne 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 queMaxDelegationDepthse 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, plusdelegation_contextetautonomous_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 avecmemory: 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 :
MaxTokensConsumedcouvre 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 litToken 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 ;ICrewExecutionHookreçoitFailedavec cette raison (Canceledreste réservé à une vraie annulation).orkeon runsort 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})SpawnAgentTooljournalise 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 crewprocess("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