LACUNA : Agents sûrs en tant que trous de programme récursifs

Résumé

Les agents de LLM agissent de plus en plus en écrivant du code, mais un fossé persiste entre l’environnement d’exécution qui pilote l’agent et le code que le modèle produit. L’environnement d’exécution contrôle la boucle, le contexte et le flux d’exécution, et le modèle n’a que peu d’emprise sur ces éléments. Permettre au code écrit par le modèle de façonner l’environnement d’exécution lui-même rendrait les agents plus expressifs, mais accentuerait également les problèmes de sécurité. Un modèle peut être détourné par une injection d’invite, appeler le mauvais outil, ou échouer en cours de route et laisser un état incohérent ; chacun de ces échecs a des conséquences plus étendues lorsque le code façonne l’environnement d’exécution que lorsqu’il exprime une action unique. Nous présentons LACUNA, un modèle de programmation pour agents qui comble ce fossé tout en préservant la sécurité. Chaque action d’agent est un appel typé `agent[T](task)` que le LLM remplit avec du code lorsque l’exécution l’atteint, et ce code est vérifié statiquement par rapport au programme environnant avant son exécution. Étant donné que chaque action est acceptée ou rejetée dans son ensemble, une action rejetée laisse l’environnement intact, et ses diagnostics de compilation déclenchent une nouvelle tentative. La même vérification limite également les outils et données qu’une action peut utiliser ainsi que leur flux. Notre primitive exprime les boucles ReAct, les sous-agents, les compétences, la décomposition parallèle et la planification multi-modèle comme un flux de contrôle ordinaire. Nous évaluons LACUNA sur un ensemble de cas de test, BrowseComp-Plus et τ²-bench. Sur BrowseComp-Plus, 8,6 % des générations sont rejetées avant exécution, avec 0,7 nouvelle tentative par requête en moyenne, et l’agent atteint une précision de 27,1 %. Sur τ²-bench, LACUNA résout 76,0 % des 392 tâches dans quatre domaines avec un modèle performant, à égalité avec l’agent de référence.

English

LLM agents increasingly act by writing code, yet a split persists between the runtime that drives the agent and the code the model writes. The runtime owns the loop, context, and control flow, and the model has little say over any of them. Letting model-written code shape the runtime itself would make agents more expressive, but it would also sharpen safety problems. A model can be diverted by a prompt injection, call the wrong tool, or fail partway and leave an inconsistent state, and each such failure reaches further when the code shapes the runtime than when it expresses a single action. We present LACUNA, a programming model for agents that closes this split while preserving safety. Each agent action is a typed call agent[T](task) that the LLM fills with code when execution reaches it, and the code is type-checked against the surrounding program before it runs. Because each action is accepted or rejected as a whole, a rejected one leaves the environment untouched, and its compiler diagnostics drive a retry. The same check also bounds which tools and data an action may use and how they flow. Our primitive expresses ReAct loops, sub-agents, skills, parallel decomposition, and multi-model planning as ordinary control flow. We evaluate LACUNA on a collection of test cases, BrowseComp-Plus, and τ^2-bench. On BrowseComp-Plus, 8.6% of generations are rejected before execution, with 0.7 retries per query on average, and the agent reaches 27.1% accuracy. On τ^2-bench, LACUNA solves 76.0% of 392 tasks across four domains with a capable model, on par with the baseline agent.