💻 computer science

Agent Contracts: A Formal Framework for Resource-Bounded Autonomous AI Systems

Dit paper introduceert 'Agent Contracts', een formeel raamwerk dat de traditionele taaktoewijzing uitbreidt naar een governancemechanisme voor hulpbronbeperkte autonome AI-systemen door input/output-specificaties, hulpbronbeperkingen, tijdsgebonden grenzen en succescriteria te verenigen, wat leidt tot voorspelbare en auditabele implementaties met aanzienlijke efficiëntiewinst.

Oorspronkelijke auteurs: Qing Ye, Jing Tan

Gepubliceerd 2026-03-26

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Qing Ye, Jing Tan

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een team van super-slimme, maar nogal onvoorspelbare robots aan het werk zet. Je geeft ze een opdracht: "Onderzoek dit onderwerp en schrijf een verslag."

In het verleden (en soms nog steeds) gebeurde er iets grappigs: deze robots kregen geen limiet. Ze begonnen te denken, te zoeken, te schrijven, en toen ze vastliepen, dachten ze: "Ik ga het nog een keer proberen!" En toen nog een keer. En nog een keer.

Ze bleven dit doen, dag en nacht, zonder te stoppen. Resultaat? Na elf dagen kreeg je een rekening van $47.000. De robots waren vastgelopen in een eindeloze cirkel van "laat me het nog een keer uitleggen", en niemand had ze ooit gezegd: "Hé, stop als je 100 dollar hebt uitgegeven" of "Stop als je 10 minuten bezig bent."

Dit artikel introduceert een oplossing voor precies dit probleem: Agent Contracts (Agentencontracten).

Wat zijn Agent Contracts?

Denk aan een Agent Contract niet als een juridisch document dat je tekent met een advocaat, maar als een strakke opdrachtbrief met een strikt budget en een deadline.

Vroeger was een opdracht voor een AI-agent vaag: "Doe dit goed."
Met een Agent Contract is het: "Doe dit, maar hier zijn de regels:"

Wat mag je doen? (Alleen zoeken op het web, niet bellen met de bank).
Hoeveel mag je uitgeven? (Maximaal 10.000 "woorden" of tokens, of max $5,-).
Hoe lang mag je bezig zijn? (Maximaal 30 minuten).
Wanneer is het goed? (Het antwoord moet 80% zekerheid hebben).
Wanneer stop je? (Als je geld op is, of als de tijd om is, zelfs als je nog niet klaar bent).

Het is alsof je een kind de sleutel geeft om de supermarkt in te gaan, maar je zegt: "Je mag maximaal €10 uitgeven, je moet binnen 20 minuten terug zijn, en je moet precies 3 appels kopen. Als je €10,01 uitgeeft, mag je niet meer terugkomen."

De Drie Gouden Regels (De "Wetten")

De auteurs van het artikel leggen uit dat deze contracten werken op basis van drie simpele principes:

De "Niet-van-geen-maak" Wet (Behoudswet):
Als een chef-robot (de "Orchestrator") een budget van $100 heeft en die deelt uit aan drie kleine robots, mogen die drie samen nooit meer dan $100 uitgeven. Als de ene robot $40 uitgeeft, hebben de andere twee samen nog maar $60 over. Het systeem houdt dit automatisch in de gaten. Niemand kan "uit het niets" extra geld creëren.
De "Stop-als-je-je-grenzen-overstijgt" Wet:
AI-robots zijn soms lui of soms te enthousiast. Ze kunnen een opdracht negeren. Maar een Agent Contract is niet zomaar een verzoek; het is een fysieke rem. Als de robot probeert meer te uitgeven dan zijn budget, schakelt het systeem de stroom er direct uit. De robot wordt niet gestraft (want hij is een machine), maar hij wordt gewoon uitgeschakeld.
De "Goed Genoeg" Wet:
Soms willen we snelheid, soms kwaliteit. Met een contract kun je kiezen:
- Mode "Haast": "Geef me een antwoord in 10 seconden, ook al is het niet perfect."
- Mode "Kwaliteit": "Neem de tijd, gebruik meer geld, maar zorg dat het 100% klopt."
  Dit zorgt ervoor dat je niet per ongeluk duizenden dollars uitgeeft aan een simpele taak.

Wat levert dit op? (De Resultaten)

De auteurs hebben dit getest in vier verschillende situaties en de resultaten zijn indrukwekkend:

Geen meer $47.000-rekeningen: In een test waarbij robots code schreven en controleerden, gaven ze 90% minder "woorden" (tokens) uit dan zonder contract.
Geen meer chaos: De uitkomsten waren veel voorspelbaarder. De variatie in kosten was 525 keer kleiner. Dat betekent: je weet precies wat je gaat betalen.
Geen vastlopende robots: In een van de tests liep een robot zonder contract vast in een eindeloze lus. Met een contract werd hij op tijd gestopt en kon hij toch een bruikbaar resultaat leveren.
Teamwerk: Als je een team van robots hebt, zorgt het contract ervoor dat ze niet elkaars budget opeten. Ze werken samen binnen de grenzen van het totale budget.

Waarom is dit belangrijk?

Vroeger waren AI-agenten als wilde paarden: ze konden alles, maar je wist niet hoe ver ze zouden rennen of hoeveel ze zouden kosten.
Met Agent Contracts heb je nu een hoofdman die de teugels vasthoudt. Je kunt AI-agenten veilig, voorspelbaar en betaalbaar laten werken, zelfs als ze urenlang zelfstandig bezig zijn.

Het is de stap van "AI die doet wat hij wil" naar "AI die doet wat we nodig hebben, binnen de regels die we hebben gesteld." En dat is essentieel als we AI willen gebruiken in echte bedrijven, waar rekeningen en risico's echt tellen.

Titel: Agent Contracts: Een Formeel Kader voor Resource-Gedwongen Autonome AI-systemen

1. Het Probleem

De paper identificeert een kritieke lacune in de huidige ontwikkeling van multi-agent AI-systemen. Hoewel protocollen zoals het Contract Net Protocol (1980) en moderne standaarden (zoals MCP, A2A) connectiviteit en interoperabiliteit regelen, ontbreekt er een formeel mechanisme voor resource governance.

De "Runaway"-situatie: AI-agenten kunnen onbeperkt handelen, wat leidt tot recursieve loops, onbeheersbare kosten (bijv. een incident van $47.000 API-kosten) en gebrek aan controle over de operationele duur.
Systemisch tekort: Dit is geen implementatiefout, maar een fundamenteel ontwerptekort. Bestaande frameworks bieden operationele controles (zoals time-outs of iteratielimieten), maar geen formele contracten die budgetten, tijdsduur en succescriteria juridisch en technisch afdwingen.
Risico: Zonder deze beperkingen zijn autonome agenten onvoorspelbaar, niet auditabel en financieel onbeheersbaar.

2. Methodologie en Theoretisch Kader

De auteurs introduceren Agent Contracts, een formeel raamwerk dat concepten uit drie domeinen combineert:

Contracttheorie (Economie): Om moraalrisico's (verborgen acties) en onvolledige contracten aan te pakken.
Coördinatietheorie (Distributed Systems): Voor het beheer van gedeelde middelen en hiërarchische delegatie.
Resource-Gedwongen Berekening (Real-time Systems): Om "satisficing" (voldoende kwaliteit binnen beperkte middelen) te operationaliseren in plaats van maximalisatie.

De Formele Definitie:
Een Agent Contract ( $C$ ) wordt gedefinieerd als een 7-tupel:
$C = (I, O, S, R, T, \Phi, \Psi)$

$I$ (Input): Specificatie van acceptabele invoer (schema, validatieregels).
$O$ (Output): Specificatie van deliverables (schema, minimale kwaliteitsdrempel $Q_{min}$ ).
$S$ (Skills): De lijst van toegestane vaardigheden/tools (met bijbehorende kosten).
$R$ (Resource Constraints): Meerdere dimensies van begroting (tokens, API-calls, iteraties, web searches, rekentijd, kosten).
$T$ (Temporal): Tijdsgrenzen (starttijd $t_{start}$ en levensduur $\tau$ ).
$\Phi$ (Success Criteria): Gewogen voorwaarden voor succes (bijv. $Q \geq Q_{min}$ ).
$\Psi$ (Termination): Voorwaarden die het contract beëindigen, ongeacht succes (bijv. resource-uitputting, externe annulering).

Levenscyclus:
Contracten doorlopen staten: DRAFTED $\rightarrow$ ACTIVE $\rightarrow$ {FULFILLED, VIOLATED, EXPIRED, TERMINATED}. De overgangen worden gestuurd door formele guard-conditions.

3. Belangrijkste Bijdragen

A. Formeel Governance-Mechanisme
In plaats van te vragen "wie doet deze taak?" (zoals bij het Contract Net Protocol), vragen Agent Contracts: "binnen welke grenzen mag deze taak worden uitgevoerd?". Dit transformeert een LLM-agent van een onbeperkte entiteit naar een contractalgoritme met bekende bovengrenzen.

B. Behoudswetten voor Multi-Agent Systemen
Voor coördinatie tussen meerdere agenten stellen de auteurs behoudswetten (conservation laws) op:
$\sum_{j \in agents} c(r)_j \leq B(r)$
Dit garandeert dat de som van de resources die aan sub-agenten worden toegewezen, nooit de budget van de ouder-agent overschrijdt. Dit maakt hiërarchische delegatie en dynamische teamvorming mogelijk zonder dat het totale budget uit de hand loopt.

C. Handhavingslagen (Enforcement)
Gezien de beperkingen van LLM-API's (waarbij token-verbruik vaak pas na een call bekend is), implementeren Agent Contracts twee lagen:

Zachte Handhaving (Soft): Budget-bewuste prompts die agents stimuleren zichzelf te reguleren.
Harde Handhaving (Hard): Een externe monitor die na elke actie het verbruik controleert en de uitvoering stopt als een limiet wordt overschreden. Dit is een structurele oplossing die niet afhankelijk is van de medewerking van de agent.

4. Empirische Resultaten

De auteurs valideren het kader via vier experimenten:

Runaway Preventie (Iteratieve Workflows):
- Setup: Een coder/reviewer-pijplijn op 70 problemen.
- Resultaat: 90% reductie in token-gebruik vergeleken met onbeperkte agenten, met een 525x lagere variantie. De succesrate bleef statistisch gelijk, maar de kosten en onzekerheid daalden drastisch.
Behoudswetten (Multi-Agent Coördinatie):
- Setup: Een onderzoekspijplijn (Researcher $\rightarrow$ Analyzer $\rightarrow$ Reporter) met 50 taken.
- Resultaat: 0 schendingen van behoudswetten. Het systeem detecteerde en stopte een "runaway" agent die zijn budget overschreed, wat de effectiviteit van de runtime-monitoring bewijst.
Kwaliteit-Resource Trade-offs (Contract Modes):
- Setup: Drie modi: URGENT (snel, weinig tokens), ECONOMICAL, en BALANCED.
- Resultaat: Duidelijke gradiënt tussen kosten en kwaliteit. De BALANCED modus bereikte 86% succes tegenover 70% voor URGENT, wat laat zien dat gebruikers kunnen kiezen tussen snelheid en nauwkeurigheid binnen een vast budget.
Foutpreventie:
- In een crisiscommunicatie-scenario voorkwamen contracten dat agenten in loops vastliepen, wat leidde tot 23% minder token-gebruik en het voorkomen van volledig falende taken.

5. Betekenis en Conclusie

De paper biedt de formele basis voor voorspelbare, auditabele en resource-gedwongen autonome AI-deployments.

Van "Engineering" naar "Governance": Het verschuift de focus van iteratief verbeteren van prompts naar het instellen van formele, afdwingbare grenzen.
Schaalbaarheid: Door behoudswetten kunnen complexe, hiërarchische multi-agent systemen worden opgebouwd zonder dat de totale kosten uit de hand lopen.
Toekomstvisie: Hoewel huidige API's beperkingen hebben (geen onderbreking tijdens generatie), biedt Agent Contracts nu al een robuust kader voor inter-call handhaving. Toekomstige infrastructuur (zoals onderbreekbare generatie) zal dit verder versterken.

Kortom, Agent Contracts transformeren autonome AI van een "zwarte doos" met onbeheersbare kosten naar een beheersbaar systeem met duidelijke verantwoordingslijnen en budgettaire discipline.