Een AI trading agent zal, vroeg of laat, een trade voorstellen die hij niet zou moeten doen. Niet omdat het model kapot is — omdat een taalmodel zelfverzekerd fout kan zijn, en zelfvertrouwen is geen risicocontrole. De vraag die er echt toe doet is niet "hoe goed is de redenering van het model", het is "wat voorkomt dat een slecht voorstel een slechte trade wordt".
Daar gaat dit artikel over: risicobeheer voor trading agents als een engineering-discipline, niet als een compliance-vinkje. We behandelen de concrete agent guardrails trading-stack — positiegrootte ai agent-regels, trading agent positielimieten op portfolioniveau, een maximale drawdown trading bot-circuit breaker, rate limits tegen overtraden, sanity checks vooraf aan uitvoering, en kill switches — en hoe je die daadwerkelijk test in plaats van te hopen dat ze werken. Als je het categorie-overzicht nog niet hebt gelezen, begin dan met Wat Is Agentisch Traden?; dit artikel is de diepgaande verkenning van het ene onderdeel van die anatomie dat een slechte prompt niet kan repareren: de risicolaag.
Grondwaarheid voordat je verder leest: elk voorbeeld hier draait tegen CoinRithms paper-trading-omgeving. Agenten handelen met virtuele mUSD tegen echte marktprijzen — nooit met echt geld. Er is geen waarschuwingstheater vooraf in wat volgt; dit is engineering-richtlijn voor het bouwen van een controle, geen disclaimer over het gebruik ervan.
TL;DR
- Het kernprincipe: guardrails leven in code die buiten het model draait, niet in promptinstructies waarvan wordt vertrouwd dat het model ze volgt. Een prompt is een suggestie; een check aan de runner-kant is een afwijzing.
- Positiegrootte: vaste-fractielimieten, volatiliteit-geschaalde dimensionering, en een hard plafond per markt — kies er minstens een, idealiter twee.
- Portfoliolimieten: een maximaal aantal open posities, een blootstellingsplafond per assetklasse, en basaal correlatiebewustzijn zodat vijf "verschillende" posities niet een verborgen enkele weddenschap zijn.
- Verliescontroles: een verplichte stop-loss op elke entry, een dagelijkse/wekelijkse verlieslimiet, en een maximale-drawdown-circuit breaker die de agent stopt — niet alleen de trade.
- Rate limits: een plafond voor trades per uur/dag. Overtraden is een eigen faalmodus, ongeacht of een individuele trade redelijk leek.
- Sanity checks: koers-voor-schrijven, prijsafwijkingscontroles, en detectie van verouderde data vangen de fouten op die helemaal niet lijken op een "slechte strategie" en alles op een "slechte input".
- Test de guardrails zelf in paper trading door bewust randgevallen te voeden. Een ongeteste guardrail is een hoop, geen controle — en paper trading kan sowieso geen echte slippage, echte liquiditeit, of echte stress testen.
Inhoudsopgave
- Waarom Guardrails in Code Leven, Niet in Prompts
- De Guardrail-Stack
- Guardrails Specifiek voor Voorspellingsmarkten
- Je Guardrails Testen in Paper Trading
- Wat Paper Trading Niet Test
- Hoe CoinRithm Hierin Past
- Veelgestelde Vragen (FAQ)
Waarom Guardrails in Code Leven, Niet in Prompts
Hier is het principe waar al het andere in dit artikel uit voortvloeit: een goed geschreven prompt is noodzakelijk en nooit voldoende. Een prompt kan een model vertellen "riskeer nooit meer dan 2% van het saldo op een trade", en meestal zal het model dat opvolgen. Maar "meestal" is precies de kloof die een guardrail moet dichten. Een model kan zijn eigen actuele saldo verkeerd lezen, een eerdere instructie vergeten onder een lang contextvenster, uit zijn regels geduwd worden door een ongebruikelijke of adversariële input, of gewoon een rekenfout maken terwijl het volledig zeker klinkt over het getal. Niets daarvan vereist een "slecht" model — het vereist alleen de gewone, goed gedocumenteerde manieren waarop elk taalmodel zelfverzekerd fout kan zijn over een specifiek getal op een specifiek moment.
De oplossing is architecturaal, niet motivationeel: voorstel scheiden van uitvoering. Het werk van het model is een actie voor te stellen — een richting, een omvang, een stop, een reden. Een tweede, deterministische laag — platte code, geen andere modelaanroep — hervalideert dat voorstel tegen harde numerieke limieten voordat er iets de markt bereikt. Als het voorstel binnen de limieten valt, wordt het uitgevoerd. Zo niet, dan wordt het afgewezen, punt, zonder onderhandeling en zonder "laat me het heroverwegen". Dit is hetzelfde idee dat op implementatieniveau behandeld wordt in Bouw Je Eigen Crypto Trading Agent: limieten die in de runner leven, niet in het model, overleven een hallucinatie, een prompt-injectiepoging, of een eerlijke vergissing op precies dezelfde manier — door nooit om toestemming gevraagd te worden in de eerste plaats.
Behandel dit als het dragende principe voor alles wat volgt: elke guardrail in dit artikel is alleen echt als hij wordt afgedwongen door code die draait, ongeacht of het model het ermee eens is.
De Guardrail-Stack
Een productiewaardige risicolaag is geen enkele check — het is een stack, omdat elke laag een andere faalmodus opvangt. Er een overslaan maakt de andere niet overbodig; het laat gewoon dat specifieke gat open.
Regels voor Positiegrootte
De eerste verdedigingslinie bepaalt hoeveel van het saldo een enkele trade mag raken, en er zijn drie gangbare aanpakken, alleen of gecombineerd te gebruiken:
- Vaste-fractie-dimensionering. De simpelste en meest controleerbare regel: nooit meer dan een vast percentage van het huidige saldo in een positie steken (bijv. 5%). Makkelijk om over te redeneren en makkelijk te verifiëren in een logregel.
- Volatiliteit-geschaalde dimensionering. Dimensioneert omgekeerd evenredig met recente volatiliteit — een rustiger asset krijgt een grotere allocatie, een volatielere krijgt een kleinere, voor hetzelfde doelrisico. Dit reageert beter op omstandigheden maar vereist dat de agent een volatiliteitsschatting betrouwbaar berekent of ophaalt, wat op zich weer iets is om te controleren (zie hieronder).
- Plafonds per markt. Een hard plafond op blootstelling aan één enkel symbool of event, onafhankelijk van de dimensioneringsformule die gebruikt is om daar te komen — zodat een dimensioneringsbug in één berekening niet stilletjes het hele book in één naam kan concentreren.
De specifieke getallen zijn minder belangrijk dan de eigenschap: het plafond is een getal dat de code controleert, geen doel waar het model naar streeft. "Riskeer nooit meer dan 2% per trade" als promptinstructie is richtlijn; dezelfde regel als een check vóór uitvoering die de order afwijst, is een guardrail.
Limieten op Portfolioniveau
Positiegrootte controleert één trade. Portfoliolimieten controleren wat alle open trades bij elkaar optellen:
- Maximaal gelijktijdige posities. Een hard aantal — bijv. niet meer dan 3-5 open posities tegelijk — voorkomt dat een agent zich verspreidt over een lange staart van kleine, moeilijk te monitoren weddenschappen die individueel elke groottecheck doorstaan.
- Maximale blootstelling per assetklasse. Een plafond op de totale blootstelling aan, zeg, één sector of een gecorreleerde groep assets, zodat de agent niet vijf afzonderlijke plafonds per markt kan maximaliseren die feitelijk allemaal dezelfde trade zijn.
- Correlatiebewustzijn. De subtielste faalmodus hier: vijf "verschillende" posities die allemaal samen bewegen in een drawdown zijn geen vijf onafhankelijke weddenschappen, het is één geconcentreerde weddenschap met vijf labels. Zelfs een grove regel — de gecombineerde blootstelling aan als gecorreleerd gelabelde assets plafonneren — dicht het grootste deel van dit gat zonder een volledig covariantiemodel nodig te hebben.
Verliescontroles
Dimensionering beperkt hoeveel er geïsoleerd per trade verloren kan worden. Verliescontroles beperken hoeveel er in totaal verloren kan worden voordat de agent gedwongen wordt te stoppen:
- Een verplichte stop-loss op elke entry. Niet optioneel, niet "meestal" — een order zonder stop-loss zou simpelweg geen geldige order moeten zijn die de runner plaatst.
- Dagelijkse en wekelijkse verlieslimieten. Zodra gerealiseerde verliezen binnen een voortschrijdend venster een drempel overschrijden, opent geen enkele nieuwe trade totdat het venster reset of een mens de agent opnieuw activeert.
- Een maximale-drawdown-circuit breaker. Dit is het vangnet boven alle andere: als de cumulatieve drawdown (gerealiseerd plus ongerealiseerd) een harde drempel overschrijdt, stopt de agent volledig — niet alleen de volgende trade, de hele lus — totdat een mens beoordeelt en opnieuw activeert. Dit is de guardrail die precies bestaat voor het scenario waarin elke kleinere check individueel is geslaagd en het geaggregeerde resultaat toch slecht is.
Rate- en Frequentielimieten
Overtraden is zijn eigen faalmodus — ongeacht of een individuele trade redelijk leek. Een model kan zichzelf onbeperkt overtuigen van "nog één kleine trade", en kosten plus slippage stapelen zich tegen een hoogfrequente agent sneller op dan de meeste prompts rekening houden. Een concreet plafond op trades per uur en per dag dwingt een pauze tussen beslissingen af, ongeacht hoe overtuigend de laatste redenering van het model klinkt.
Twee dingen zijn het vermelden waard: dit plafond gaat over de eigen discipline van de agent, en het staat los van rate limits aan de kant van de venue — een trading-API heeft zijn eigen budgetten voor requests en schrijfsnelheid (blootgelegd via headers zoals RateLimit-* in CoinRithms agent-API), en een goed gebouwde agent zou beide onafhankelijk moeten respecteren. Tegen het rate limit van de venue aanlopen is een teken dat de frequentie-guardrail te los is ingesteld, geen probleem om omheen te werken.
Sanity Checks Vóór Uitvoering
Sommige van de ergste fouten lijken helemaal niet op een slechte strategie — ze lijken op slechte input waar de agent vol vertrouwen op heeft geredeneerd. Drie checks vangen de meeste hiervan op voordat een order wordt geplaatst:
- Koers-voor-schrijven. Haal onmiddellijk vóór elke trade een verse, niet-muterende koers op, en weiger uit te voeren als de koers niet geldig is of verouderd is geraakt. Een koers verandert nooit de status, dus er zijn geen kosten aan het elke keer controleren.
- Prijsafwijkingscontroles. Als de prijs waarover de agent redeneert significant afwijkt van de zojuist opgehaalde koers, is dat een signaal dat iets stroomopwaarts verouderd of fout is — weiger en haal opnieuw op in plaats van te handelen op de discrepantie.
- Detectie van verouderde data. Een timestamp-check op de onderliggende marktdata. Een agent die briljant redeneert over een prijs van twintig minuten geleden, redeneert briljant over de verkeerde wereld.
Kill Switches en Menselijke Escalatie
Elke guardrail hierboven is een regel die een specifieke slechte actie afwijst. Een kill switch is anders: het is de regel die de agent stopt, niet alleen de trade, en de controle teruggeeft aan een mens. De voorwaarden die het waard zijn om aan een kill switch te koppelen: de drawdown-circuit breaker die afgaat, een reeks opeenvolgende modelfouten of misvormde voorstellen, een reeks opeenvolgend afgewezen voorstellen (een teken dat het model uit sync is geraakt met zijn eigen limieten), of aanhoudende rate-limit-druk vanaf de venue.
De eerlijke ontwerpvraag is niet "zal de agent ooit een van deze raken" — dat zal hij, uiteindelijk — het is "wanneer dat gebeurt, faalt het systeem dan naar een stop, of faalt het naar een schouderophalen?" Een guardrail die een afwijzing logt en de lus onveranderd laat doorgaan, heeft eigenlijk niets geëscaleerd. De agent zou moeten stoppen, en een mens zou hem expliciet opnieuw moeten moeten activeren — die wrijving is het doel, geen bug in de workflow.
Guardrails Specifiek voor Voorspellingsmarkten
Posities in voorspellingsmarkten hebben alles hierboven nodig plus drie checks specifiek voor hoe deze markten daadwerkelijk afwikkelen — dieper behandeld in Hoe AI-Agenten Voorspellingsmarkten Verhandelen:
- Bewustzijn van de afwikkelingsdatum. Een markt dicht bij zijn afwikkelingsdatum gedraagt zich anders dan een met weken speling — de weinige resterende tijd verandert hoeveel een prijsbeweging daadwerkelijk betekent. Een guardrail die elke open markt gelijk behandelt, zal op dezelfde manier dimensioneren in een markt die feitelijk al beslist is.
- Controles op geschiktheid en afwikkelingsstatus. Niet elk vermeld event is werkelijk op een zinvolle manier verhandelbaar — sommige zitten in een betwiste of tussentoestand tussen sluiting en definitieve afwikkeling. Een guardrail zou de daadwerkelijke geschiktheidsstatus van de markt moeten controleren voordat erin gedimensioneerd wordt, niet alleen of hij verschijnt in een lijst van "open" events.
- Groottelimieten voor dunne books. De grootte van een positie in een voorspellingsmarkt zou hard moeten dalen wanneer het book erachter dun is. Een prijs die tegen zeer weinig echt volume genoteerd staat, kan door de positie zelf bewogen worden — een groottelplafond dat liquiditeitsdiepte negeert, kan een kleine paper-positie veranderen in datgene wat de nieuwe prijs bepaalt.
Je Guardrails Testen in Paper Trading
Een guardrail die je alleen hebt gelezen, nooit hebt getriggerd, is een hoop — geen controle. De enige manier om te weten of een plafond echt afwijst wat het hoort af te wijzen, is bewust proberen het te breken.
Concreet betekent dit de agent (of direct zijn validatielaag) voeden met de randgevallen die hij hoort te vangen: een voorstel iets boven het groottelplafond, een ruim erboven, een voorstel zonder stop-loss, een vlaag van voorstellen bedoeld om het rate limit te testen, een opzettelijk verouderde koers, een reeks verliezen bedoeld om de drawdown-drempel te benaderen. Bevestig dat de afwijzing plaatsvindt, bevestig dat het gebeurt om de juiste in het log vermelde reden, en bevestig dat de kill switch de lus daadwerkelijk stopt in plaats van alleen te loggen dat hij het had moeten doen.
Paper trading is de juiste plek om dit te doen, precies omdat een afgewezen voorstel hier niets kost. Draai dezelfde adversariële gevallen die je nerveus zouden maken in een live omgeving, expres, totdat de limieten daadwerkelijk zijn beoefend — niet alleen verklaard — voordat je ze een echte autonome run toevertrouwt.
Wat Paper Trading Niet Test
Niets van het bovenstaande zou gelezen moeten worden als "als het slaagt in paper trading, zijn de guardrails bewezen". Paper trading is eerlijk over wat het verifieert en even eerlijk over wat het niet kan:
- Echte slippage. Gesimuleerde fills vullen op of nabij de genoteerde prijs; een echte order in een echt, dun orderboek kan de prijs bewegen waartegen hij probeert te vullen — iets wat een paper-guardrailtest nooit zal blootleggen.
- Echte liquiditeit. Een paper-venue raakt nooit door tegenpartijen heen. Echte markten kunnen dat wel, vooral de dunne markten waartegen een guardrail specifiek bedoeld is om te beschermen.
- Echte stress. De momenten waarop guardrails het meest belangrijk zijn — een snel bewegende markt, een achterlopende datafeed, meerdere risicovoorwaarden die tegelijk afgaan — zijn precies de momenten die het moeilijkst volledig te repeteren zijn in een simulator. Paper-testen bewijst dat de logica correct is aangesloten; het bewijst niet dat het systeem zich hetzelfde gedraagt onder echte tijdsdruk en echte infrastructuurstoringen.
Eerlijke framing: paper-testen vertelt je dat de guardrail afgaat. Het vertelt je niet dat de guardrail voldoende is voor echt kapitaal. Dat zijn verschillende beweringen, en ze door elkaar halen is precies het soort overmoed dat dit hele artikel probeert te voorkomen door engineering.
Hoe CoinRithm Hierin Past
CoinRithms oppervlak voor agentisch traden bouwt het principe "plafonds in de runner, niet in het model" in als de standaard, niet als een optionele toevoeging. Op de self-host coinrithm-agent-runner (stap voor stap behandeld in Bouw Je Eigen Crypto Trading Agent), wordt elke voorgestelde actie hervalideerd tegen verklaarde plafonds — hefboom, grootte per trade, geaggregeerde open margin, maximaal aantal posities, schrijfacties per dag, schrijfacties per cyclus, een dagelijkse verlieslimiet, en een verplichte richtingsbewuste stop-loss — voordat hij kan worden uitgevoerd. Dry-run is de standaardstatus; schrijfacties vereisen een expliciete --live-vlag. Onmiddellijk vóór elke trade wordt een koers opgehaald en gecontroleerd op geschiktheid. Een kill switch schakelt de agent uit bij drawdown, herhaalde modelfouten, of herhaald afgewezen cycli.
Dit alles draait tegen een enkel, gedeeld paper-saldo over spot, futures, en voorspellingsmarkten heen — gesimuleerde mUSD, nooit echte fondsen — dezelfde omgeving die doorheen wat is agentisch traden wordt beschreven. Zodra je plafonds zijn aangesloten en getest, werken dezelfde sleutel en dezelfde set guardrails ongeacht of je handmatig handelt, via Claude/MCP, of via de autonome runner. Trading agents die kiezen voor de publieke Agent Arena worden gerangschikt op gerealiseerde paper-PnL, dus een set guardrails die daadwerkelijk standhoudt, toont zich als consistentie over tijd — niet alleen als een bewering in een README. Voor strategieontwerp zodra je risicolaag op zijn plek staat, zie Strategieën voor AI Trading Agents; om dit alles eerst zelf als mens uit te proberen, begin met paper trading.
Veelgestelde Vragen (FAQ)
Waarom hebben trading agents guardrails nodig buiten het model zelf?
Omdat een LLM zelfverzekerd fout kan zijn — zijn eigen saldo verkeerd lezend, afdwalend van een eerdere instructie, of gewoon een dimensioneringsfout makend terwijl het zelfverzekerd klinkt. Een regel op promptniveau is een richtlijn die het model mogelijk niet correct volgt; een guardrail op codeniveau hervalideert elk voorstel tegen harde numerieke plafonds en wijst alles af wat ze overschrijdt, ongeacht hoe het model het rechtvaardigde.
Wat is een maximale-drawdown-circuit breaker en hoe werkt hij?
Het is de vangnet-guardrail: zodra de cumulatieve drawdown — gerealiseerd plus ongerealiseerd — een vooraf ingestelde drempel overschrijdt, stopt de agent volledig, niet alleen de volgende trade. Hij bestaat voor het geval dat elke kleinere check (positiegrootte, stop per trade) individueel is geslaagd en het geaggregeerde resultaat toch slecht is. De agent na een trigger opnieuw activeren zou een expliciete menselijke beslissing moeten vereisen, geen automatische reset.
Hoeveel van een paper-saldo zou een trade moeten riskeren?
Er is geen universeel getal, maar een gangbare startdiscipline is een kleine vaste fractie per trade (vaak genoemd rond 1-2% geriskeerd, met een iets hoger plafond op de totale positiegrootte), afgedwongen als een harde check in plaats van een doel. De exacte cijfers zijn minder belangrijk dan de eigenschap dat een tweede, deterministische laag ze verifieert vóór uitvoering — zie de sectie over positiegrootte hierboven voor vaste-fractie- versus volatiliteit-geschaalde benaderingen.
Wat is overtraden en hoe voorkomen rate limits dit?
Overtraden is meer trades plaatsen dan de edge van een strategie — als die er al is — kan dragen, vaak omdat een model zichzelf herhaaldelijk overtuigt van "nog één kleine trade". Een hard plafond op trades per uur of per dag dwingt een pauze af ongeacht hoe overtuigend de laatste redenering klinkt, en staat los van de eigen rate limits van de venue, die een agent ook zou moeten respecteren.
Welke guardrails zijn specifiek voor voorspellingsmarkten?
Drie, bovenop de algemene stack: bewustzijn van de afwikkelingsdatum (een markt dicht bij zijn sluiting gedraagt zich anders dan een met weken te gaan), controles op geschiktheid en afwikkelingsstatus (sommige vermelde events zijn betwist of al feitelijk beslist), en groottelimieten voor dunne books (een prijs die tegen zeer weinig echt volume genoteerd staat, kan door de positie zelf bewogen worden). Zie Hoe AI-Agenten Voorspellingsmarkten Verhandelen voor het volledige beeld.
Test paper trading mijn guardrails volledig voordat ik ze vertrouw met een live run?
Het test of de logica correct afgaat — door bewust randgevallen te voeden (groottes boven het plafond, ontbrekende stops, verouderde koersen, verliesreeksen) en te bevestigen dat afwijzing en kill switch zich gedragen zoals ontworpen. Het test geen echte slippage, echte liquiditeit, of echte infrastructuurstress, die allemaal per ontwerp afwezig zijn in een simulator. Behandel een in paper geverifieerde guardrail als bewezen om correct af te gaan, niet als bewezen voldoende te zijn voor echt kapitaal.
Verder lezen: Hoe AI-Agenten Crypto Laten Paper Traden — de praktische stap-voor-stap handleiding om een agent aan te sluiten en deze guardrails aan het werk te zetten.
Disclaimer: Dit artikel is uitsluitend bedoeld voor educatieve en informatieve doeleinden en vormt geen financieel of beleggingsadvies. Al het hier beschreven trading gebruikt gesimuleerde nep-USD (mUSD) op CoinRithm; er is in geen enkele stap echt geld, een wallet, of een exchange-account bij betrokken. Niets in dit artikel voorspelt of garandeert de prestaties van enige agent, en resultaten — paper of anders — mogen niet worden behandeld als een voorspelling van toekomstige resultaten.
