Harnais d’outils déterministe pour MatchTIR: Schémas JSON, contrôleurs LangGraph et télémétrie reproductible

Quand les systèmes d’IA utilisant des outils trébuchent, le coupable n’est souvent pas le raisonnement du modèle mais la plomberie autour de celui-ci: routage d’outils, orchestration, et invites. Pour MatchTIR, attribuer les succès et échecs au bon composant nécessite un harnais qui normalise les interfaces, isole les contrôleurs, et mesure tout ce qui compte. Cet article présente une pile d’évaluation concrète et déterministe qui expose le véritable profil de performance de MatchTIR sans biais confondants. Vous apprendrez comment les interfaces d’outils basées sur le schéma JSON s’alignent avec les API d’appel de fonctions traditionnelles; comment les contrôleurs LangGraph interchangeables séparent l’orchestration de la capacité du modèle; comment les environnements fixés, les cassettes de relecture, et la provenance rendent les exécutions répétables; et comment une télémétrie exhaustive permet d’obtenir une rigueur statistique et une analyse des erreurs actionnables.

Détails d’architecture/implémentation

Normalisation des interfaces via des schémas JSON

La normalisation des interfaces est au cœur du harnais. Tous les outils—calculatrices, exécution Python, récupérateurs, navigateurs, moteurs SQL et API externes—sont exposés à travers des signatures de fonctions de schéma JSON alignées aux conventions d’utilisation d’outils de OpenAI et Anthropic. Cette standardisation minimise le biais induit par le schéma, permet une validation stricte des arguments, et rend mesurable la précision et le rappel par outil par rapport aux bases de référence de l’appel de fonctions supervisé comme ToolBench et Gorilla OpenFunctions.

Le journal des appels d’outils capture à la fois les résultats syntaxiques et sémantiques pour chaque action: quel outil le modèle a sélectionné, si les arguments correspondaient au schéma, si l’appel a été exécuté avec succès et comment le score de la tâche en aval a changé. Ce journal permet de calculer la précision/le rappel des appels d’outils, la correction des arguments, et les taux d’appels invalides et de réessais, qui, selon la littérature, sont décisifs pour le succès de bout en bout.

Contrôleurs interchangeables sous forme de graphiques et de chaînes

Les contrôleurs sont représentés dans deux abstractions équivalentes:

Orchestrateurs basés sur des graphes (LangGraph) pour une planification découplée, un raisonnement-acte entrelacé et une séparation planificateur-exécuteur.
Chaînes linéaires (LangChain) pour répliquer des bases de référence canoniques sous des menus et des budgets identiques.

Dans ce schéma, la même tâche peut être exécutée par un entrelacement de type ReAct, une stratégie de planification d’abord dans l’esprit de ReWOO, une recherche délibérée à branches multiples semblable à Tree-of-Thought, ou un contrôleur qui intègre l’auto-réflexion pour réparer les erreurs sur de plus longs horizons —le tout sans modifier les descriptions des outils ou la température de décodage. Lorsque MatchTIR s’implémente, toute amélioration mesurée par rapport à ces contrôleurs canoniques reflète sa logique d’orchestration plutôt que les différences d’interface biaisées.

Déterminisme, isolation et relecture

La répétabilité est non négociable. Le harnais impose le déterminisme et l’isolation en:

Exécutant Python et SQL dans des images Docker fixées avec des graines et des quotas de ressources.
Évaluant les tâches de navigation dans des arènes standardisées (WebArena, BrowserGym) avec des exécutions statiques mises en cache pour une relecture exacte et des variantes en direct étiquetées pour quantifier la variance en conditions réelles.
Fixant les pipelines de recherche (corpus et implémentations d’index) et exigeant des récupérateurs qu’ils exposent la provenance, afin que le harnais puisse évaluer l’enracinement au lieu de seulement la précision de la forme de surface à l’aide de diagnostics BEIR et RAGAS.
Utilisant des cassettes de relecture de style VCR par défaut pour les API externes afin de capturer les charges utiles de requêtes/réponses et le comportement de limitation du débit.
Approvisionnant des conteneurs Postgres/MySQL versionnés pour Spider et BIRD avec des frontières de privilèges strictes et des journaux de requêtes audités.

Télémétrie et rigueur statistique

La couche de télémétrie est exhaustive par conception: chaque tour journalise les invites (système et utilisateur), les schémas d’outils exposés au modèle, le graphe d’appel d’outil, les arguments et réponses, les décisions du contrôleur, les comptes de jetons (répartis entre la réflexion et les charges utiles d’outils) et la décomposition de la latence en temps de réflexion et temps d’outil. En répétant les exécutions à travers les graines, le harnais prend en charge des tests de signification appariés pour les résultats des tâches et des analyses de style Wilcoxon pour la latence et le coût. Tous les résultats suivent les divulgations de style HELM pour les configurations et les traces afin de soutenir la réplication externe.

Couverture des benchmarks pour exposer différents modes d’échec

Pour stresser significativement la pile, le harnais couvre:

Raisonnement programmatique: calculatrice + Python sandboxé; compare le raisonnement aidé par programme (PAL) et le branchement délibéré (ToT) pour exposer les compromis entre précision et latence.
Ingénierie logicielle: SWE-bench sous des piles de développeurs reproductibles (éditeur, shell, tests) et lignes de base d’agent comme OpenDevin/OpenHands pour capturer les effets d’orchestration, où la fidélité de l’environnement domine souvent.
Navigation: WebArena et BrowserGym pour la navigation et le remplissage de formulaires avec des métriques standardisées; les pages adversariales exposent la fragilité de l’injection d’invites.
Text-to-SQL: Spider et BIRD avec des instantanés de bases de données versionnés et des mesures de précision d’exécution versus d’appariement exact pour sonder l’exposition des schémas et les limites de sécurité.
QA multi-hop et planification: HotpotQA et MuSiQue pour un raisonnement compositionnel avec RAG; AgentBench et GAIA pour une planification plus large avec des API standardisées.

Tableaux de comparaison

Paradigmes de contrôleur sous des menus d’outils et des budgets identiques

Contrôleur	Idée centrale	Forces (preuves)	Effet coût/latence	Où il excelle
ReAct	Entrelacer raisonnement et action	Fort défaut dans des environnements interactifs	Nombre potentiellement plus élevé d’appels d’outils	Navigation, outils multi-étapes
ReWOO/planification d’abord	Découpler la planification de l’observation	Réduit les appels inutiles tout en préservant la précision	Coût inférieur à précision similaire	Tâches avec outils coûteux
Tree-of-Thought	Branchement/recherche délibéré	Précision plus élevée en maths/codage	Augmentation des jetons et latence p95	Raisonnement difficile, code
Réflexion	Auto-réparation itérative	Améliore le succès à long horizon avec un surcoût modéré	Tours et jetons supplémentaires	Agents multi-tours

Les métriques comparatives spécifiques dépendent de la tâche et de la configuration; le harnais rapporte des métriques de succès officielles par domaine avec des intervalles de confiance (métriques spécifiques non disponibles) [11–15][19–21][23–26].

Composants du harnais, leviers de déterminisme et métriques exposées

Composant	Levier de déterminisme/isolation	Principales métriques exposées
Interfaces d’outils	Schéma JSON aligné sur OpenAI/Anthropic	Précision/rappel des appels d’outils, correction des arguments, taux invalide/redémarrage
Contrôleurs	Graphes LangGraph et chaînes LangChain	Nombre/profondeur d’appels, coût, delta de succès par rapport aux bases de référence
Python/SQL	Docker épinglé, graines, quotas	Succès d’exécution, ventilation de la latence
Navigation	WebArena/BrowserGym, cache statique + étiquettes en direct	Succès/récompense, variance par rapport au direct
RAG	Corpus/indexes épinglés; provenance; BEIR/RAGAS	Enracinement, fidélité
API externes	Cassettes VCR/replay	Résultats des injections de failles, réessais
Reporting	Configurations de style HELM, CIs multi-graines	Tests appariés, latence p50/p90/p99

Meilleures pratiques

Normalisez tôt, validez toujours. Utilisez le schéma JSON pour chaque outil avec une validation d’argument appliquée au moment de l’appel. Alignez-vous sur l’appel de fonction OpenAI/Anthropic pour réduire la dérive du schéma et rendre votre système portable entre modèles et fournisseurs. Les ensembles de données d’appel de fonctions supervisées (ToolBench/Gorilla) sont de fortes références pour la précision/le rappel et la réduction des appels invalides.
Découplez l’orchestration de la capacité. Implémentez des contrôleurs sous forme de graphes interchangeables (LangGraph) et de chaînes (LangChain) afin que le routage et la planification puissent être analysés indépendamment du modèle sous-jacent. Maintenez les menus d’outils et budgets constants à travers les bras pour attribuer les améliorations à l’orchestration plutôt qu’à l’exposition.
Faites du déterminisme une fonctionnalité, pas un espoir. Épinglez les images Docker, graines, corpus, et bases de données; préférez les replays de style VCR pour les API; et divisez la navigation en caches statiques et exécutions en direct étiquetées pour comptabiliser la variance.
Mesurez l’enracinement, pas seulement la précision. Dans RAG et QA multi-hop, enregistrez la provenance des preuves et utilisez BEIR et RAGAS pour évaluer si les réponses sont fondées, et non seulement correctes en forme de surface.
Instrumentez pour la science. Capturez les invites, schémas, graphes d’appel d’outils, jetons (raisonnement vs charge utile d’outil), et décomposition de la latence; adoptez la divulgation de configuration de style HELM et les tests appariés multi-graines pour garantir que les conclusions sont statistiquement défendables.
Stressez pour la robustesse et la sécurité. Injectez des pannes, des pics de latence, et des charges utiles mal formées; servez des pages adversariales aux agents; et catégorisez les incidents sous OWASP LLM Top 10 pour quantifier les comportements de risque et de récupération.
Testez la généralisation à travers les familles de modèles. Exécutez des réglages de décodage appariés et des plafonds de budget à travers les API d’outils de classe GPT-4, l’utilisation d’outils Claude, Llama 3.1, et les modèles de la famille DeepSeek pour révéler les différences de portabilité et d’efficacité d’échantillon (métriques spécifiques non disponibles).

💡 Traitez le coût par succès et l’efficacité d’échantillon comme des objectifs de première classe, pas des pensées après coup; de nombreux choix de contrôleurs échangent la précision contre la latence et les jetons.

Exemples pratiques

Bien que les détails d’implémentation spécifiques de MatchTIR ne soient pas disponibles publiquement (métriques spécifiques non disponibles), le harnais supporte les modèles d’évaluation concrets suivants tirés de la littérature et des benchmarks cités dans le rapport:

Compromis de raisonnement programmatique. Sur des tâches nécessitant un raisonnement arithmétique ou symbolique, exposez à la fois une calculatrice et un outil Python sandboxé. Comparez une approche PAL de raisonnement aidée par le programme contre un paramétrage à branches multiples délibéré inspiré par Tree-of-Thought pour quantifier combien d’augmentation de précision est achetée au coût de jetons supplémentaires et de latence p95. Parce que les interfaces sont normalisées et les arguments validés, le harnais peut attribuer les échecs à une mauvaise sélection (calculatrice vs. Python), des erreurs d’arguments (désaccords de schéma), ou des impasses de contrôleur.
SWE-bench avec des piles de développeurs reproductibles. Utilisez des conteneurs épinglés et des référentiels versionnés pour garantir la fidélité de l’environnement. Évaluez MatchTIR aux côtés des lignes de base des agents logiciels (OpenDevin, OpenHands) sous des outils d’éditeur/shell/test identiques. Le harnais journalise si les correctifs se compilent, les tests réussissent, et comment les choix de contrôleurs affectent la profondeur des appels d’outils et les réessais, un cadre où l’orchestration et la discipline des outils dominent souvent la qualité brute du modèle.
Navigation dans des arènes statiques et en direct. Exécutez WebArena et BrowserGym avec des pages statiques mises en cache pour une relecture exacte ainsi que des variantes en direct étiquetées pour quantifier la variance. Injectez des pages adversariales pour mesurer la sensibilité à l’injection d’invites, la récupération, et l’adhésion aux politiques; catégorisez les incidents sous OWASP LLM Top 10. Le graphe d’appel d’outil et la ventilation de la latence séparent le “temps de réflexion” du “temps d’outil”, permettant des ablations de contrôleur ciblées (par exemple, planification d’abord vs. entrelacé).
Text-to-SQL sous des limites de privilèges. Évaluez Spider et BIRD par rapport à des instantanés Postgres/MySQL versionnés avec des privilèges stricts et des journaux de requêtes audités. Mesurez à la fois la précision d’appariement exact et d’exécution; utilisez des ablations de contrôleurs pour tester si les stratégies de planification d’abord réduisent les appels excessifs (par exemple, sonde de schéma inutile) sans nuire à la précision. Les traces rejouables permettent aux examinateurs de classer les échecs en tant qu’erreurs d’arguments, mauvaise sélection de table, ou utilisation dangereuse d’outils.
QA multi-hop avec vérifications d’enracinement. Couplez HotpotQA et MuSiQue avec des outils RAG qui journalisent les preuves classées et la provenance. Évaluez la fidélité des réponses avec BEIR/RAGAS et comparez les contrôleurs ReAct vs. planification d’abord vs. branchement délibéré pour voir si un contrôleur qui sélectionne bien les outils produit également des réponses enracinées. La précision/le rappel par outil du harnais révèle si un sélecteur conscient des schémas améliore la qualité de récupération et réduit l’utilisation d’outils hallucinée.

Conclusion

Un harnais déterministe, interchangeable et entièrement instrumenté transforme l’évaluation de MatchTIR en une affaire de preuves, pas de récit. En normalisant les interfaces d’outils avec des schémas JSON, en représentant les contrôleurs sous forme de graphes LangGraph et de chaînes LangChain, en appliquant le déterminisme à travers des environnements épinglés et des replays, et en journalisant une télémétrie exhaustive avec la rigueur de style HELM, les examinateurs peuvent sans ambiguïté attribuer les gains au sélecteur d’outils, au contrôleur ou à la politique d’invite. Le résultat: des exécutions comparables à travers les graines, les modèles, et les examinateurs qui exposent les véritables compromis coût-précision et les profils de sécurité.

Points clés:

La normalisation des interfaces élimine le biais induit par le schéma et permet de mesurer la précision/le rappel des appels d’outils.
Les contrôleurs interchangeables isolent les effets d’orchestration sous des menus d’outils et budgets identiques.
Le déterminisme (conteneurs épinglés, caches, cassettes) est essentiel pour des résultats reproductibles et une analyse robuste des erreurs.
La télémétrie associée aux rapports de style HELM supporte les tests appariés et des conclusions reproductibles.
La robustesse et la sécurité nécessitent des tests de stress systématiques et une taxonomie d’incidents alignée sur OWASP.

Prochaines étapes pour les praticiens: implémentez des registres d’outils de schéma JSON alignés sur les conventions d’OpenAI/Anthropic; refactorisez les contrôleurs en graphes LangGraph et chaînes LangChain; épinglez vos environnements et ajoutez VCR pour les API; intégrez BEIR/RAGAS pour l’enracinement; et publiez des configurations et des traces de style HELM. Bien fait, vous verrez exactement où MatchTIR aide—et où il a besoin de travail—à travers les domaines et les familles de modèles. 🚀

Sources

ReAct: Synergizing Reasoning and Acting in Language Models — https://arxiv.org/abs/2210.03629 — Pertinence: Établit la référence de base de raisonner-agir entrelacée utilisée comme contrôleur canonique.
ReWOO: Decoupling Reasoning from Observations — https://arxiv.org/abs/2305.18323 — Pertinence: Soutient l’orchestration de type planification d’abord pour réduire les appels d’outils inutiles.
PAL: Program-aided Language Models — https://arxiv.org/abs/2211.10435 — Pertinence: Montre le raisonnement assisté par programme avec exécution de code dans des tâches de maths/codage.
Tree of Thoughts: Deliberate Problem Solving with Large Language Models — https://arxiv.org/abs/2305.10601 — Pertinence: Motive le raisonnement à branches multiples délibéré et ses compromis de coût/latence.
Reflexion: Language Agents with Verbal Reinforcement Learning — https://arxiv.org/abs/2303.11366 — Pertinence: Fournit des preuves pour l’auto-réparation itérative dans des tâches à long horizon.
ToolBench (OpenBMB) — https://github.com/OpenBMB/ToolBench — Pertinence: Fournit des bases de référence d’appel de fonctions supervisé pour mesurer la précision/le rappel des appels d’outils et les taux d’appels invalides.
Gorilla: Large Language Model Connected with Massive APIs — https://arxiv.org/abs/2305.15334 — Pertinence: Montre comment les schémas d’API de haute qualité améliorent la correction des arguments et réduisent les appels invalides.
Gorilla OpenFunctions (GitHub) — https://github.com/ShishirPatil/gorilla — Pertinence: Fournit des signatures de fonctions standardisées pour évaluer la qualité des appels d’outils.
AgentBench (arXiv) — https://arxiv.org/abs/2308.03688 — Pertinence: Bancs d’essai pour tâches multi-API et de planification pertinentes à la robustesse des contrôleurs.
AgentBench (GitHub) — https://github.com/THUDM/AgentBench — Pertinence: Offre l’implémentation pour des API et des récompenses d’agents standardisées.
WebArena (arXiv) — https://arxiv.org/abs/2307.13854 — Pertinence: Environnement de navigateur standardisé pour mesurer la navigation/le remplissage de formulaires.
Site Web WebArena — https://webarena.dev — Pertinence: Ressource officielle pour les environnements et métriques.
BrowserGym (arXiv) — https://arxiv.org/abs/2401.07317 — Pertinence: Fournit une arène de navigation contrôlée et des métriques; supporte les exécutions statiques vs. en direct.
SWE-bench (arXiv) — https://arxiv.org/abs/2310.06770 — Pertinence: Référence de correction de bugs en conditions réelles où l’orchestration et la fidélité de l’environnement comptent.
Site Web/Classement SWE-bench — https://www.swe-bench.com — Pertinence: Mètres et protocoles de reproductibilité officiels.
OpenDevin (arXiv) — https://arxiv.org/abs/2407.12894 — Pertinence: Pile de base d’agent logiciel pour comparer des stratégies d’orchestration sur SWE-bench.
OpenHands (arXiv) — https://arxiv.org/abs/2407.01489 — Pertinence: Pile d’agents alternative mettant l’accent sur les comparaisons d’outils de développement réalistes.
DS-1000 (arXiv) — https://arxiv.org/abs/2306.17565 — Pertinence: Sonde l’utilisation d’outils de science des données en Python, soulignant le déterminisme du bac à sable.
Spider (arXiv) — https://arxiv.org/abs/1809.08887 — Pertinence: Généralisation de Text-to-SQL avec précision d’exécution et métriques d’appariement exact.
BIRD (arXiv) — https://arxiv.org/abs/2305.03111 — Pertinence: Référence text-to-SQL à grande échelle soulignant ancrage réaliste des bases de données.
Classement BIRD — https://bird-bench.github.io/leaderboard — Pertinence: Protocole d’évaluation officiel et métriques pour la précision d’exécution.
GAIA (arXiv) — https://arxiv.org/abs/2311.12983 — Pertinence: Reference de planification/agent pour tester l’orchestration sous diverses APIs.
HotpotQA (arXiv) — https://arxiv.org/abs/1809.09600 — Pertinence: Ensemble de données QA multi-hop pour le raisonnement compositionnel + évaluation RAG.
MuSiQue (arXiv) — https://arxiv.org/abs/2202.06643 — Pertinence: Accentue la composition dans QA multi-étape.
BEIR (arXiv) — https://arxiv.org/abs/2104.08663 — Pertinence: Évaluation de la récupération standardisée pour évaluer la qualité des preuves.
RAGAS (GitHub) — https://github.com/explodinggradients/ragas — Pertinence: Métriques de fidélité pour l’enracinement RAG.
HELM (arXiv) — https://arxiv.org/abs/2211.09110 — Pertinence: Recommande des configurations transparentes, exécutions multi-graines, et rapports rigoureux.
MiniWoB++ (arXiv) — https://arxiv.org/abs/1707.06150 — Pertinence: Micro-tâches pour une sélection d’actions UI fine-grainée.
Documentation LangChain — https://python.langchain.com/ — Pertinence: Orchestrateur de chaîne de base utilisé pour standardiser les contrôleurs linéaires.
Documentation d’utilisation des outils Anthropic — https://docs.anthropic.com/en/docs/build-with-claude/tool-use — Pertinence: Définit les conventions d’utilisation d’outil informant de l’alignement du schéma JSON.
Guide d’appel de fonctions OpenAI — https://platform.openai.com/docs/guides/function-calling — Pertinence: Établit des conventions d’appel de fonctions pour éviter les biais d’interface.
Annonce Meta Llama 3.1 — https://ai.meta.com/blog/meta-llama-3-1/ — Pertinence: Indique le soutien pour l’évaluation des modèles à poids ouverts.
DSPy (arXiv) — https://arxiv.org/abs/2306.04031 — Pertinence: Motive l’optimisation des invites déclarative pour réduire les appels invalides.
OWASP Top 10 pour les applications LLM — https://owasp.org/www-project-top-10-for-large-language-model-applications/ — Pertinence: Taxonomie standardisée pour le rapport d’incidents de sécurité chez les agents.
DeepSeek-LLM (arXiv) — https://arxiv.org/abs/2401.02954 — Pertinence: Famille de modèles ouverts utilisée pour tester la généralisation inter-modèles des contrôleurs.
Documentation LangGraph — https://langchain-ai.github.io/langgraph/ — Pertinence: Orchestrateur basé sur des graphes pour composer des contrôleurs interchangeables.
LlamaIndex — https://www.llamaindex.ai/ — Pertinence: Expose les récupérateurs en tant qu’outils avec provenance pour soutenir le scoring d’enracinement.

Sources & Références

ReAct: Synergizing Reasoning and Acting in Language Models Establishes the interleaved reasoning–acting baseline used as a canonical controller.

ReWOO: Decoupling Reasoning from Observations Supports plan-first orchestration to reduce unnecessary tool calls.

PAL: Program-aided Language Models Demonstrates program-aided reasoning with code execution in math/coding tasks.

Tree of Thoughts: Deliberate Problem Solving with Large Language Models Motivates deliberate multi-branch reasoning and its cost/latency trade-offs.

Reflexion: Language Agents with Verbal Reinforcement Learning Provides evidence for iterative self-repair in longer-horizon tasks.

ToolBench (OpenBMB) Supplies supervised function-calling baselines to measure tool-call precision/recall and invalid-call rates.

Gorilla: Large Language Model Connected with Massive APIs Shows how high-quality API schemas improve argument correctness and reduce invalid calls.

Gorilla OpenFunctions (GitHub) Provides standardized function signatures to evaluate tool-call quality.

AgentBench (arXiv) Benchmarks multi-API and planning tasks relevant to controller robustness.

AgentBench (GitHub) Offers the implementation for standardized agent APIs and rewards.

WebArena (arXiv) Standardized browser environment to measure navigation/form-filling.

WebArena website Official resource for environments and metrics.

BrowserGym (arXiv) Provides a controlled browsing arena and metrics; supports static vs. live runs.

SWE-bench (arXiv) Real-world bug-fixing benchmark where orchestration and environment fidelity matter.

SWE-bench website/leaderboard Official metrics and reproducibility protocols.

OpenDevin (arXiv) Software-agent baseline stack to compare orchestration strategies on SWE-bench.

OpenHands (arXiv) Alternative agent stack emphasizing realistic dev tooling comparisons.

DS-1000 (arXiv) Probes data science tool use in Python, stressing sandbox determinism.

Spider (arXiv) Text-to-SQL generalization with execution accuracy and exact-match metrics.

BIRD (arXiv) Large-scale text-to-SQL benchmark emphasizing realistic database grounding.

BIRD Leaderboard Official evaluation protocol and metrics for execution accuracy.

GAIA (arXiv) Planning/agent benchmark to test orchestration under diverse APIs.

HotpotQA (arXiv) Multi-hop QA dataset for compositional reasoning + RAG evaluation.

MuSiQue (arXiv) Multi-step QA emphasizing compositionality.

BEIR (arXiv) Standardized retrieval evaluation to assess evidence quality.

RAGAS (GitHub) Faithfulness metrics for RAG groundedness.

HELM (arXiv) Recommends transparent configs, multi-seed runs, and rigorous reporting.

MiniWoB++ (arXiv) Micro-tasks for fine-grained UI action selection reliability.

LangChain Documentation Baseline chain orchestrator used to standardize linear controllers.

Anthropic Tool Use Documentation Defines tool-use conventions informing JSON Schema alignment.

OpenAI Function Calling Guide Establishes function-calling schema conventions to avoid interface bias.

Meta Llama 3.1 Announcement Indicates function-calling support for open-weight model evaluations.

DSPy (arXiv) Motivates declarative prompt optimization to reduce invalid calls.

OWASP Top 10 for LLM Applications Standardized taxonomy for safety incident reporting in agents.

DeepSeek-LLM (arXiv) Open-model family used to test cross-model generalization of controllers.

LangGraph Documentation Graph-based orchestrator to compose swappable controllers.

LlamaIndex Exposes retrievers as tools with provenance to support groundedness scoring.