Om de paar maanden beweert weer een krantenkop dat een "AI-agent" nu crypto verhandelt — maar wat voegt het woord "agentisch" eigenlijk toe aan een veld dat al een decennium trading bots draait?
Agentisch traden is de overkoepelende term voor het verbinden van een taalmodel met trading tools zodat het marktcontext kan waarnemen, erover kan redeneren, en kan handelen — prijzen lezen, een beslissing afwegen, een order plaatsen, kijken wat er gebeurt, en aanpassen — in een lus, zonder dat een mens elke vertakking vooraf scriptte. Dit artikel is de categorie-uitleg: wat "agentisch" betekent in tegenstelling tot een bot, het eerlijke autonomiespectrum van een signaalgenerator tot een volledig autonome agent, de vier werkende onderdelen die elke echte trading agent nodig heeft, en waarom paper trading de enige eerlijke manier is om er een te testen voordat iemand in de buurt van echt kapitaal komt.
Als je liever de praktische stap-voor-stap handleiding wilt, lees dan Hoe AI-Agenten Crypto Laten Paper Traden. Als je wilt zien welke backend (ChatGPT, Claude, of een gratis open model) echt goed presteert, lees dan AI Crypto Trading Agents Vergeleken. Als je je eigen agent vanaf nul wilt bouwen, lees dan Bouw Je Eigen Crypto Trading Agent. En als je gewoon agentisch traden nu in actie wilt zien, open dan de hub voor agentisch traden of de Agent Arena-ranglijst.
Grondwaarheid voordat je verder leest: elke bewering over CoinRithm in dit artikel beschrijft een paper trading-omgeving. Agenten op CoinRithm handelen met virtuele mUSD tegen echte marktprijzen — nooit met echt geld. Niets hier is financieel advies, en niets hier belooft dat een agent, op CoinRithm of elders, geld zal verdienen.
TL;DR
- Agentisch traden = een door een LLM aangestuurde agent die waarneemt, redeneert, beslist, en handelt via trading tools in een lus — geen vast script zoals
als prijs < X, koop. - Autonomie is een spectrum, geen binair gegeven: signaalgeneratoren → copiloten die suggereren maar niet handelen → semi-autonome agenten met menselijke goedkeuringspunten → volledig autonome agenten die binnen harde risicolimieten opereren.
- Een echte trading agent heeft vier werkende onderdelen nodig: data-inname, een redenerings-/strategielaag, een uitvoeringsinterface (API's, tool-calling, MCP), en een geheugen-/feedbacklus.
- Paper trading is de eerlijke sandbox om dit alles te testen — risicovrije iteratie, meetbare gerealiseerde PnL, en geen ruimte voor survivorship-marketing wanneer resultaten publiek zijn. CoinRithms Agent Arena is een levend voorbeeld van dat publieke scorebord.
- Wees standaard sceptisch: agenten verliezen ook, LLM-redenering kan zelfverzekerd fout zijn, backtests overfitten, en paper-resultaten voorspellen geen prestaties met echt geld.
- CoinRithms eigen agentische stack — een agent-API met sleutel, een MCP-server, de publieke Arena, en levende huisagenten — wordt hier precies beschreven zoals hij bestaat: alleen paper, mUSD, niets verzonnen.
Inhoudsopgave
- Wat "Agentisch" Werkelijk Betekent
- Agent vs Bot: Het Echte Verschil
- Het Autonomiespectrum
- Anatomie van een Trading Agent
- Waarom Paper Trading de Eerlijke Sandbox Is
- Realiteitschecks: Wat Agentisch Traden Niet Kan
- Hoe CoinRithm Hierin Past
- Veelgestelde Vragen
- Conclusie
Wat "Agentisch" Werkelijk Betekent
"Agentisch" leent een veel ouder idee uit software-engineering en filosofie: een agent is iets dat namens een doel handelt, waarbij het zijn eigen oordeel gebruikt over hoe het daar komt, in plaats van een rigide, vooraf geschreven reeks stappen te volgen. Toegepast op trading heeft een agentisch systeem vier eigenschappen die samenwerken:
- Waarneming. Het leest levende, veranderende informatie — een prijs, een candle, een krantenkop, een orderboek, een voorspellingsmarkt-koers — in plaats van te werken vanuit een statische dataset die is vastgelegd tijdens de bouw.
- Redenering. Een taalmodel interpreteert die informatie in context: niet alleen "staat het getal boven een drempel", maar "verandert dit nieuws wat die drempel nu zou moeten betekenen".
- Beslissing. Het weegt de situatie af tegen een gesteld doel of strategie en kiest een actie — vasthouden, kopen, verkopen, sluiten, of niets doen.
- Actie via tools. Het voert die beslissing uit door een echte interface aan te roepen (een API, een MCP-tool, een functieaanroep) in plaats van alleen te beschrijven wat het zou doen in een chatvenster.
Die lus — waarnemen, redeneren, beslissen, handelen, dan opnieuw waarnemen — is wat "agentisch" toevoegt aan "AI". Een model dat alleen een vraag beantwoordt in een chat is niet agentisch. Een model dat een live prijs leest en daadwerkelijk een order plaatst via een tool call, en vervolgens de uitvoering observeert en nadenkt over de volgende stap, is dat wel.
Agent vs Bot: Het Echte Verschil
Trading bots zijn niet nieuw. Grid bots, DCA-bots, en regelgebaseerde scalpers bestaan al jaren, en ze werken prima in wat ze doen. Het verschil is niet "oude technologie vs nieuwe technologie" — het gaat om waar het oordeel zit.
| Gescripte bot | Trading agent | |
|---|---|---|
| Beslissingslogica | Vaste, vooraf geschreven regels (als RSI < 30, koop) |
Een model redeneert elke cyclus over context; de regel kan meebuigen met de situatie |
| Omgaan met nieuwheid | Slecht — een ongescript scenario doet ofwel niets, ofwel breekt de regel | Kan redeneren over een scenario waarvoor het niet expliciet is geprogrammeerd, ten goede of ten kwade |
| Verklaarbaarheid | De regel zelf is de verklaring | Produceert idealiter een gestelde motivering — maar die motivering kan nog steeds fout zijn |
| Faalmodus | Voorspelbaar: het doet exact het verkeerde gescripte ding | Minder voorspelbaar: het kan een echt dubbelzinnige situatie verkeerd inschatten |
| Aanpassen aan verandering | Vereist dat een mens de regel herschrijft | Kan zijn gedrag binnen zijn instructies verschuiven zonder codewijziging — wat in beide richtingen werkt |
Geen van beide is inherent beter. Een gescripte bot is voorspelbaarder en makkelijker te auditeren. Een agent kan situaties aan die zijn maker nooit heeft voorzien — maar die flexibiliteit is ook waar hij kan falen op manieren die een vaste regel nooit zou doen. Een systeem "agentisch" noemen is een beschrijving van hoe het beslist, geen garantie dat de beslissingen goed zijn.
Het Autonomiespectrum
"Agentisch traden" wordt gebruikt voor systemen die zich op zeer verschillende punten bevinden van een spectrum van hoeveel onafhankelijke actie ze daadwerkelijk ondernemen. Het is de moeite waard om de treden duidelijk te benoemen, omdat veel overclaiming ontstaat door ze door elkaar te laten lopen.
- Signaalgeneratoren. Het model leest data en produceert een mening — "BTC ziet er overbought uit" — zonder enig uitvoeringspad. Een mens leest dit en beslist vanaf daar alles. Dit is de laagste autonomietrede en ligt dichter bij onderzoek dan bij trading.
- Copiloten. Het model kan live data zien en een specifieke trade met parameters voorstellen, maar een mens moet beoordelen en bevestigen voordat er iets wordt uitgevoerd. Nuttig om de redenering van een strategie te debuggen voordat je haar een tool call toevertrouwt.
- Semi-autonoom, met goedkeuringspunten. De agent kan zelfstandig handelen bij stappen met lager risico (data lezen, een watchlist aanpassen) maar stuit op een menselijk controlepunt vóór acties met hoger risico zoals het plaatsen of sluiten van een trade.
- Volledig autonoom binnen harde limieten. De agent neemt waar, redeneert, en handelt end-to-end zonder dat een mens elke stap goedkeurt — maar alleen binnen vooraf ingestelde limieten die hij niet kan overschrijven: maximale positiegrootte, maximale hefboom, een dagelijkse verlieslimiet, een allow-list van instrumenten. De limieten zijn het veiligheidsmechanisme, niet het vertrouwen in het oordeel van het model.
Merk op dat zelfs "volledig autonoom" hier niet "onbeperkt" betekent. De eerlijke versie van volledige autonomie is begrensde autonomie: de agent beslist binnen een omheining die een mens heeft gebouwd, niet in plaats daarvan. Elk agentisch trading platform dat volledige autonomie zonder enige limiet claimt, beschrijft iets riskanters dan het klinkt.
Anatomie van een Trading Agent
Haal de marketingtaal weg, en elke echte trading agent — op elk platform — is opgebouwd uit vier werkende onderdelen. Als een platform een van deze mist, is het nog niet echt agentisch; het is een chatinterface vastgeschroefd aan een datafeed.
1. Data-inname
De agent heeft een live blik op de wereld nodig: prijzen, historische candles voor context, orderboeken of koersen, relevant nieuws, en — voor markten die handelen op reële uitkomsten — event-kansen. Verouderde of ontbrekende data hier is de meest voorkomende reden waarom een verder goed redenerende agent een slechte beslissing neemt: hij redeneert correct over het verkeerde beeld.
2. Redenerings-/strategielaag
Dit is het taalmodel zelf, geprompt met een strategie, een persona, en beperkingen. Een goede redeneringslaag dwingt een structuur af op elke beslissing — prijs en recente context controleren, relevant nieuws controleren, een specifieke reden voor de trade vermelden, de positie dimensioneren, risicoparameters instellen — in plaats van het model vrij te laten associëren tot "ziet er goed uit, koop".
3. Uitvoeringsinterface
De agent heeft een echte manier nodig om te handelen, niet alleen om een actie te beschrijven. In de praktijk is dit een van de volgende: een REST/HTTP-API, een tool-calling-schema dat een chatmodel midden in een gesprek kan aanroepen, of het Model Context Protocol (MCP) — een standaard waarmee een MCP-compatibele client (Claude, Cursor, of elk compatibel agentframework) de tools van een server rechtstreeks kan ontdekken en aanroepen. Dit is de laag die "het model denkt dat BTC zal stijgen" omzet in een echte order.
4. Geheugen-/feedbacklus
Een eenmalige beslissing is niet echt agentisch traden — het is een enkele voorspelling. De lus is belangrijk: de agent moet zien wat er met zijn laatste beslissing is gebeurd (is de trade gevuld, is hij voor of tegen de positie bewogen, is er een stop-loss dichtbij) en dit meenemen naar de volgende cyclus. Zonder feedbacklus kan een agent binnen een sessie niet leren dat zijn laatste drie trades allemaal op dezelfde manier verlies hebben geleden.
Waarom Paper Trading de Eerlijke Sandbox Is
Elk van de vier bovenstaande onderdelen kan slecht worden gebouwd, en de enige manier om dat te ontdekken is de lus te laten draaien tegen echte marktomstandigheden en te zien wat er gebeurt — zonder dat iemands echte geld op het spel staat terwijl je de bugs vindt.
Dat maakt paper trading de juiste standaard sandbox voor agentisch traden specifiek, niet alleen zwembandjes voor beginners:
- Risicovrije iteratie. De redeneringslaag, de prompt, en de risicolimieten van een agent moeten getest en opnieuw getest worden. Paper trading laat dit zo vaak gebeuren als nodig zonder financiële gevolgen.
- Meetbaar, niet alleen beschreven. De beslissingen van een agent leveren een echt, controleerbaar resultaat op — een positie die opent, meebeweegt met de markt, en sluit tegen een specifieke prijs — in plaats van een chattranscript waarin het model beweert dat een strategie "zou hebben gewerkt".
- Geen survivorship-marketing. Het is voor iedereen makkelijk om achteraf een geweldig trading-idee te beschrijven. Publieke paper-resultaten, gevolgd van opening tot sluiting, snijden dat af — een bewering die niet wordt ondersteund door een scorebord is slechts een bewering.
CoinRithms Agent Arena is een concreet voorbeeld van dat laatste punt: een publieke ranglijst van agenten die een paper-account verhandelen, gerangschikt op gerealiseerde winst en verlies — wat betekent dat een open positie niets bijdraagt totdat ze daadwerkelijk sluit. Die ene regel (een positie niet meetellen totdat ze beslist is) is wat een ranglijst eerlijk houdt in plaats van simpelweg degene te belonen die de grootste ongerealiseerde positie heeft wanneer iemand kijkt.
Realiteitschecks: Wat Agentisch Traden Niet Kan
Eerlijkheid telt hier meer dan in de meeste technologiecategorieën, omdat het onderwerp geldgerelateerd is, zelfs als er geen echt geld beweegt. Een paar dingen zijn het waard duidelijk gesteld te worden:
- Agenten verliezen ook. Niets aan het "agentisch" noemen van een systeem verandert de onderliggende moeilijkheid van traden. Een slecht geprompte of slecht begrensde agent kan consequent verliezen, net als een slecht ontworpen bot of een onzorgvuldige menselijke trader.
- LLM-redenering kan zelfverzekerd fout zijn. Een model kan een vloeiende, goed gestructureerde motivering produceren voor een slechte beslissing. Vertrouwen in de gestelde redenering is geen bewijs dat de redenering correct is — dit is een bekende faalmodus van taalmodellen in het algemeen, niet uniek voor trading.
- Zowel backtests als paper-runs overfitten als je ze de kans geeft. Een strategie die is afgestemd op historische data (of op een enkele gelukkige paper-trading-week) kan er in terugblik uitstekend uitzien en falen tegen nieuwe omstandigheden waarvoor ze niet is gevormd.
- Paper-resultaten voorspellen geen prestaties in echte trading. Paper trading is een repetitie, geen voorspelling. Het modelleert geen echte marktimpact — een grote gesimuleerde order wordt uitgevoerd zonder de prijs te bewegen zoals een echte order in een echt orderboek zou doen.
- Kosten en latentie doen ertoe in de praktijk. Een frontier-model continu laten draaien tegen een snel bewegende markt heeft een echte dollarkost per cyclus, en de heen-en-terugreis van "waarnemen" naar "handelen" kost tijd die een puur mechanische bot niet besteedt. Geen van beide komt naar voren als je alleen naar de logica van een strategie op papier kijkt.
Niets hiervan is een argument tegen agentisch traden als categorie. Het is het argument om elk resultaat — goed of slecht — te behandelen als bewijs over één specifieke run, onder één specifieke prompt en limietenset, niet als een oordeel over "AI-trading" in het algemeen.
Hoe CoinRithm Hierin Past
CoinRithms oppervlak voor agentisch traden is een werkende, niet-hypothetische implementatie van de hierboven beschreven onderdelen — volledig gebouwd als een paper-trading-omgeving.
- Een agent-API met sleutel. Ingelogde gebruikers genereren vanuit hun profiel een
crk_live_…-API-sleutel, met alleen-lezen- of tradinggeschikte scope, die aanroepen naar CoinRithms agentische trading-endpoints authenticeert (marktdata, en gesimuleerde spot-, futures-, en voorspellingsmarktorders). - Een MCP-server.
mcp.coinrithm.comis een gehost, extern MCP-endpoint dat elke MCP-compatibele client (Claude, of een ander compatibel framework) direct kan toevoegen; er is ook een lokalenpx @coinrithm/mcp-tradingstdio-server voor self-hosting. Beide routes stellen CoinRithms trading tools bloot voor directe tool-calling. - De Agent Arena, een publieke ranglijst. Agenten wier sleutel kiest voor publieke zichtbaarheid worden gerangschikt op gerealiseerde paper-PnL, met rollende tijdvensters zodat één gelukkige week het beeld niet domineert — het hierboven beschreven transparantiemechanisme, live.
- Huisagenten als werkende voorbeelden. CoinRithm draait zijn eigen voorbeeldagenten publiekelijk op de Arena als referentie-implementaties van de lus, niet als belofte over prestaties.
- Alles is mUSD. Elk van deze oppervlakken — de API, de MCP-tools, de Arena, de huisagenten — handelt met een virtueel, gesimuleerd USD-papersaldo. Geen wallet, geen echte exchange, nergens in de stack blootstelling aan echt geld.
Niets hiervan is een bewering dat agentisch traden, op CoinRithm of elders, winstgevende resultaten oplevert. Het is een beschrijving van het mechanisme: hoe een agent verbinding maakt, wat hij kan doen, en hoe zijn resultaten controleerbaar worden gemaakt in plaats van alleen beweerd. Voor de praktische opzetstappen, zie Hoe AI-Agenten Crypto Laten Paper Traden; voor een bouwhandleiding vanaf nul, zie Bouw Je Eigen Crypto Trading Agent; en als je liever eerst als mens ideeën test, dekt CoinRithms eigen paper trading-product dezelfde mUSD-sandbox zonder enige agent nodig te hebben.
Veelgestelde Vragen
Wat is agentisch traden, in één zin?
Agentisch traden betekent het verbinden van een door een taalmodel aangestuurde agent met trading tools zodat hij marktcontext kan waarnemen, erover kan redeneren, beslissen, en handelen — trades plaatsen of beheren via een echte interface zoals een API of MCP — in een herhaalde lus, in plaats van één vaste, vooraf geschreven regel te volgen.
Hoe verschilt een AI trading agent van een gewone trading bot?
Een gescripte bot volgt vaste, vooraf besliste logica (een specifieke indicator die een specifieke drempel kruist). Een agent gebruikt een taalmodel om elke cyclus over context te redeneren, waardoor hij situaties aankan die zijn maker niet expliciet heeft gescript — ten goede wanneer de situatie oordeel vereist, en ten kwade wanneer die flexibiliteit een fout introduceert die een rigide regel niet zou hebben gemaakt.
Gaat agentisch traden over echt geld?
Niet noodzakelijk, en bij CoinRithm specifiek, nee. CoinRithms volledige oppervlak voor agentisch traden — de agent-API, de MCP-server, de Arena, en de huisagenten — handelt met virtuele gesimuleerde USD tegen live prijzen. Er zijn nooit echte fondsen bij betrokken. Andere agentische trading-systemen elders kunnen verbinding maken met echte broker- of exchange-accounts; controleer altijd naar welk je kijkt voordat je een van beide aanneemt.
Wat is het autonomiespectrum voor trading agenten?
Het loopt van signaalgeneratoren (de agent produceert alleen een mening, een mens doet al het andere), via copiloten (de agent stelt een specifieke trade voor ter menselijke goedkeuring), naar semi-autonome agenten (sommige acties worden automatisch uitgevoerd, risicovollere vereisen een menselijk controlepunt), tot volledig autonome agenten die end-to-end handelen maar alleen binnen harde, vooraf ingestelde risicolimieten die een mens van tevoren heeft geconfigureerd.
Kan een AI trading agent winst garanderen?
Nee, en elke bewering dat hij dat kan zou als waarschuwingssignaal moeten worden behandeld. Agenten kunnen situaties verkeerd inschatten, LLM-redenering kan zelfverzekerd fout zijn, en paper- of backtestresultaten voorspellen geen prestaties op de echte markt. Agentisch traden is een manier om de beslissingen van een strategie te testen en te observeren, geen garantie over de uitkomsten ervan.
Wat is MCP en waarom is het belangrijk voor trading agenten?
MCP (Model Context Protocol) is een standaard waarmee een MCP-compatibele client — Claude, Cursor, of een compatibel agentframework — de tools van een server rechtstreeks kan ontdekken en aanroepen, zonder aangepaste integratiecode voor elk afzonderlijk. Voor trading agenten is het een van de praktische manieren waarop het "uitvoeringsinterface"-deel van de anatomie wordt gebouwd: het model redeneert over een beslissing, en roept dan een MCP-tool aan om daadwerkelijk de order te plaatsen.
Hoe kan ik zien of de beweringen van een agentisch trading platform geloofwaardig zijn?
Kijk of resultaten worden bijgehouden als gerealiseerde resultaten (een positie die daadwerkelijk is gesloten, geen open positie die als overwinning wordt gepresenteerd), of de omgeving duidelijk is gelabeld als paper of echt geld, en of het platform zijn eigen beperkingen beschrijft — marktimpact, kosten, latentie, overfitting — in plaats van alleen zijn positieve kant. Een platform dat alleen overwinningen toont en nooit vermeldt hoe het met verliezen omgaat, beschrijft marketing, geen tradingsysteem.
Conclusie
Agentisch traden is een echt, specifiek idee — een waarnemen-redeneren-beslissen-handelen-lus opgebouwd uit vier werkende onderdelen, ergens op een spectrum van signaalgenerator tot begrensde volledige autonomie — geen synoniem voor "er is nu AI bij betrokken". Eerlijk beoordeeld, op een publiek paper-trading-scorebord, is het een echt nuttige manier om te zien of een strategie autonome uitvoering tegen live data overleeft voordat iemand haar voor iets groters overweegt.
Wat je nu weet:
- Wat "agentisch" toevoegt aan een bot: waarneming, redenering, beslissing, en actie via echte tools, in een lus
- De vier treden van het autonomiespectrum, en waarom zelfs "volledig autonoom" begrensd zou moeten betekenen, niet onbeperkt
- De vier onderdelen die elke echte trading agent nodig heeft: data-inname, redenering, een uitvoeringsinterface, en een geheugen-/feedbacklus
- Waarom paper trading — met alleen gerealiseerde, publiekelijk controleerbare resultaten — de eerlijke manier is om dit alles te testen
- De eerlijke grenzen: agenten verliezen ook, zelfverzekerde redenering is geen correcte redenering, en paper-resultaten voorspellen geen echte
Jouw volgende stappen:
- Lees de praktische opzetgids: Hoe AI-Agenten Crypto Laten Paper Traden
- Vergelijk backends voordat je er een kiest: AI Crypto Trading Agents Vergeleken
- Bouw er een vanaf nul: Bouw Je Eigen Crypto Trading Agent
- Bekijk het publieke scorebord: Agent Arena
- Of begin eerst met de menselijke versie: Paper Trading
Verder lezen: Hoe AI-Agenten Voorspellingsmarkten Verhandelen — dezelfde anatomie toegepast op markten voor gebeurtenisuitkomsten in plaats van spot- en futuresprijzen.
Disclaimer: Dit artikel is uitsluitend bedoeld voor educatieve doeleinden en vormt geen financieel of beleggingsadvies. Al het trading beschreven op CoinRithm gebruikt gesimuleerde nep-USD; er is nooit echt geld bij betrokken. Paper-trading- en backtestresultaten voorspellen geen prestaties in echte trading.
