LACUNA: Veilige agenten als recursieve programmagaten

Samenvatting

LLM-agenten handelen steeds vaker door code te schrijven, maar er blijft een scheiding bestaan tussen de runtime die de agent aanstuurt en de code die het model schrijft. De runtime beheert de lus, context en controlestroom, en het model heeft hier weinig invloed op. Door door het model geschreven code de runtime zelf te laten vormgeven, zouden agenten expressiever worden, maar het zou ook veiligheidsproblemen verscherpen. Een model kan worden omgeleid door een promptinjectie, de verkeerde tool aanroepen, of halverwege falen en een inconsistente toestand achterlaten. Elk van deze fouten reikt verder wanneer de code de runtime vormgeeft dan wanneer het een enkele actie uitdrukt. We presenteren LACUNA, een programmeermodel voor agenten dat deze scheiding overbrugt terwijl de veiligheid behouden blijft. Elke agentactie is een getypeerde aanroep agent[T](taak) die de LLM met code vult wanneer de uitvoering deze bereikt, en de code wordt typegecontroleerd tegen het omringende programma voordat deze wordt uitgevoerd. Omdat elke actie als geheel wordt geaccepteerd of afgewezen, laat een afgewezen actie de omgeving onaangetast, en de compilerdiagnostiek stuurt een herpoging aan. Dezelfde controle begrenst ook welke tools en gegevens een actie mag gebruiken en hoe deze stromen. Onze primitief drukt ReAct-lussen, subagenten, vaardigheden, parallelle decompositie en multi-modelplanning uit als gewone controlestroom. We evalueren LACUNA op een verzameling testgevallen, BrowseComp-Plus en τ^2-bench. Op BrowseComp-Plus wordt 8,6% van de gegenereerde code afgewezen vóór uitvoering, met gemiddeld 0,7 herpogingen per query, en de agent behaalt een nauwkeurigheid van 27,1%. Op τ^2-bench lost LACUNA 76,0% van de 392 taken op in vier domeinen met een capabel model, vergelijkbaar met de baseline-agent.

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.