🇬🇧 English version
Voir aussi : Retour à l'index
Limites et contraintes connues
InMemoryUnitOfWorkn'a par conception aucune étape de persistance durable : les agrégats vivent dans les repositories in-memory etSaveChangesAsyncse réduit au dispatch (réel et ordonné) des événements de domaine. Un adapter durable remplacerait cet adapter dans son ensemble ; le code ne porte aucune migration EF.- Persistance d'état d'exécution : par défaut, les états d'exécution de crew (
ICrewExecutionStateManager) sont in-memory only (pas de reprise après crash). La persistance durable est opt-in : choisir un state store de checkpointing — la sectionOrkeon:Checkpointing(Enabled,Storejson, sqlite ou postgres), lue parorkeon runetorkeon-host, ouAddOrkeonCheckpointing(configuration)/AddOrkeonSqliteCheckpointing/AddOrkeonPostgresCheckpointingdans un hôte écrit en C# — et activerAddCrewExecutionStatePersistence(...)(ou la sectionOrkeon:ExecutionState:Persistence). Un run échoué ou tué se reprend avecorkeon run --resume <id>|latestà la granularité de la tâche : chaque tâche qu'un run termine est checkpointée à sa fin, et un run repris répond à celles-là depuis le checkpoint sans appeler le modèle. Les décisions du manager d'une crew Hierarchical ou Autonomous sont rejouées en direct à la reprise (seules les tâches sont gardées : le manager est interrogé de nouveau pour affecter et relire), une tâche de décision (decision:) est reposée en Sequential et en Parallel (Graph checkpointe la route qu'une décision a prise et la rejoue), et une tâche en cours quand le processus est mort repart de son début. Une tâche modifiée entre les runs (sa description ou sa sortie attendue telles que les variables du run les remplissent, donc un--varchangé compte, son agent ou ses dépendances) est rejouée, ainsi que chaque tâche qui s'exécute après elle, puisque ce qu'elles liraient de sa sortie est périmé ; l'hôte journalise un avertissement qui la nomme.--resume latestprend le run le plus récent de la crew qui n'est pas terminé (un run terminé plus récent ne cache pas un run échoué plus ancien) ; un run encore marquéRunningn'est pas repris parlatest, car le magasin ne tient aucun bail et il peut être vivant dans un autre processus : le refus donne son id, et--resume <id>le reprend. Une session qui attend une réponse, ou marquée en échec, est refusée parlatest, et par son id, seulement quand l'historique des runs prouve son propriétaire vivant (enregistré en cours avec un processus vivant sur cet hôte, ou lancé sur un autre hôte) ; sans trace dans l'historique, elle est reprise. Faute de bail, rien d'autre n'empêche deux processus de reprendre le même run par son id en même temps. Un run se reprend depuis l'endroit où il a été lancé : déplacer ou renommer le checkout (ou le fichier de crew) change la clé de crew et orpheline ses runs précédents. Deux limites de l'identité du run : l'id de tâche A2A et celui de l'API ne sont pas unifiés avec l'id du run (StateStoreA2ATaskStorereste sur sa propre clé__a2a__et ses propres ids de tâche). La clé de crew d'une session est le nom de la crew, le chemin virtuel de son fichier et une courte empreinte du chemin complet de ce fichier (deux dossiers se lisent tous deux/crewpour le système de fichiers virtuel) : deux crews de même nom ne partagent jamais une session.Orkeon:Checkpointing:StoresansEnabled: trueest ignoré et l'hôte le dit à son démarrage. Une fois activée, les états sont persistés à chaque transition et rechargés/réutilisés après redémarrage — voir Sous-systèmes opt-in. Limites v1 : métadonnées persistées en chaînes invariantes,ToolsUsednon persisté. - Le framework cible .NET 10 — sa version est définie dans
src/Directory.Build.props. .NET 11 n'est pas une cible :ci.ymlconstruit et teste la solution avec le SDK 11.x (jobbuild-test-net11) en guise d'alerte précoce, et les deux dotnet tools (orkeon,orkeon-repl) acceptent un runtime majeur plus récent (RollForward=Major) pour qu'une machine n'ayant que .NET 11 puisse les exécuter. Le passage du target framework, deglobal.jsonet des images de base des conteneurs à .NET 11 est prévu ; le CHANGELOG le consignera quand il aura lieu. - Le périmètre fonctionnel est gelé à 16 fournisseurs LLM (quatorze vendeurs et deux agrégateurs — OpenRouter et Mammouth AI, la première exception motivée au gel, intégrés documentation d'abord et campagnés le 2026-10-07), 124 outils intégrés (la famille e-mail est la deuxième exception motivée ; Gmail et Hotmail via Graph sont campagnés, Outlook en IMAP et SMTP n'a pas été joué ; la famille drive — Google Drive et OneDrive — est la troisième, campagnée sur des comptes personnels ; l'outil
firefoxest la quatrième) et 6 stores de mémoire tant que de vrais utilisateurs n'en demandent pas davantage : un mainteneur unique porte toute la surface, et chaque ajout est un coût permanent. Pas de 17ᵉ fournisseur : les endpoints qui parlent le dialecte OpenAI n'ont pas besoin de fournisseur (pointezLlm:BaseUrldessus) ; les outils s'écrivent en scripts.ork.tsou en plugins. La règle et ce qui reste bienvenu sont dans CONTRIBUTING.fr.md. - Pas d'API batch : les points d'accès batch asynchrones des fournisseurs (Anthropic Message Batches, OpenAI Batch et leurs pairs) ne sont pas pilotés. Un batch répond à l'échelle de l'heure et n'accepte aucun appel d'outil interactif : il ne peut pas porter la boucle agentique (appel, résultat d'outil, appel), et le servir demanderait un mode d'exécution différé qui n'existe pas. Un run qui voudrait le tarif batch n'a aucun chemin pour l'obtenir ; la bascule d'un profil ne s'en sert pas non plus.
- Une clé de LLM est la clé, jamais un nom de secret.
LlmConfigporte la clé d'API elle-même (LlmConfig.ApiKey) ; rien dans le framework ne lit une clé de LLM dans un coffre de secrets. Un hôte qui y garde ses clés résout la clé lui-même et l'affecte ÃApiKey; les chemins supportés pour la fournir sont le fichier de settings (Llm:ApiKey), l'environnement (ORKEON_Llm__ApiKey) et — pour garder la clé hors du fichier — la variable que nomme le fichier (Llm:ApiKeyEnvVar, et par profilLlm:Profiles:<nom>:ApiKeyEnvVar, lue dans l'environnement du processus puis dans la portée Utilisateur de Windows ; voir la configuration). - Le streaming LLM est uniforme à la frontière du framework : les 16 providers héritent du lecteur de streaming SSE/NDJSON de
HttpLlmProviderBase(IStreamingLlmProvider).SupportsStreamingn'est pas untrueinconditionnel : il suit le fait que le provider soit réellement utilisable (une clé d'API quand le fournisseur en exige une, plus l'endpoint de ressource pour Azure), si bien qu'un provider non configuré déclarefalseet que tout appelant qui teste la capacité prend le chemin tamponné — celui qui rend la réponse explicite « API key is required » — au lieu d'une branche SSE qui se terminerait sans le moindre chunk. L'exception restante par provider est le/api/chatd'Ollama (voir l'entrée Ollama ci-dessous). Un appel streamé court entier sousLlm:TimeoutSecondset, quand il est posé, sousLlm:StreamIdleSecondsentre deux chunks ; deux bords subsistent : sur la phase des en-têtes le même délai court deux fois (HttpClient.Timeoutet le budget du flux, démarrés à un instant d'écart), si bien qu'un délai atteint peut coûter une tentative de connexion de plus avant que l'échec soit rapporté ; et les flux texte seul (GenerateStreamingAsync), qui ne portent aucune métadonnée, ne peuvent pas signaler un flux fermé sans son marqueur de fin après un début de texte — ils se terminent normalement, là où le flux chat portestream_truncated. - Le fournisseur
mockdiffuse en un seul fragment :Provider: mock(orkeon run --llm-mock) émule le flux en envoyant toute la réponse comme un seul événement de contenu avant la réponse complète, et ne déclare aucun flux natif ; il apparie le dernier message utilisateur d'un appel, pas toute la conversation, et il n'a aucun drapeau de capacité « appel d'outil natif » à déclarer — le framework n'en a pas : ses appels d'outil sont un corps de réponse à la forme OpenAI (choices[0].message.tool_calls), que lit la stratégie d'appel d'outil par défaut de l'hôte, comme elle lit celui d'Ollama, et une crew avec un vrai outil le parcourt de bout en bout. Un hôte qui enregistre une autre stratégie lit ce corps avec elle, et un appel d'outil du mock peut alors ne pas s'y analyser. Le dossier de son fichier de réponses est un montage interne : il ne peut contenir ni la crew ni le script. - Une cassette fige les réponses du modèle, pas le run :
--llm-recordet--llm-replay(guide) rangent chaque appel sous un hachage du profil, des messages, du message système, des outils et du mode d'outil, du format de réponse et de la grammaire ; tout changement d'un prompt, d'un outil ou du format est donc un échec de rejeu (ReplayMissException, jamais un appel réseau) jusqu'à ce que la cassette soit réenregistrée. Les outils s'exécutent de nouveau au rejeu, et les embeddings comme la mémoire ne sont pas enregistrés. La clé tient aussi le modèle et les options d'échantillonnage (température, top-p, graine, pénalités, séquences d'arrêt, nombre maximal de jetons, réflexion) : en changer un est aussi un échec de rejeu. Une cassette n'est masquée que pour la clé configurée et les motifs listés (dans un appel en flux, sur les deltas réunis, si bien qu'un secret coupé entre deux deltas est masqué aussi), et la clé est calculée sur la forme masquée ; un secret qu'aucun motif ne reconnaît n'est ni masqué ni reporté dans la clé : relisez une cassette avant de la versionner. Deux agents qui demandent la même clé au même instant prennent les réponses enregistrées dans l'ordre où ils les demandent : un run dont des appels parallèles identiques changent d'ordre peut les permuter. - Le compteur de tokens compte les appels de génération — tous, et seulement eux.
cost.updatedetrun.finishedadditionnent les appels d'une exécution à travers l'unique décorateur de mesure qui enveloppe chaque fournisseur : les tours d'agent et leurs relances, le manager hiérarchique, le planificateur, les pipelines RAG, les services mémoire, les juges LLM et les appelsctx.llm.*. Les appels d'embeddings ne sont pas comptés — les vecteurs de l'ingestion et de la recherche RAG, desemantic_search, de l'indexation RaggableTree et de la mémoire d'une crew (ce qu'elle range et ce qu'elle rappelle) viennent des ports d'embeddings, que le total ↑/↓ ne voit pas. Deux conséquences de l'emplacement du compteur : un fournisseur qu'un hôte enregistre lui-même n'est mesuré que s'il passe parAddOrkeonLlmProviderouAddOrkeonLlmProfile, ou s'il est donné au manager d'une crew parCrewBuilder.WithManagerLlmou à son planificateur parCrewBuilder.WithPlanningLlm(unIChatClientqui ne repose pas sur unILlmProviderOrkeon n'est pas mesuré du tout), et un flux texte seul, qui ne porte aucun usage, est compté à sa fin sur estimation — signalée parestimatedTokens, jamais chiffrée en coût. - A2A dans les binaires livrés :
orkeon-hostsert les crews qu'exposeOrkeon:Host:A2A— une compétence par crew, une tâche étant un run de cette crew par le runner qu'emprunte un message de chat (ses montages, sa borne de concurrence, le délai de l'hôte), le démarrage refusé quand l'écoute irait au-delà de la boucle locale sans authentification — voir Hôte de service ; il ne garde aucun enregistrement de tâche (GET /a2a/tasks/{id}répond501). L'API de run et les sondes de santé sont un listener à part, éteint saufOrkeon:Host:Api:Enabled— voir l'API du host :POST /runs/{id}/inputrépond à la question d'entrée humaine en attente d'un run (200 deliveredpour un run tenu,202 recordedpour un run suspendu), et ses clés d'idempotence ne survivent à un redémarrage que par l'historique de runs.orkeon runet le REPL ne servent pas A2A : un run unique n'a rien à écouter.orkeon-hostconnecte aussi lesMCP:Serversau démarrage, commeorkeon runetorkeon-repl— voir Intégration MCP. Un hôte C# qui appelleAddOrkeonA2Aobtient un serveur démarré avec l'hôte générique (EnableServer) dont le routeur exécute l'agent que désigne une tâche — voir Conformité A2A. - Défauts DI délibérément minimaux —
IKnowledgeStore(in-memory, non persistant ; sonSearchAsyncignore la requête) etIAgentExecutionServicesont des remplaçants qui s'annoncent chacun par un Warning unique nommant la remédiation ; rien n'appelle un LLM ni ne persiste implicitement. Inventaire complet et gestes de remplacement : Comportements par défaut - Les outils custom doivent implémenter
IBaseToolou hériter deToolBase<TReq,TRes>. Le chargement de plugins au runtime existe (opt-inAddOrkeonPlugins(...)— un manifesteplugin.jsonpar dossier de plugin,AssemblyLoadContextcollectables isolés, voir Plugins) ; limites v1 : les assemblies chargées s'exécutent en pleine confiance (pas de sandbox), et il n'y a pas de hot-reload - Plusieurs sous-systèmes (A2A, monitoring backend, NIST, DLP, rate-limiting d'outils, rotation de clés, benchmarking, validation multi-modale, hooks de kickoff, le sous-système RAG —
AddOrkeonRag+AddOrkeonRagTools, plus l'opt-inAddOrkeonOnnxReranker; le transport du repli web est câblé parAddOrkeonRaglui-même et gouverné par la configuration) sont opt-in :AddOrkeonInfrastructure()/AddOrkeonApplication()ne les enregistrent pas, et chacun s'active par son extension dédiée — voir Sous-systèmes opt-in. - A2A — la persistance des tâches est opt-in : enregistrez un state store de checkpointing plus
AddOrkeonA2ATaskPersistence(), etGET /a2a/tasks/{id}répond200avec le cycle de vie enregistré (404pour un id inconnu) tandis queDELETEinterrompt une tâche sur laquelle l'agent travaille encore (elle finitCancelled), répond409pour une tâche terminée et404pour un id inconnu. Sans l'opt-in,GETcontinue de renvoyer un501explicite plutôt que de fabriquer un état. Les écarts plus larges vis-à -vis de la spec v1.0 (bindings, push notifications, cycle de vie à 9 états,A2A-Version) sont inventoriés dans la matrice de conformité A2A. - A2A mTLS —
A2AClientcharge le certificat client (A2ASecurityOptions.ClientCertificatePath) et applique toujours la validation complète du certificat serveur — il n'existe délibérément aucun opt-out « accepter n'importe quel certificat » ; un serveur auto-signé ou de dev local épingle sa CA viaTrustedCertificateAuthorities. Côté serveur, quandRequireMutualTls = true,A2AServern'accepte que les certificats clients qui chaînent vers l'une desTrustedCertificateAuthoritiesou correspondent à une empreinte épinglée deTrustedClientCertificateThumbprints(403 sinon) et refuse de démarrer si aucune ancre de confiance n'est configurée (fail-closed). La révocation n'est pas vérifiée (CA privées sans endpoints CRL/OCSP supposées). L'épinglage CA côté client ne couvre que la chaîne inconnue — un mismatch de nom d'hôte n'est jamais contourné. QuandAllowedAuthSchemesest défini, une requête n'est acceptée qu'avec un identifiant que le validateur de son schéma accepte (401 sinon) : un jetonBearervalidé par unIAuthenticationProviderenregistré (A2A:Security:AzureAD/A2A:Security:Oidc), uneApiKeyégale à un secret nommé dansApiKeySecretNames; le serveur refuse de démarrer quand un schéma déclaré n'a pas de validateur.A2AClientenvoieAuthorization: <ClientAuthScheme> <secret>quandClientAuthSchemeetClientCredentialSecretNamesont définis, le secret étant lu viaISecretProviderà chaque appel. La terminaison TLS mutuelle réelle requiert un binding HTTPS deHttpListener(réservation HTTP.sys / certificat serveur) configuré au niveau de l'hôte ; l'endpoint de découverte/.well-known/agent.jsonreste public. - La sélection sémantique d'agents (
OrkeonApplicationOptions.AgentSelectionStrategy = Embedding) hérite de la chaîne de résolution d'embeddings réelle : l'IEmbeddingServicepar défaut adapte le portIEmbeddingProvider(BGE local siAddOrkeonLocalEmbeddings()est enregistré → provider distant viaOrkeon:Embeddings→ échec expliciteInvalidOperationExceptionau premier usage, message actionnable). Il n'y a aucun repli non sémantique silencieux : sans embedding provider, la stratégieEmbeddingéchoue bruyamment — configurer un provider, ou préférer la stratégieSkill(correspondance lexicale, sans dépendance) ou le défautFirstFit(premier agent disponible). - Le chemin RAG ne se dégrade pas en silence — le pipeline d'ingestion (
Orkeon.Rag) embedde les chunks à l'ingestion et le document store cherche par similarité vectorielle scorée (les scores survivent de bout en bout jusqu'ÃScoredChunk), et le portIEmbeddingProviderse résout BGE local (siAddOrkeonLocalEmbeddings()est enregistré) → provider distant viaOrkeon:Embeddings→ échec explicite (InvalidOperationExceptionau premier usage, message actionnable).HashBasedEmbeddingProviderest un double de test uniquement — il n'est jamais résolu implicitement. - Tool calling natif — Ollama :
OllamaLlmProvideratteint/api/chat— et est câblé avec la stratégie native OpenAI — dès que la conversation déclare des outils, rejoue des appels d'outils, ou transporte une part non textuelle (une part audio ou fichier y est alors refusée parNotSupportedException, comme chez OpenAI et Anthropic). Il remet en forme la réponse d'Ollama (message.tool_callsavecargumentsen objet JSON, sans tableauchoices) dans le corps OpenAI que lit l'unique parser du framework (choices[0].message.tool_calls,argumentsen chaîne JSON), et assigne des ids d'appel positionnels puisqu'Ollama n'en émet pas. Limites restantes : tout le reste — conversations simples, génération mono-prompt — passe encore par/api/generate, donc le protocole texte de repli reste aux commandes pour les modèles sans support des tools (un appel streamé prend le même point d'accès que l'appel bufferisé) ; et les images doivent être fournies en octets, puisqu'Ollama prend des payloads base64 nus et ne télécharge jamais une URL distante. - Profils RAG
adaptive/corrective— les nœuds dépendant d'un LLM se dégradent hors ligne : la route Adaptive-RAGIterativedélègue au pipeline graphecorrective(l'étaperoutetracedelegate=correctiveetRagTrace.Routeporte la décision). Limites honnêtes restantes : le classifieur de complexité par défaut est l'heuristique déterministe ; le classifieurllmrequiert unIChatClientenregistré (sans lui, repli sur l'heuristique avec avertissement) ; et sans vrai LLM le graphe correctif ne peut pas combler un fossé de vocabulaire — en évaluation--offlinele stub extractif alimenterewrite_query/evaluate/check_groundedness: le parseur tolérant du grader pêche des mots de grade dans les passages recopiés (verdicts déterministes, dictés par l'unique mot de verdict que le corpus de référence contient ; le repli du vérificateur d'ancrage reste sûrementgrounded), et une réécriture déclenchée dégénère en le préfixe fixe du stub — une seule probe dénuée de sens partagée par tous les cas — donc les chiffrescorrectiveoffline mesurent les garde-fous de la boucle plus cette dégradation, pas la qualité de réécriture, et peuvent tomber sousquality(tableau mesuré et analyse dansexamples/rag/eval/README.md; le mécanisme de bout en bout — verdict de l'évaluateur → réécriture → citation récupérée sur le cas seedé q-007 — est prouvé parCorrectiveRagMechanismSlowTestsavec un LLM scripté, étiqueté comme tel). La même note offline vaut pour les transformers de requête LLM (multi-query/rag-fusion/hyde) : le chemin mesuré offline estQueryTransform.Mode=none+ routage heuristique. - Les profils RAG
balanced/quality/adaptiveexigent les paquets du reranker ONNX : leurs presets activent l'étage de rerank cross-encoder. Les trois binaires livrés —orkeon,orkeon-hostetorkeon-repl— l'enregistrent. Un hôte C# à soi qui ne référence pasOrkeon.Rag.Onnx+Orkeon.Rag.Onnx.Modelet n'appelle pasAddOrkeonOnnxReranker()refuse de démarrer sous ces profils, en nommantonnxet les rerankers qu'il connaît.fast(le défaut) etcorrective(le graphe corrige en bouclant, pas d'étage de rerank linéaire) fonctionnent sans les paquets ONNX.adaptiveen a besoin car sa routeSingleShotdélègue Ãbalanced. - Runtime natif ONNX — les suites qui le chargent : deux suites de tests chargent la bibliothèque native ONNX Runtime —
tests/tools/Orkeon.Tools.Embeddings.Local.Tests(embeddings BGE-micro-v2 locaux) ettests/rag/Orkeon.Rag.Onnx.Tests(reranker cross-encoder ms-marco) — et exigent donc une plateforme où cette bibliothèque se charge ; toutes deux tournent en simples étapesdotnet testen CI et dans un conteneur. UnLocalEmbeddingProviderlibéré lèveObjectDisposedExceptiondepuisEmbedBatchAsyncetDimensions. - Le modèle d'embeddings local lit l'anglais. BGE-micro-v2 — le modèle embarqué d'
Orkeon.Tools.Embeddings.Local, derrière la recherche sémantique locale, la récupération RAG par embeddings locaux, la sélection sémantique d'agents etorkeon usecases search— a été entraîné sur de l'anglais. Son vocabulaire WordPiece (30 522 tokens) ne contient aucune lettre accentuée et 244 caractères chinois : « matin », « chaque » ou « résumé » lui arrivent découpés en fragments, alors que « morning » et « report » sont des mots entiers. Un texte français, espagnol, allemand ou chinois obtient bien un vecteur, mais bien plus proche du bruit que du sens : attendez-vous à une recherche sémantique, une récupération ou une sélection d'agents par embeddings nettement plus faibles hors de l'anglais.orkeon usecases searchest construit autour : BM25 porte les cinq langues, les fiches sont vectorisées à partir de leur texte anglais, et le sens n'est ajouté que pour les langues où son jeu d'or a mesuré un gain (référence du CLI). Pour une recherche sémantique dans d'autres langues, configurez un fournisseur d'embeddings distant multilingue (Orkeon:Embeddings). - Providers d'embeddings : cinq, et un modèle changé est refusé là où un montage porte l'empreinte —
Orkeon:Embeddings:Provideraccepteopenai(tout générateur M.E.AI),ollama,mistral,azure-openaietgemini(providers). Cohere, Voyage et pgvector ne sont pas livrés. Les vecteurs dépendent du modèle qui les a produits. Là où un montage couvreOrkeon:Embeddings:FingerprintPath, l'hôte compare au démarrage le provider, le modèle et les dimensions à l'empreinte qui y est consignée et refuse de démarrer si elles diffèrent ; rien n'est migré, il faut ré-embedder et vider les vecteurs stockés, puis supprimer le fichier d'empreinte. Le garde-fou voit les réglages d'embeddings, pas les magasins de vecteurs : un magasin rempli par un autre hôte, ou par du code qui a construit son propre provider, n'est pas vérifié. Un hôte doté d'un provider d'embeddings est gardé, avec ou sans sectionOrkeon:Embeddings: un hôte qui a produit des vecteurs avec le défaut embarqué puis nomme un autre provider est refusé (un hôte sans provider d'embeddings n'écrit rien). Il ne garde pas partout :orkeon forgeconsigne son empreinte par session sous/forge, donc ne garde rien d'une session à l'autre ;orkeon ragn'utilise aucune empreinte d'hôte, et le manifeste de chaque collection refuse un changement de modèle à l'ingestsans--reindex, ausearch, Ãeval rag --no-ingest -cet Ãeval rag -cavec sa passe d'ingestion et sans--reindex(orkeon rag ingest --reindexreconstruit la collection) ; un hôte dont leFingerprintPathne se trouve sous aucun montage (pas de/workspace) saute le garde-fou en Debug ; sur un montage sans Write ni Create sur le fichier ni Create sur son dossier, une empreinte existante est encore vérifiée et un changement de modèle encore refusé, une empreinte absente n'est pas consignée (Debug, sans Warning) ; unFingerprintPathvide désactive le garde-fou, sans journal. LeMinScorepar défaut (0,6) n'a été mesuré que sur le modèle local ; aucun modèle d'embeddings distant n'a encore de mesure. Orkeon.Tools.Embeddings.Localrepose sur une pré-release d'un amont archivé — l'opt-in d'embeddings locaux on-device est bâti surSmartComponents.LocalEmbeddings 0.1.0-preview10148(épinglé dansDirectory.Packages.props), qui est la seule version existante : l'amont n'a jamais publié de version stable, et le dépôt visé par leprojectUrldu paquet (dotnet-smartcomponents/smartcomponents) est archivé — le code a déménagé versdotnet/smartcomponents, qui ne livre toujours pas de 1.0. Attendre un amont stable n'est pas un plan. Le volet licence est tranché et documenté (MIT pour le wrapper comme pour les poids BGE-micro-v2 embarqués, provenance établie à la main dansTHIRD-PARTY-NOTICES.mdsections 1-2) ; ce qui reste est une contrainte de packaging : NuGet refuse de packager un paquet stable qui dépend d'une pré-release (NU5104). Une version stable d'Orkeon ne peut donc pas porter cette dépendance dans son paquet principal — c'est exactement pour cela que cet opt-in est livré comme paquetOrkeon.Tools.Embeddings.Localà part plutôt que fondu dans le parapluieOrkeon. Conséquence pour un consommateur : référencer cet opt-in fait entrer une dépendance pré-release dans votre propre graphe, et si vous publiez ensuite un paquet stable qui en dépend, vous heurtezNU5104à votre tour. Échappatoires, de la moins coûteuse à la plus coûteuse : (a) ne pas référencer l'opt-in — le portIEmbeddingProviderrésout alors un provider distant depuisOrkeon:Embeddings(voir l'entrée sélection sémantique d'agents ci-dessus) ; (b) implémenterIEmbeddingProvidersur votre propre pile d'embeddings ; (c) vendorer le wrapper d'inférence amont (MIT, donc autorisé) dans une assembly que vous contrôlez et retirer la référence de paquet. La préversion est assumée, pas vendorisée. UnOrkeon.Tools.Embeddings.Localstable dépend deSmartComponents.LocalEmbeddings 0.1.0-preview10148;NU5104est réduit au silence dans ce seul projet de packaging (l'ombrelle,Orkeon.Toolset la CLI ne déclarent jamais la dépendance), un pack stable de toute la ligne réussit, et le README dit en une ligne quel opt-in reste sur une préversion et pourquoi. Vendoriser le wrapper d'inférence (issue (c)) reste possible pour un consommateur qui exige un graphe entièrement stable ; cela ne vaut pas une seconde copie d'un wrapper MIT pour le framework lui-même. Les dotnet toolsorkeon/orkeon-replet les installeurs ne sont pas concernés parNU5104— un paquet tool est self-contained et c'est sa propre version que NuGet contrôle. Ils embarquent en revanche les poids BGE-micro-v2 (environ 17 Mo, sousLocalEmbeddingsModel/), redistribués sous MIT avec les notices deTHIRD-PARTY-NOTICES.md; le paquetOrkeon.Tools.Embeddings.Locallui-même les retire, puisque son consommateur les obtient autrement. Le paquetSmartComponents.LocalEmbeddings(~40 Ko) ne contient aucun poids : sa ciblebuild/téléchargemodel.onnxetvocab.txtdepuis huggingface.co au premier build d'un projet qui référenceOrkeon.Tools.Embeddings.LocalouOrkeon.Scripting(tous deux laissent passer cette cible) et les copie dansLocalEmbeddingsModel/default/de sa sortie. Un premier build hors ligne échoue dans la tâche amontDownloadFile; les builds suivants réutilisent la copie mise en cache à côté du paquet. Pour éviter le téléchargement, mettezExcludeAssets="build"sur chaquePackageReferencequi atteint le paquet,Orkeon.ScriptingcommeOrkeon.Tools.Embeddings.Local: NuGet réunit les drapeaux, donc une seule référence sans lui garde le téléchargement. Le projet se compile alors hors ligne, sans le modèle. L'embedder local est construit au premier embedding, non au démarrage : un hôte ainsi compilé démarre, et son premier embedding local échoue par uneInvalidOperationExceptionqui nommeLocalEmbeddingsModel/default/model.onnx, l'exclusion et chaque référence qui peut porter le modèle (Orkeon.Scripting,Orkeon.Tools.Embeddings.Local,SmartComponents.LocalEmbeddings) ; un hôte qui produit ses embeddings par un fournisseur distant n'y arrive jamais.- Le repli web RAG est un double opt-in, désactivé par défaut : le nÅ“ud
web_fallbackdu graphe correctif ne s'exécute que quand les deux interrupteurs sont activés —Orkeon:Rag:Corrective:WebFallback(politique : le graphe a-t-il le droit de sortir du store local) etOrkeon:Rag:WebFallback(transport : endpoint SearxNG —AddOrkeonRagcâble le transport, dont l'adaptateurIWebDocumentRetrieverdu graphe correctif n'est enregistré que si activé avec un endpoint non vide). Chaque page téléchargée est filtrée parPromptInjectionDocumentValidatoravant d'entrer dans le working set (les pagesRejectedn'entrent jamais ;Suspicioussuit la politique configurée) — voir Sécurité - Outils e-mail — quelques limites de protocole (
Orkeon.Tools.Email, voir le guide) : Gmail a été campagné sur un vrai compte le 2026-10-04 (mot de passe d'application) et le 2026-10-05 (OAuth2) — ce que cela a établi ; Hotmail via Microsoft Graph le 2026-10-12. Outlook en IMAP et SMTP n'a pas été exécuté contre un vrai compte. Une page de recherche contient une dizaine de messages quoi que demandelimit, étant coupée à un résultat d'outil : seul unnext_cursornul termine un dossier. Aucun outil ne rend les libellés Gmail d'un message. POP3 ne lit que la boîte de réception — pas de dossiers, de marques, de brouillons ni de corbeille ; une suppression est définitive et exige le droitPurge; une recherche ne filtre que sur l'expéditeur, l'en-tête To, l'objet et les dates, sur au plus 200 messages par appel. Microsoft Graph accepte 4 Mo par requête, soit environ 3 Mo de pièces jointes (pas de session de chargement), et une recherche texte passe par KQL avec les marques et les dates appliquées côté client : une page peut donc contenir moins de messages que demandé. Sur un serveur IMAP personnalisé,raw_queryest refusée (elle exige Gmail ou Graph), et sans UIDPLUS un message déplacé ou un brouillon enregistré revient sans son nouvel id. Outlook en IMAP hérite de la régression OAuth grand public de Microsoft du 2026-09-24, d'où Graph par défaut.Send:MaxPerHourse compte par processus, tentative refusée comprise. Le filtre anti-injection ne voit le contenu caché que par une courte liste de déclarations en ligne (display:none,visibility:hidden,opacity:0,font-size:0,max-height:0,width:0,height:0,mso-hide:all) et l'attributhidden— un texte masqué par une classe CSS d'un bloc<style>, une police d'un pixel ou du blanc sur blanc n'est ni retiré ni signalé, et une partie texte brut, que lit l'agent quand il y en a une, n'est pas comparée au HTML ; un corps qui imbrique des éléments sur plus de 5000 niveaux est remplacé par un avis d'une ligne. Les fichiers de jetons OAuth sont du JSON en clair — à l'abri des outils du VFS, pas d'un outil shell ou de code qui tourne sous le même utilisateur du système — etorkeon-replne tient aucun magasin de jetons : les comptes OAuth ne fonctionnent que sous le CLIorkeonet le démonorkeon-host. Pas dans cette version : supprimer des dossiers, copier un message ou lui donner plusieurs libellés Gmail, l'approbation interactive d'un envoi (email_draftest la voie de relecture). - Outils drive — périmètre et limites des fournisseurs (
Orkeon.Tools.Drive, voir le guide) : la campagne contre un vrai Google Drive et un vrai OneDrive a été close le 2026-11-17. Son passage consigné, le 2026-10-24, a porté sur un compte Google personnel et un compte Microsoft personnel et a mené aux correctifs dedrive_search; un compte OneDrive professionnel ou scolaire n'a pas été joué, et aucun rapport de campagne n'est écrit. Un compte ne voit que son propre « Mon Drive » ou son OneDrive : les drives partagés Google et les bibliothèques SharePoint ne sont pas atteints. Une recherche sur Google Drive ne peut pas être bornée à une sous-arborescence : ses résultats hors duRootdu compte sont écartés, et une page peut contenir moins d'éléments quelimit; sur OneDrive une recherche ne prend que des mots (textouname_contains), les autres critères étant appliqués à ce qu'elle rend, etraw_queryest refusée. Un compte du tenantconsumers(comptes Microsoft personnels) ne supprime rien définitivement sur OneDrive. Les documents Google sont lus via leur export texte (texte brut, ou CSV pour une feuille de calcul — sa première feuille) et téléchargés par export ;drive_readrécupère au plus 2 Mo, un fichier plus gros ou binaire passant pardrive_downloadet les outils fichiers. La vérification de la racine remonte 32 niveaux de parents au plus. Les chargements s'arrêtent ÃMaxUploadMegabytes(100 par défaut), envoyés dans une session reprenable vers Google (par tranches de 8 Mio au-delà de 8 Mio) et par tranches de 10 Mio vers OneDrive au-delà de 4 Mio. Les fichiers de jetons sont du JSON en clair — à l'abri des outils du VFS, pas d'un outil shell ou de code qui tourne sous le même utilisateur — etorkeon-replne tient aucun magasin de jetons : les comptes drive ne fonctionnent que sous le CLIorkeonet le démonorkeon-host. Un seul répertoire d'identifiants par run : quandOrkeon:Tools:Email:CredentialsDirectoryetOrkeon:Tools:Drive:CredentialsDirectorydiffèrent, celui de l'e-mail est utilisé. Pas dans cette version : la copie, les révisions, les commentaires, le retrait d'un partage, un drive d'essai pour la forge, un drive monté dans le VFS. - MCP — client/serveur dual-era : le client sonde avec
server/discoveret parle la révision moderne stateless (2026-07-28—_metapar requête, renégociation de version surUnsupportedProtocolVersionError) ou retombe sur le handshakeinitializelegacy (2025-11-25,2025-06-18,2024-11-05;2025-03-26est exclue à dessein — seule révision qui impose le batching JSON-RPC, que cette implémentation ne parle pas) ; le serveur sert les deux ères simultanément — sur stdio seulement, démarré parorkeon mcp serve(pas de transport HTTP pour le serveur), chaquetools/callpar le point d'invocation gardé des tours d'agent, les requêtes s'exécutant en concurrence jusqu'Ã--max-concurrency(4) et annulables parnotifications/cancelled, et/outputservi comme ressources en lecture seule sous--expose-output(niresources/subscribe, jamais/workspace), et des prompts seulement pour les tâches des crews que nomme--crew. Limites assumées de la surface moderne :subscriptions/listenen HTTP seulement (les notifications stdio sont entendues d'elles-mêmes ettools/list_changedresynchronise les outils enregistrés), des crews servies comme outils (orkeon mcp serve --crew:run_crew_<nom>, progression par tâche, tâches en prompts) enregistrées dans l'historique des runs quand il est actif, mais ni sampling, ni roots, ni elicitation (une requête du serveur pour l'un d'eux reçoit-32601: le sampling appellerait un LLM hors du budget, du gardien et du coût du run, les roots exposeraient des chemins physiques, l'elicitation attend le human-in-the-loop durable), pas de requêtes multi-aller-retour (un résultatinput_requiredremonte comme erreur d'outil), un client OAuth pour le serveur (client credentials, device flow :Auth:Typeoauth2-client-credentialsouoauth2-device) mais pas de flux authorization-code, pas de découverte de ressource protégée (RFC 9728) ni d'enregistrement dynamique de client (DCR), et le device flow est refusé dansorkeon-host(pas de terminal) — un serveur derrière un identifiant statique s'atteint parMCP:Servers:<id>:Auth(bearer ou basic, lu dans l'environnement) etHeaders; le transport HTTP est du Streamable HTTP (id de session, réinitialisation sur 404, réponses SSE lues événement par événement, fluxGETavecLast-Event-ID; le transport HTTP+SSE de 2024-11-05 à endpoint séparé n'est pas supporté). Côté client, le schéma d'un outil distant est gardé entier à toute profondeur (propriétés, éléments, bornes,anyOf/oneOf,additionalProperties, unallOfd'objets fusionné,$reflocaux résolus, la racine lue comme tout schéma) ; il perd encore, entre autres, unallOfdont un membre n'est pas un objet,not,if/then/else,patternProperties,uniqueItems,multipleOf,dependentRequired,additionalItems,title,minProperties/maxProperties,propertyNames,contains, un membre d'enumqui estnullou n'est pas un scalaire, la position des éléments d'un tuple (lus comme leurs alternatives), une ancre, une référence à un autre document et une référence coupée sur un cycle (n'importe quelle valeur JSON), ce qui se trouve à plus de 32 niveaux de profondeur, et à la racine unadditionalPropertiesautre quefalse(Intégration MCP liste ce qui est gardé) ; un outil dont l'inputSchemas'étend à plus de 4096 schémas, ou copie plus de 1 Mio de texte, chaque usage d'un$refcompté (une définition utilisée plusieurs fois compte à chaque fois), est écarté avec un avertissement écrit une fois par définition d'outil distincte ; untypeen tableau qui ne nomme que"null", ou l'absence detype, est lu comme une absence de type ("type": "null"restenull), un entier qu'aucun entier 64 bits ne contient est lu comme undouble, et un tableau dont les éléments ne sont pas connus — pas d'items, des éléments sans type unique — est montré avecitems: {}, n'importe quelle valeur JSON ;tools/list,prompts/listetresources/listsont lus entrée par entrée : un outil, un prompt ou une ressource illisible est écarté à lui seul avec un avertissement ; une réponsetools/listde la mauvaise forme (untoolsqui n'est ninullni un tableau, unnextCursorqui n'est pas une chaîne) fait encore échouer la liste, et donc la connexion, avec un message qui nomme le serveur, là où unprompts/listou unresources/listde la mauvaise forme donne ce qui a pu être lu. Côté serveur, un hôte C# qui désérialise lui-même un message et le remet ÃProcessRequestAsyncperd unidnull(le message est pris pour une notification et ne reçoit rien, là où la boucle stdio d'orkeon mcp serverépond-32600) et unjsonrpcabsent (il vaut"2.0"par défaut, le message est donc exécuté là où la boucle le refuse), et une réponse qu'il lui remet reçoit-32600là où la boucle l'ignore. L'interop contre le serveur de référence (server-everything) tourne chaque nuit, et à la main avec le MCP Inspector — Interop MCP. - LanceDB —
LanceDbMemoryProvidercible un serveur LanceDB Cloud/Enterprise distant (protocole Lance REST Namespace, payloads Arrow IPC) ; il n'y a pas de store local. Limites de l'API distante (détails dans Système de mémoire) :SearchAsyncexige un index FTS surcontent(créé automatiquement à la création de la table, sinon l'erreur serveur est propagée — jamais simulée localement) ;HybridSearchAsyncémet deux requêtes serveur (classements_distance/_scorecôté serveur) et fusionne localement les deux listes classées, comme les rerankers des SDK officiels ; l'API delete ne renvoyant pas de compteur,DeleteAsync/UpdateAsyncfont une requête d'existence préalable pour préserver leur contrat booléen ; la conversion score =1 − _distancen'est pertinente que pour la métriquecosine(défaut) - La détection du Guardian est heuristique — la phase d'entrée et l'assainisseur de résultats d'outil reconnaissent des formulations (
ignore previous instructions, jetons de gabarit de chat, …) : une attaque reformulée passe, et une invite honnête peut correspondre — sousSecurity:Prompt:Policy = Block(le défaut) sa tâche échoue alors avec le motif nommé (Warnla laisse passer avec un avertissement). Les résultats d'outil sont balisés comme données, jamais nettoyés. Seuls les hôtes qui composentAddOrkeonApplication()avecAddOrkeonInfrastructure()ont le Guardian ; unExecutionOrchestratorconstruit à la main tourne sans garde tant que sesGuardianetToolInvocationne sont pas posés. Voir Sécurité. - Modèles de décision : un juge par phase — TypeSafe, Liquid et Kev sont des fournisseurs
DecisionderrièreIDecisionModel, pas des 17ᵉ fournisseurs LLM : un agent ne peut pas en prendre un commellm. Le juge LLM du gardien (Orkeon:Guardian:Llm, coupé par défaut) juge l'entrée de l'agent et la sortie d'une tâche par l'uniqueIDecisionModel, sans profil propre, et ajoute un appel de modèle par phase, retarde le streaming d'une tâche jusqu'à ce que sa sortie soit jugée, juge un texte long en entier, par morceaux deMaxContentCharsqui se chevauchent d'un quart, sousFailMode: Closed(32 morceaux au plus, au-delà le texte est refusé), mais seulement la première et la dernière moitié deMaxContentCharssousOpen(le milieu n'est pas jugé), et ne couvre que les tâches de crew (la réponse d'unctx.llm.actscripté n'est pas jugée) ; une réponse au sein d'un appel se juge par une étape de réponse d'un profil de décision (Orkeon:Decision:Profiles). Les étapes de requête n'interrogent que le dernier message utilisateur, un rappel après la réponse n'a lieu qu'une fois par appel, et ni les étapes ni le rerankerdecisionne posentLongContext: un état long ou de nombreux passages peuvent dépasser le contexte par requête du fournisseur et échouer sur son erreur de limite, un 400max_tokens_exceeded(Modèles de décision). Les opérations supplémentaires de Kev (permuter, séparer, liste des modèles) ne sont pas câblées. Aucun coût n'est calculé pour une décision, seulement ses jetons d'usage. Les poids ouverts de d1 ne sont pas servis par Orkeon : Liquid s'atteint par son API hébergée. - La mémoire d'une crew garde tout, rappelle par vecteur sauf si la mémoire cognitive est activée, et ne dure que dans un magasin durable — avec
memory: true, une crew range le résultat de chaque tâche réussie et rappelle les plus proches avant chaque tâche (Système de mémoire). Ce qu'elle ne fait pas : il n'y a ni rétention ni remise à zéro — la mémoire croît d'une entrée par tâche réussie, run après run, etIMemoryService.ClearMemoryAsyncne vide que les entrées du run en cours ; avec In-Memory, elle vit en RAM le temps du processus, si bien qu'orkeon runne se souvient d'un processus à l'autre qu'avec un magasin durable (memoryProvider: sqlite, une base vectorielle, ou unMemory:Providerdurable) ; le rappel est une recherche vectorielle, sans extraction de faits par LLM ni score de récence ou d'importance (ceux de CrewAI) — sauf siOrkeon:CognitiveMemory:Enabledvauttrue, ce qui rappelle par score composite et analyse ce qui est rangé, au prix d'appels LLM (Système de mémoire) ;MinScore(0,6) est à l'échelle du modèle local anglais, où un texte français obtient un score élevé quoi qu'il dise, et une longue variable d'entrée qui partage le sujet d'un souvenir peut porter une tâche sans rapport au-dessus. - Le plan d'une crew est un conseil, fait sur le profil par défaut — avec
planning: true, un planificateur écrit un plan pas à pas pour chaque tâche avant la première, et chaque tâche lit son propre plan dans son prompt, dans les six modes ; le plan ne change ni l'ordre ni les agents (Types de processus). Ce qu'il ne fait pas : il planifie sur le fournisseur de planification de la crew (WithPlanningLlmen C#) ou sur le profil par défaut de l'hôte — une crew YAML ou.ork.tsne peut pas en nommer un autre ; il ne montre au planificateur ni la backstory des agents, ni leur connaissance, ni la mémoire de la crew, et coupe ce qu'il montre (PlanningDefaults) ; une réponse illisible deux fois laisse la crew sans plan — un avertissement, pas un échec ; et sur le fournisseur écho (pas de sectionLlm), il saute le plan, avec un avertissement. spawn_agent— l'hôte de scripts l'offre, le tool C# est enregistré par l'hôte — l'actd'un script se voit offrirspawn_agent(SpawnAgentScriptTool) : il exécute un agent nommé du crew comme enfant, sous les budgets de profondeur de délégation et de spawn de l'exécution du crew (voir Scripting). LeSpawnAgentToolC# (self-spawn sous budget du mode autonome, dansOrkeon.Infrastructure) est une autre classe et reste enregistré par l'hôte : aucune racine de composition livrée — niorkeon runni le REPL — ne le met dans le registre de tools, et un hôte C# qui veut le self-spawn l'enregistre explicitement avec unIAgentFactory. Voirdocs/fr/tools/inventory.mdetdocs/fr/orchestration/autonomous.md.- Les espaces de noms de mounts par exécution ne sont entrés que par
orkeon-hostet l'essai de la forge —IFileSystemScope/AsyncLocalFileSystemScope(Domain) donnent à un flux d'exécution son propreFileSystemRegistry, etFileSystemServiceconsulte cette surcharge ambiante à chaque opération : deux crews dans le même processus peuvent donc adresser chacun son/outputsur des dossiers physiques différents — le rejet des chemins virtuels en double est par instance, jamais global.orkeon-hostentre un namespace par crew hébergé, depuisOrkeon:Host:Crews:*:Mounts(CrewRunner), et l'essai de la forge en entre un fait des dossiers que sa session a confirmés (ForgeTrialScope). Tous les autres points d'entrée —orkeon run, le reste d'orkeon forge,orkeon rag,orkeon-repl— tournent sur le registre de boot, un jeu de mounts plat par processus dont les chemins virtuels doivent être globalement uniques : d'où le fait qu'ils réservent leurs racines contre les settings — le fichier et l'environnement — au lieu de les cloisonner, et que l'hôte renomme encore les crews auxquels il n'accorde aucun mount (/crews,/crews-1, …). Un hôte qui veut son propre namespace le compose avecScopedMountComposition.ForExecution: entrer dans un scope remplace le jeu de boot au lieu de fusionner avec lui, donc la composition reporte les mounts de boot et laisse ceux de l'exécution les masquer aux chemins qu'ils revendiquent — les abandonner emporte/llm-logset/sandboxavec le run, et emporte la racine depuis laquelle le runner charge le crew. Un dossier accordé à une crew est une entrée du démon, lisible où qu'il soit, sans--allow-external-mounts. Les dossiers de la forge sont des entrées aussi :forge resumeconstruit son hôte avec les dossiers confirmés montés et autorisés, et un run sur le point d'essayer l'équipe dans son propre processus refuse, Ãfolders.confirmed, un dossier d'entrée relié à un dossier réel que son validateur n'autorise pas (FORGE-FOLDERS-INVALID). Voir Conformité VFS. - Une approbation d'appel d'outil dans
orkeon-replse lit entre deux commandes, ou par unrunCrewen attente — la question d'un crew attend la boucle de lecture, qui ne lit que lorsqu'aucune commande ne tourne au premier plan, ou une commande qui attend dansrunCrew(synchrone), qui lit la réponse elle-même. Toute autre commande qui tient la boucle laisse la question attendre jusqu'à sa fin. Lectx.promptd'une commande qui lit pendant qu'une question attend prend la ligne de l'opérateur à sa place. Dans la console simple sur un terminal, une question écrite pendant l'édition d'une ligne décale l'ancre de l'éditeur, comme le fait déjà la ligne de fin d'un ticket. La pause de l'horloge du script pendant que le contrôle décide vaut pour tout le moteur : chaque agent du crew, chaque course qui partage le moteur d'un fichier de commandes. Le REPL enregistre directement son canal d'approbation (CompositeLineInterceptor), sans le décorateurSerializingToolApprovalChannelque reçoivent les autres hôtes : si deux appels de lecture d'un même tour (qui tournent en parallèle) demandent tous deux, leurs questions ne sont pas mises en file une à la fois. Unacten modeasksans contrôle de permission échoue fermé (l'appel est refusé). Pendant un rejeu (orkeon-repl --replay,/replay), la ligne suivante du fichier répond à une question dès qu'elle attend : une ligne écrite pour la commande suivante répond à une approbation que le rejeu n'attendait pas ; une ligne répond à une approbation, mais une réponse pour toute la session (s) règle en outre chaque approbation en file pour le même outil, et le fichier ne doit donc porter aucune ligne pour elles ; et une approbation qui attend encore quand le fichier se termine arrête le rejeu (replay ended with an approval waiting: <outil>, code de sortie1). Une instance d'arrière-plan lancée par un rappelcompleted()est imputée à la ligne du rejeu en cours quand elle démarre, pas à la ligne qui a lancé son parent. Une questionhuman_inputn'émet aucun signal : le rejeu la voit en un quart de seconde au plus, en regardant de nouveau. - Aucun hôte livré n'active un agent sur le bus de dispatch des commandes scriptées — un agent déclare des gestionnaires
.onCommand(...)et une commande.cmd.tsl'atteint parcommands.request/commands.post, mais rien ne relie les deux :orkeon-replne charge que des fichiers*.cmd.tset n'enregistre aucun agent, et le registraire qui le fait est interne. Tant qu'un hôte n'en enregistre pas,requestetpostlèventcommands: unknown agent '<name>'. Registered: (none).— voir Commandes CLI scriptées. - Un appel d'outil d'un agent de crew pour lequel la permission gate demande est refusé quand l'hôte n'a pas de canal d'approbation — la gate est consultée par
ToolInvocationPipelinepour les scripts comme pour les crews YAML (permissionMode:d'un agent, sinonOrkeon:Security:PermissionGate:DefaultMode) ; unaskva à l'IToolApprovalChannelde l'hôte, et sans lui (le bot Discord) l'appel est refusé et le modèle en lit la raison. AvecOrkeon:Checkpointing:Enabledla question est durable : le démon etorkeon runla persistent et arrêtent le run dessus (waiting_for_input, sortie 75) au lieu de refuser ; le bot Discord n'a toujours aucun chemin pour y répondre (une session de forge en pause n'est pas un run : elle reste à 0). - Le démon ne reprend pas de lui-même un run suspendu — un run dont la question d'entrée humaine a dépassé
Orkeon:HumanInput:HoldTimeout(ouPause: Suspend) finitwaiting_for_input;POST /runs/{id}/inputenregistre la réponse etorkeon run <crew> --resume <id>le reprend. Chaque question qu'une tâche parallèle pose est persistée sous son propre id ; le run s'arrête sur l'une d'elles (celle que montrent sa sortie etpending_input), les autres se répondent par leurrequest_id, et une question restée sans réponse est reposée à la reprise du run. Une question se rejoue au grain de la tâche : la tâche qui l'a posée repart de son début (ses appels d'outils sont refaits), et les décisions des managers Hierarchical et Autonomous ne sont pas checkpointées. - La réponse à une question d'entrée humaine est stockée en clair — la session de checkpoint garde les réponses (
SessionState.AnsweredInputs) telles qu'elles ont été données, parce que la tâche reprise en a besoin : un magasin sur disque (json,sqlite) ou Postgres les garde lisibles, comme il garde les sorties de tâche. Ce qui est imprimé ou relu d'une question - le prompt sur la ligne stderr d'orkeon runet dansGET /runs/{id}- passe par le masquage de l'historique de run (RedactingRunEventSink.Redact) ; le prompt stocké n'est pas masqué. Une réponse donnée sans id de question (--resume <id> --input "...", ou unPOST /runs/{id}/inputsansrequest_id) va à la question sur laquelle le run s'est arrêté ; quand plusieurs sont ouvertes et qu'aucune n'est celle de l'arrêt, elle est refusée (409 request_id_required). Une approbation d'outil stockée n'est réutilisée à la reprise que pour le même outil et les mêmes arguments : un autre appel est redemandé. - Le confinement de
shell_command: ce que tient chaque backend, et où c'est vérifié — le processus est confiné par défaut (Confinement du shell) : bubblewrap sous Linux, Seatbelt sous macOS, un AppContainer dans un Job Object sous Windows 10 et suivants ; dans un conteneur, ou avecMode = None, il tourne sur l'hôte sous l'utilisateur de l'hôte et le VFS ne vérifie que les chemins que nomme sa ligne de commande. Où c'est vérifié : les parties pures (les arguments debwrap, le profil Seatbelt, le plan d'ACL, les lignes de commande Windows, le protocole du shell, le choix d'Auto) sont des tests unitaires que chaque run de CI exécute sous Linux ; un vraibwrap, un vraisandbox-execet un vrai AppContainer ne tournent que dans les jobs nocturnes d'integration.yml(ubuntu-latest,macos-latest,windows-latest), qui échouent plutôt que de sauter leurs tests quand le backend ne peut confiner ; seul le job Linux ouvre l'issue de suivi du run nocturne, un job macOS ou Windows rouge ne se voit que sur le workflow. Ce que la vue ne porte pas : une surcharge de sous-chemin sur un chemin qui n'existe pas à l'ouverture de la session (un parent accessible en écriture laisse le processus le créer ; bubblewrap et AppContainer), un montage interne dont le dossier se trouve dans un montage exposé aux agents (atteignable par ce montage), et un programme hors des répertoires système (/opt, un dossier.dotnetounvmdu répertoire personnel sous Linux ;/opt/homebrewsous macOS ; tout ce qui est sous le profil utilisateur sous Windows) tant que son dossier n'est pas listé dansConfinement:ReadOnlyPaths. Une racine d'agent qui est un worktree git lié reçoit le répertoire commun du dépôt lié en lecture seule et, par-dessus, sesobjects,refs,logset le répertoire git propre au worktree en lecture-écriture : l'agent peut réécrire les refs de chaque branche et les objets partagés, mais ni leconfig, leshooks,info,modulesdu répertoire commun ni les répertoires git des autres worktrees, ni aucun arbre de travail hors de sa racine ; un dépôt sanslogs/ne peut enregistrer de reflog depuis l'agent ; une disposition qui échoue une vérification (commondirou lien retour qui ne nomme pas les répertoires attendus, un lien symbolique sur le chemin) ne lie rien ; git lancé sur l'hôte dans le worktree de l'agent se fie toujours à ce que l'agent y a écrit, et git lancé sur l'hôte n'importe où dans le dépôt suit un lien que l'agent a créé dansobjects,refsoulogs; un gitdir écrit en chemin virtuel ne fonctionne que sous bubblewrap (Seatbelt et AppContainer montrent les chemins physiques). Pas de réseau saufConfinement:AllowNetwork: un gestionnaire de paquets ougit fetchéchoue jusque-là . Un dépassement de délai ne rend aucune sortie partielle sous Linux et macOS (la session est tuée avant que la sortie de la commande soit relue ; Windows rend ce qui a été capturé), et il réinitialise la session : la commande suivante démarre dans une nouvelle, sans ce que la précédente avait laissé dans son/tmp. Windows : chaque session accorde ses montages par ACE et reprend l'accord à sa fin, et Windows propage une ACE héritable à chaque objet sous la racine du montage : une session coûte une écriture de descripteur de sécurité par fichier de ses montages, dans chaque sens (unnode_modulesde 100 000 fichiers fait 100 000 écritures à l'ouverture de la session et autant à sa fermeture) ; la DACL est lue, modifiée puis réécrite, ce qu'un autre processus qui modifie la même DACL au même moment peut défaire. Un sous-chemin masqué, ou en lecture seule dans un montage accessible en écriture, a sa DACL protégée le temps de la session et réécrite telle qu'elle était à la fin (le contrôle d'accès du conteneur ignore une ACE de refus) : une modification qu'un autre outil fait entre-temps à cette DACL est perdue. Les commandesdir,vol,attribetwhere /rde cmd interrogent la racine du lecteur, qu'une ACL standard n'ouvre pas à un AppContainer : elles répondent « Access is denied. » dans une session confinée. Un fichier de commandes (.bat,.cmd, doncnpm.cmd) est refusé dans une session AppContainer et ne tourne qu'avecMode = None, et un programme n'est cherché que sur lePATH. Après un crash de l'hôte : bubblewrap et le Job Object ne laissent aucun processus (le noyau tue l'arbre), mais les ACE qu'une session AppContainer a posées restent sur les montages jusqu'à ce que la première session de l'hôte suivant les reprenne (elles sont consignées sous%LOCALAPPDATA%\Orkeon\shell-sessions\) ; sous Seatbelt et hors confinement sous Linux et macOS, une sentinelle qui sonde chaque seconde tue l'arbre de processus de la session, auquel échappe un processus qui en est sorti (un double fork). Le runtime scripté termine la portée d'un agent sans l'attendre : la fermeture d'une session peut finir après le retour du corps de l'agent. Sous Linux, l'environnement de la session garde lePATHde l'hôte, avecHOMEetTMPDIRsur le/tmppropre à la vue ; la restriction AppArmor d'Ubuntu 24.04 sur les espaces de noms utilisateur fait échouerbwrapsauf si un profil lui accordeuserns. Le bus de session n'atteint une session confinée qu'avecOrkeon:Tools:Shell:Environment:SessionBus = true, qui permet à une commande de sortir du bac à sable (systemd-run --user) et de lire le trousseau ; un busunix:abstract=reste joignable sous bubblewrap avecAllowNetwork, puisqu'une socket abstraite suit l'espace de noms réseau partagé. Jobs d'arrière-plan : un run tient 16 jobs vivants au plus, un id de job ne vaut que dans le run qui l'a lancé, et la fin du run tue les jobs encore en cours. - Le périmètre de fichiers d'un agent juge des chemins virtuels (périmètre de fichiers d'un agent) : un lien symbolique dans une entrée qui pointe ailleurs dans le même mount est suivi par les outils du VFS (le validateur de chemins tient les liens aux mounts, pas au périmètre) ;
shell_commandsous bubblewrap ne lie que les entrées, le lien n'y mène donc nulle part. Un shell non confiné (Mode = None, ou dans un conteneur) ne tient le périmètre que pour les chemins que nomme sa ligne de commande et pour son répertoire de travail, comme il tient les mounts. Une entréerwndretientDelete, mais un déplacement peut encore en sortir un fichier : le VFS ne demande que Read et Write à la source d'un déplacement. Les surcharges de sous-chemin d'un mount se comparent toujours en tenant compte de la casse, et le périmètre ne replie ni les noms courts 8.3 de Windows ni les flux de données alternatifs NTFS. En mode hiérarchique, les workers que le manager assigne tournent comme des runs de premier niveau sous leurs propres périmètres : un périmètre déclaré sur l'agent manager ne les borne pas. Seuls les appels d'outil de l'agent sont tenus : ce que le framework lit ou écrit pour le run (mémoire, connaissances, fichiers de sortie) garde les droits des mounts. - Coupe du résultat par tool —
Orkeon:Tools:ResultLimits(Limits:<tool>,MaxParallelToolCalls, 4 par défaut) est lié parAddOrkeonInfrastructureet lu par les boucles d'agent C# viaExecutionOrchestrator.ToolLimits. L'actdes scripts le lit aussi, parScriptingHostPorts.ToolLimits, queorkeon run, les hôtes des runners (dontorkeon-host), les commandes de script du REPL et l'assistant de crew de la forge renseignent tous ; un hôte de scripts construit sans ce port coupe et parallélise avec les valeurs par défaut intégrées. La coupe par défaut du shell dans le pipeline est de 10000 caractères ; un résultat qu'un tool a déjà borné (ToolCallResponse.AlreadyBounded) n'est pas coupé une seconde fois. La boucle de repli texte (LegacyTextAgentLoop) et le chemin texte du dispatcher ne parallélisent pas. - Instances d'agent : une mémoire par nom d'agent — le store durable de
ctx.memory.agent(FileScriptAgentMemoryStore) vit sousOrkeon:Scripting:AgentMemory:RootDirectory(par défaut/workspace/.orkeon/agent-memory, voir la référence de configuration) ; la clé est le nom de l'agent, deux agents de même nom le partagent donc. Sansbudget(...),MaxSpawnedAgentscompte par exécution d'agent, pas par exécution de crew. - Le verrou d'ingestion RAG est interne au processus — les ingestions d'une même collection sont sérialisées par un
SemaphoreSlimpar collection du processus ; deux processus partageant un store persistant ne sont pas coordonnés (un verrou inter-processus demande le support du provider).Prunene retire que les sources du manifeste absentes des globs demandés ; une suppression en échec est notée dans les erreurs du rapport et garde son entrée de manifeste. Voir Pipeline RAG. - Markdown dans le RaggableTree — pas de validation de parse — Les éditions d'un fichier
.md(node_replace,node_insert,edit_batch,ensure_section,insert_under_heading,replace_mermaid) ne sont pas validées par un parse : Markdown n'a pas d'erreur de syntaxe à refuser. Sur un bloc de code non fermé de premier niveau,replace_mermaidremplace le corps jusqu'à la fin du fichier sans le fermer. - Réindexation incrémentale : bornes énoncées —
incremental_reindexre-parse les fichiers modifiés et corrige le store fichier par fichier ; les appels des fichiers inchangés et les liens Markdown vers un nom ajouté ou retiré par les fichiers modifiés sont re-liés sans relire les fichiers inchangés. Les chemins du jeu modifié n'appliquent pas.gitignore. Une arêtetestsvers un membre surchargé relie toutes les surcharges (le FQN est sans types). Voir RaggableTree. - Requêtes du flux de développement : bornes énoncées —
affected_teststireproject_dependsdes seuls csproj, réunitbase..HEADet les changements de l'arbre de travail (non suivis inclus), et répondallquand une requête de projet remplit sa page de 1000 lignes ou qu'une expansion est tronquée ; les symboles sous un module modifié sont lus sur trois niveaux.documents_oflit les sections d'un fichier par une requête plafonnée à 1000 sections par le store.access_costcompte comme une lecture une écriture derrièreConfigureAwait, commeaccess-cost.py. - Opérations d'intention — une grammaire fermée —
ensure_importne voit pas un commentaire//dans des accolades d'import multi-lignes (la liaison suivante est masquée), niimport React, { … }(défaut plus nommées). Les réécritures structurelles etedit_batchsont atomiques au mieux : les fichiers sont écrits un par un avec une sauvegarde ou l'original en mémoire, et restaurés en cas d'échec ; si la restauration échoue elle-même, le journal est conservé et uneAggregateExceptionest levée, et les fichiers déjà écrits restent modifiés jusqu'au rejeu du journal (dansstructural_rewrite,$$dans un motif reste deux dollars, un seul dans un correctif). - Les tâches de décision ne tournent que dans trois processus. Une tâche avec un bloc
decision:ou une conditionwhenest acceptée en Sequential, Parallel et Graph ; en Hierarchical, Consensual et Autonomous le chargement est refusé (DecisionTaskRules.Check), jamais ignoré, et un équipage construit en C# qui les atteint échoue avant sa première tâche. - Tâches de décision : ce que la seconde itération laisse de côté. Pas de nœud de décision avant ou après une tâche (une garde sur l'entrée ou la réponse finale d'une tâche), pas de sortie go-to, de boucle ni de journal des décisions ; ni réessai (une tâche de décision ne peut pas déclarer
retry:, et le graphe n'a pas de boucle de retry propre) ni repli quand une requête au modèle de décision échoue (la tâche échoue, le repli ne sert qu'à un circuit coupé) ; ni image ni questionboxdans un équipage (le portIDecisionModelaccepte les deux, fonctions « danger zone » opt-in de TypeSafe depuis Jev 1.13 et 1.14, mais la tâche de décision d'un équipage n'envoie que du texte) ; le rerankerdecisionenvoie ses passages en une requête, sans lots. - Le
retry:d'une tâche rejoue la tâche entière, et rien de plus. Tous les modes réessaient une tâche échouée (retry: {attempts, backoffMs, backoff}), appels d'outils déjà réussis compris : aucun mécanisme ne les déduplique, et une tâche dont les outils écrivent doit pouvoir tourner deux fois sans dommage. Les appels d'outils d'une tentative en échec, la mémoire écrite par des outils, le coût mesuré et les événements restent, et les callbacks de tâche partent une fois par tentative. Une annulation, un refus du gardien et un budget épuisé ne sont jamais réessayés ; un dépassement de temps et une chaîne de basculement épuisée le sont. Il n'y a ni planificateur ni file de messages : un retry est immédiat (ou après son backoff), dans le run. - La transcription du REPL n'affiche aucun détail de décision pour les tâches d'un crew. Le JSONL du run porte la raison du saut d'une tâche et les réponses d'une tâche de décision ; la transcription du REPL n'affiche ni raison de saut ni libellé de décision pour une tâche de crew.
- Le bloc YAML
graph:s'exécute sur le moteur Domain seulement. Ungraph:hors deprocess: graphest refusé au chargement, et un passage de relais entre agents n'est pas une arête de graphe. Le constructeur de crew d'un.ork.tsn'a pas de surfacegraph::process("graph")y exécute un nœud par tâche, et un graphe dessiné avecstateGraph(...)s'exécute surJsStateGraphquand le script appelle.run(). ChatOptionsComposerne traduit qu'une partie de laLlmConfigd'un agent. Il reprend le modèle, les champs d'échantillonnage et de pénalité, le plafond de sortie, la graine, les séquences d'arrêt,Thinking, le format de réponse et le cache ; des champs commeTimeoutSeconds,CustomParametersouSystemMessageposés sur laLlmConfigpropre d'un agent ne sont pas traduits dans les options de chat (la boucle de repli texte les honore).- Deux graphies de la même variable de clé d'API. Sous Linux et macOS, quand
ORKEON_Llm__ApiKeyetORKEON_LLM__APIKEYsont toutes deux posées avec des valeurs différentes, le run prend l'une ou l'autre, et le runtime n'arbitre pas entre elles. - Windows : un refus de connexion peut arriver lentement (non vérifié). La sonde du point d'accès LLM d'un run et celle d'
orkeon doctordonnent 2 s chacune et lisent une expiration comme « joignable ». Si la pile Windows réessaie le SYN après le reset, comme attendu, le refus d'unlocalhostinjoignable peut arriver après le délai, et l'échec rapide d'orkeon runne se déclenche pas. Pas encore constaté sous Windows. - La réflexion et l'effort sont jugés contre une table qui est un instantané. Chaque fournisseur juge
LlmConfig.Thinkingcontre la table par modèle (IModelCapabilityRegistry,ORKEXP005) : un effort qu'un modèle listé ne prend pas est abaissé, un interrupteur qu'il ne peut honorer est abandonné, chacun avec un avertissement, et un modèle non listé reçoit les options telles que demandées, avec un avertissement : rien n'a été vérifié. La table tient ce que les vendeurs documentaient et ce que la campagne des fournisseurs a mesuré ce jour-là : un modèle sorti ou modifié depuis répond par sa propre erreur tant queLlm:ModelCapabilities:<id>ne le déclare pas. Azure OpenAI se nomme par déploiement : ses déploiements ne sont pas listés tant qu'ils ne sont pas déclarés. Un identifiant de modèle contenant:(lellama3:8bd'Ollama) ne peut pas être une clé deLlm:ModelCapabilities, la configuration .NET n'ayant pas d'échappement pour:: écrivez son préfixe (llama3). Haiku 5.5 au-delà de 100K jetons de prompt facture davantage (0,50 / 2,50 $/M) ;ModelPricingRegistryne tarife que le palier jusqu'à 100K, si bien qu'un long prompt Haiku 5.5 est sous-estimé et qu'un budget peut être dépassé sans alerte. - Réflexion et effort : ce que la table laisse sans mesure. Le « on » d'Anthropic envoie
adaptiveà tout modèle Claude, Claude 4.5 et antérieurs compris, où aucune campagne ne l'a mesuré. L'entréeclaude-opus-4(lowÃhigh) couvre aussi Opus 4.6 et 4.7, et l'entréegpt-5(minimalÃhigh) GPT-5.1 à 5.5, sans mesure. Les identifiants Claude à points d'OpenRouter (anthropic/claude-opus-5.5) ne correspondent pas aux entrées à tirets (claude-opus-5-5) et retombent sur une entrée plus courte (claude-). Une entrée qui ne liste aucun effort (claude-,gemini-) les laisse sans vérification et ne donne pas l'avertissement « rien n'a été vérifié », puisque le modèle est connu.kimi-k3,kimi-k3.1-pro, DeepSeek et les modèlesqwen3.8n'ont pas d'entrée : ils prennent les niveaux du fournisseur, avec cet avertissement. Dans le dialecte OpenAI, « désactivé » et un effort demandés ensemble sont écrits tous les deux (thinking: {type: disabled}à côté dereasoning_effort), au vendeur de juger. Azure OpenAI garde les trois niveaux par défaut, sans mesure. La campagne des fournisseurs confronte la table à ce qu'elle mesure (orkeon llm probe, M15–M17 face à M18), mais seulement le jour où elle tourne : un vendeur qui change entre-temps les valeurs d'un modèle se manifeste par l'erreur propre à ce modèle, jusqu'à ce qu'une entrée ouLlm:ModelCapabilities:<id>suive. context N%dans la console à deux volets lit un appel face à un réglage. Il suit le dernier appel au modèle du tour du prompt : une tâche lancée dans ce tour montre donc son propre chiffre jusqu'au prochain appel de la commande principale. Il est absent pour un crew lancé de façon synchrone parrunCrew, dont aucune instance de commande ne reçoit les appels, et sa fenêtre vient du seulOrkeon:Cli:Session:ContextWindowTokens(200000sans ce réglage) : il ne suit pas/model.- Les palettes de la console sont nommées, pas détectées. La palette ne vient jamais du terminal,
ctx.setThemevaut pour la session, et un sélecteur ne peut pas en prévisualiser une en direct : rien ne rappelle un script depuis le fil d'interface. ?seul ne peut pas commencer un message sur un prompt vide de la console à deux volets. Il y liste les touches ; pendant qu'unctx.promptde script lit, c'est du texte.- Le prompt rappelé sur un transcript remonté cache la ligne sous lui. Remonter d'une ligne de plus la montre.
- Les deltas d'appels d'outils s'arrêtent aux sinks qui les lisent. Les deltas de raisonnement ne sont pas transmis Ã
ILlmDeltaSink, et le providermockn'émet aucun delta d'appel d'outil. - Le flux dans la console à deux volets. Il est actif dans la REPL et désactivé pour un crew exécuté sauf si
Orkeon:Cli:ConsoleStreaming:Enableddit autre chose, et un texte intermédiaire de l'assistant ne s'affiche pas dans un crew qui ne diffuse pas. Les lignes d'un tableau restent cachées jusqu'à la fin du tableau, et une clôture de bloc de code ajoute une ligne vide. - Les diffs et le code de la console à deux volets n'ont pas de coloration syntaxique, qui demanderait un paquet.
- La sortie d'une commande qui passe à la ligne repart en colonne 0. Les lignes suivantes d'une ligne simple coupée ne s'alignent pas sous le coude.
- Les prompts d'un script dans la console à deux volets. Un
ctx.promptque le script n'attend pas laisse une lecture ouverte, et la lecture suivante de la boucle peut échouer avecA ReadLineAsync is already in progress. Une ligne tapée au prompt pour une approbation, mise en tampon puis retirée avec sa question, peut atteindre la boucle comme une ligne à part entière (rare). - L'historique d'un run hébergé est partiel.
orkeon-hostenregistrerun.started, les événements de tâche,erroretrun.finishedde chaque run (Orkeon:RunHistory, actif par défaut) ; les événementstool.*,llm.call.*etcost.updatedne sont pas publiés pour un run hébergé, car les observateurs d'outils, d'usage et d'appels sont des services du processus et qu'un démon mène plusieurs équipages à la fois : ils restent surorkeon run --events. L'historique d'un run ne garde aucunllm.deltasansIncludeDeltas. Un run dont l'hôte ne peut pas être construit (un réglage refusé, un équipage illisible) ne laisse aucun historique, pas plus que--resume latest, dont le runner ne nomme le run qu'après avoir regardé dans le magasin. Les événements qu'un run écrit avant que l'historique puisse le rejoindre (run.startedet ce que la construction de l'hôte émet) sont gardés dans un tampon de 128 ; au-delà ils restent sur le flux et ne sont pas dans l'historique (un avertissement dit combien). Un run tué avantrun.finishedn'estorphanedque pour un lecteur du même hôte : sur un autre hôte (un dossier partagé) il resterunning, etMaxRunset la purge continuent de le compter comme en cours. Plusieurs processus peuvent écrire un même dossier d'historique : le magasin Sqlite est en mode WAL avec un délai d'occupation, le magasin JSONL ajoute à son index sans jamais le réécrire ; un run repris sous son propre id (--resume <id>) poursuit la séquence que l'historique tient pour lui, son secondrun.startedporteresumed: true, de sorte que ce queorkeon runs showécrit n'est le flux d'aucun des deux processus ligne pour ligne. L'identifiant du run côté démon est l'ExecutionIddu run, la clé de son historique ;hostRunIddansrun.startedle répète. firefox— bornes énoncées (voir le guide). La politique d'URL vérifie les pages que l'onglet affiche, avant que le navigateur démarre et après chaque action qui peut naviguer ; les sous-ressources qu'une page charge (images, scripts, cadres, XHR) sont récupérées par Firefox lui-même et ne sont pas vérifiées — gardez le navigateur sur un réseau isolé quand la politique compte. Le texte d'une page n'est pas filtré contre l'injection de consignes.searchenvoie le texte des sections de la page au fournisseur d'embeddings, en une collection éphémère par page visitée (préfixefirefox), jamais supprimée : le sous-système RAG n'a pas d'API pour retirer une collection. Le texte detypeest un argument d'outil que le modèle écrit et que la transcription garde : jamais un secret. Un seul onglet est piloté à la fois — un lien qui ouvre un onglet y déplace la session, et l'onglet quitté n'est relu qu'aprèsswitch_tab; les onglets que l'utilisateur ou un autre agent a ouverts dans un navigateur partagé ne sont jamais vus. Un profil nommé est utilisé tel quel : les onglets que Firefox restaure au démarrage sont ceux de l'utilisateur, pas de l'agent, et ce que le profil contient (cookies, sessions, extensions) n'est ni filtré ni supprimé — un agent sur le profil de l'opérateur agit en son nom. La vérification du verrou avant le démarrage ne reconnaît qu'un profil tenu par un Firefox de cette machine ; un profil ouvert sur une autre machine par un dossier partagé n'est pas vu, et Firefox le refuse au démarrage.screenshotécrit un PNG à un chemin virtuel et ne rend rien d'autre : le modèle ne voit pas l'image. Une page restaurée depuis le cache d'historique (back) est reconnue à son adresse :backentre deux entrées d'historique de même adresse attend le délai de commande (CommandTimeoutSeconds, 30 s) avant que la page soit lue. Vérifié sur Firefox 159 sous Linux ; les chemins de lancement Windows et macOS sont écrits, pas campagnés.orkeon evalnote ce que la suite sait noter.eval run --crewdonne à la crew un prompt par cas (task_description, en contexte initial et en{input}) et ne note que sa sortie finale : les sorties intermédiaires des tâches et les événements du run ne sont pas dans le rapport.eval benchnote des sorties enregistrées et n'accepte pas--crew; ses runs répétés ne diffèrent qu'avec les juges LLM.--offlineavec--crewrefuse une crew dont un agent (ou le manager) répondrait par un fournisseur autre que le mock - son profil propre, son fournisseur propre ou le défaut de l'hôte - et nomme l'agent et le profil ; il ne regarde pas les outils qui atteignent seuls le réseau.- Modèles
dotnet new: trois points de départ, pas plus —Orkeon.Templateslivreorkeon-host,orkeon-pluginetorkeon-tool. Le modèle d'hôte exécute uncrew.ork.tsparICrewScriptRunner(il demande doncesbuildsur la machine, et tireOrkeon.Toolset les embeddings locaux parOrkeon.Scripting) ; il a la forme du démonorkeon-host(hôte générique,appsettings.json) mais n'est pas le démon : ni registre de crews, ni passerelle de chat, ni canaux. Le modèle de plugin référenceOrkeonà la compilation seulement (ExcludeAssets="runtime") et part du manifeste du plugin d'exemple ; un plugin se charge depuis un dossier, rien ne le publie. Chaque projet généré fige les paquets Orkeon à la version du paquet de modèles qui l'a produit : un modèle installé depuis un paquet plus ancien génère un projet de cette ligne. Le rechargement à chaud et une extension d'IDE n'en font pas partie. - Le gate de permissions décide après les crochets d'outil d'un script. Le rappel
onToolCalld'un script s'exécute avant le gate, qui juge l'entrée qu'il renvoie (une consultation par appel, dans l'invocation avec le pipeline d'invocation des outils) : un appel que le gate refuse a quand même exécuté le rappel. Le budget d'outils n'est débité qu'une fois l'appel admis par le gardien et le gate. - Une lecture bornée d'un historique de runs JSONL lit tout le fichier.
IRunHistoryReader.ReadEventsAsync(runId, fromSeq, limit, ct)applique la limite en SQL dans le magasin Sqlite ; le magasin JSONL lit le fichier du run et s'arrête après la limite. - La permission gate est désactivée tant qu'un hôte ne l'active pas.
Orkeon:Security:PermissionGate:Enabledvautfalsepar défaut : aucun appel d'outil d'un script ou d'une crew YAML n'est filtré, et lepermissionMode:d'un agent n'est lu par rien tant que la gate n'est pas activée (configuration). Ce qui borne encore un outil sans elle, ce sont les droits VFS des mounts, le Guardian et le confinement propre de l'outil (shell_command). - Le bloc
budget:d'une crew ne plafonne que le mode autonomous. Sestokens,wallTimeSeconds,toolCalls,delegationDepthetspawnedAgentssont lus parprocess: autonomous; une crew qui le déclare sur un autre mode est refusée au chargement. Le plafond que tous les modes respectent estOrkeon:CostTracking:DefaultCrewBudgetde l'hôte (MaxTokens,MaxCostUsd), cumulé par identifiant de crew — par exécution pour une crew YAML ou C#, qui prend un nouvel identifiant à chaque chargement, tandis que les appelsctx.llmpropres à un script se cumulent sous le nom de la crew pendant toute la vie du processus, à part de ses tâches orchestrées : l'appel qui le franchit va à son terme, le suivant est refusé avecBudgetExhaustedException(configuration). Security:Audit:RetentionDaysn'est lu par aucun purgeur. La clé est déclarée (90 par défaut) mais rien ne supprime les anciens événements d'audit : le sink en mémoire vit autant que le processus, et les fichiers qu'unJsonFileAuditSinkécrit sousAuditDirectoryrestent jusqu'à ce que l'hôte les supprime.- Trois chemins chargent une crew sans le contrôle des livrables. Le contrôle qui avertit, au chargement, d'un livrable
tool_callqu'aucun agent ne peut écrire (livrables vérifiés au chargement) s'exécute dansCrewFactory: une crew construite en C# avecCrewBuildern'est pas contrôlée (l'hôte appelleDeliverableToolCheck.Checklui-même), un.ork.tsprocédural sous--validateest bundlé, jamais chargé comme une crew, et un agent dont le modèle exécute ses propres outils (un agent Microsoft Agent Framework) compte comme capable d'écrire. Sur ces chemins, le run signale de toute façon un fichier qui n'a pas été écrit (deliverableMissing). - Les drapeaux de plafond d'itérations et de livrable manquant sont best-effort. Seule la boucle d'agent principale (
ChatClientAgentLoop) prend le tour sans outils après le plafond d'itérations et poseendedOnIterationCap: les deux boucles de repli, celle du tool calling natif et celle du texte legacy, finissent sur le plafond sans la note et sans le drapeau. Un canal servi par le handler de commandes d'agent d'un script (AgentCommandRegistrar) répondfalseaux deux drapeaux.deliverableMissingvient d'une sonde du système de fichiers virtuel après la tâche : sans système de fichiers, ou quand la sonde échoue, le drapeau restefalse.