Claude Code AI trading agent: wat dit 24/7-systeem goed doet

Ik heb heel wat AI-agentdemo's gezien die instorten zodra ze de echte wereld raken.

Ze zien er strak uit, totdat geld, timing, ambiguïteit of falen in beeld komt. Dan verandert het hele verhaal in een gepolijste prompt vastgeketend aan slecht oordeel.

Daarom trok deze 24/7 AI trading agent-walkthrough mijn aandacht.

Niet omdat hij een magische geldprinter beloofde. Niet omdat hij een groter model gebruikte. En zeker niet omdat "AI trading bot" een term is die normaal gesproken zorgvuldige engineers aantrekt. Hij greep me omdat het systeem op de juiste manier was opgezet: routines, memory files, guardrails, paper trading, beperkte autonomie en een strategie die was gebouwd rond tragere, op fundamentals gebaseerde beslissingen in plaats van proberen elke drie minuten candles te scalpen.

Dat is een veel serieuzer ontwerp.

Dit artikel is gebaseerd op een video-walkthrough die ik heb geanalyseerd en de systeemdetails die daar werden gepresenteerd, niet op een live trading agent die ik persoonlijk met echt kapitaal heb ingezet.

De setup in de walkthrough gebruikt Claude Opus binnen Claude Code, waarbij het project is geüpgraded van Opus 4.6 naar Opus 4.7 voor sterker agentic gedrag. Rond dat model zit een praktisch besturingssysteem: Alpaca voor brokerage, Perplexity voor marktonderzoek, ClickUp voor notificaties, GitHub voor state-persistentie en geplande routines die de agent in beweging houden, ook wanneer er niemand achter het toetsenbord zit.

Als je de "AI trader"-hype eraf pelt, kijk je in werkelijkheid naar een continu draaiende beslissingspijplijn met geheugen, tooling en risicobeperkingen.

Dat onderscheid telt.

Want de interessante vraag is niet "Kan Claude aandelen kopen?"

Natuurlijk kan dat, als je hem aansluit op een brokerage-API.

De echte vraag is deze: kun je een systeem bouwen dat verstandige beslissingen blijft nemen wanneer de markt rumoerig is, het contextvenster eindig, de aannames van gisteren half verkeerd, en niemand in de buurt is om elke beweging te bewaken?

Dat is het deel waar deze walkthrough serieus mee omgaat. En daarom denk ik dat het de moeite waard is om te bestuderen, zelfs als je nooit een AI een live brokerage-account zou laten aanraken.

Dit is geen day trading bot, en dat is een kracht

De slimste beslissing in de hele architectuur is degene die de meeste mensen overslaan.

Deze agent wordt niet gepositioneerd als een hoogfrequent monster dat jaagt op trades onder de seconde. Hij probeert market makers niet te overtreffen. Hij doet niet alsof Claude opeens een quant desk is met co-located infrastructuur en een PhD-onderzoeksteam.

Hij is gebouwd voor een tragere stijl: swing trades, langere holdingperiodes, fundamentals, catalyst-onderzoek, portefeuille-reviews en gedisciplineerde uitvoeringsvensters.

Die keuze maakt het hele project meteen geloofwaardiger.

Large language models zijn goed in synthese. Ze kunnen rommelige input lezen, conflicterende signalen wegen, geschreven redeneringen produceren, narratieven vergelijken en een strategisch kader vasthouden wanneer de taak goed is afgebakend. Dat past veel beter bij "onderzoek een bedrijf, inspecteer catalysts, vergelijk overtuiging, dimensioneer het risico, log de beslissing" dan bij "voorspel de volgende beweging van vijf minuten in SPY."

De walkthrough versterkt dit met één benchmark waarvan ik denk dat mensen die vaak verkeerd begrijpen: agentic financial analysis. Dat soort evaluatie gaat niet echt over een scalping-machine worden. Het gaat erom of het model bedrijven kan bestuderen, kan redeneren over fundamentals en coherente investeringstheses kan produceren.

Dat is een totaal andere use case dan technische day trading.

En als ik iets in deze categorie zou bouwen, zou ik exact dezelfde inzet doen: laat het model opereren waar taal, onderzoek en beslissingsframing er daadwerkelijk toe doen.

Het echte product hier is het routinesysteem

De meeste mensen die zo'n video kijken focussen op de brokerage-integratie omdat dat het flitsende deel is. Kopen. Verkopen. Positie geopend. Trade uitgevoerd.

Ik denk dat dat de echte engineeringwinst mist.

Het echte product is de routine-laag.

De walkthrough splitst de agent op in geplande jobs verspreid over de handelsweek:

• Pre-market onderzoek
• Market-open uitvoering
• Midday risicobeheer
• Market-close review
• Wekelijkse performance-beoordeling

Dat schema is wat een eenmalige prompt verandert in een besturingssysteem.

Zonder routines heb je geen autonome agent. Je hebt een slimme chatsessie die alles vergeet zodra het venster sluit.

Met routines krijg je herhaald gedrag onder voorspelbare omstandigheden. De agent wordt wakker, leest geheugen, controleert de omgeving, voert een gedefinieerde job uit, werkt logs bij en geeft een betere state door aan de volgende run. Dat patroon is veel waardevoller dan de tradingniche zelf. Je zou hetzelfde ontwerp kunnen hergebruiken voor sales prospecting, security monitoring, support triage, contentonderzoek of infrastructuuronderhoud. Het is dezelfde reden waarom ik enthousiast werd over Claude Code tasks en parallelle uitvoering: de hefboom komt uit herhaalbare orchestratie, niet uit één indrukwekkende prompt.

Dit is een van de grootste mindset-verschuivingen die ik heb gehad bij het werken met AI-systemen: de moat zit meestal niet in de prompt. Hij zit in de loop.

Een sterk routinesysteem doet drie dingen tegelijk:

1. Het versmalt de job voor elke run.
2. Het maakt falen makkelijker te inspecteren.
3. Het stapelt leren op in de tijd via files, logs en revisies.

Dat is precies wat dit project doet.

Stateless runs, stateful geheugen

Dit is het deel dat ik het meest waardeerde.

Elke routine-run wordt op uitvoeringstijd als stateless behandeld, maar het bredere systeem blijft stateful via files. Dat is zo'n praktisch patroon voor Claude Code-werk.

In plaats van te doen alsof het model "het zich gewoon zal herinneren," leest en schrijft de agent expliciet zijn geheugen:

• strategie-files
• onderzoeksnotities
• trade history
• daglogs
• samenvattingen
• portefeuille-snapshots

Dat geeft elke run een continuïteitslaag zonder te forceren dat alle kennis in één opgeblazen gesprek leeft.

Ik heb te veel AI-workflows zien falen omdat de bouwer aanneemt dat een groot contextvenster persistentie oplost. Dat is niet zo. Meer context helpt, maar het verleidt mensen ook om alles op één plek te proppen totdat het signaal vertroebelt. De walkthrough benoemt dit zelfs met de tokenbudget-zorg: ruwweg 200.000 tokens klinkt enorm, totdat je system instructions, logs, eerder onderzoek, API-responses en live marktcontext in dezelfde run mengt.

Dan begint de rot.

Geen dramatisch falen. Erger. Zachte degradatie.

Het model schrijft nog steeds vloeiende output, maar het oordeel wordt minder scherp. Oude aannames blijven te lang hangen. Nieuw bewijs krijgt te weinig gewicht. Trade-offs vlakken af tot generieke samenvattingen. Dat is gevaarlijk in elke autonome workflow, en vooral gevaarlijk in iets dat geld raakt.

Externe memory files zijn de juiste tegenmaatregel.

Ze dwingen je om state met opzet te structureren. Wat is duurzame strategie? Wat is tijdelijk onderzoek? Wat hoort in het tradejournal? Wat moet worden samengevat in plaats van rauw doorgekopieerd? Zodra je zo denkt, wordt de agent makkelijker te schalen en veel makkelijker te debuggen. Ik heb hetzelfde principe zien terugkeren in zelfverbeterende Claude Code-systemen, waar de echte winst voortkomt uit wat de agent in de tijd bewaart, audit en verfijnt.

Waarom Opus 4.7 beter past bij dit soort werk

De walkthrough kadert de overstap van Opus 4.6 naar Opus 4.7 rond sterkere agentic prestaties: beter oordeel in ambigue situaties en betere zelfverificatie. Ik heb die model-shift-invalshoek directer uitgewerkt in mijn Opus 4.7-analyse, maar in deze tradingsetup is de praktische vraag eenvoudiger: gedraagt het model zich als een betere operator over herhaalde geplande runs?

Dat telt hier meer dan pure welbespraaktheid.

Een tradingroutine zit vol rommelige vragen die geen schone labels hebben:

• Is dit nieuws betekenisvol of slechts ruis?
• Is de positie-these gebroken of gewoon ongemakkelijk?
• Moet de agent wachten op bevestiging of nu handelen?
• Geldt de vorige notitie nog na de catalyst van vandaag?
• Is deze overtuiging hoog genoeg om risico te openen, of is het slechts een interessant idee?

Dat zijn oordeelsproblemen.

In mijn ervaring zijn de AI-systemen die langer overleven in productie niet de systemen die het slimst klinken in een demo. Het zijn de systemen die op de juiste momenten aarzelen, verifiëren voor ze handelen en coherent blijven wanneer de input incompleet is.

Daarom telt de "agentic workflow"-framing. Als een model beter is in het controleren van zijn eigen redenering, het kruisverwijzen van files en het weerstaan van de drang om voorbij het bewijs te improviseren, dan is dat precies de verbetering die je wilt in een gepland autonoom systeem.

Ik zou dat nog steeds nooit blind vertrouwen. Maar ik zou dat profiel absoluut prefereren boven een model dat vooral is geoptimaliseerd voor mooie proza of one-shot codeer-snelheid.

Het beste deel van de strategie is het risico-ontwerp

De walkthrough noemt een 30-daagse uitdaging waarin het eerdere systeem de S&P 500 met 8% versloeg.

Dat is een leuk resultaat. Het zou ook niet de hoofdconclusie moeten zijn.

Korte vensters kunnen bijna alles flatteren. Een goede maand is geen duurzame edge. Heel wat roekeloze systemen zien er briljant uit vlak voordat ze opblazen.

Wat me meer interesseert, is het guardrail-ontwerp:

• max position size rond 5% per positie
• limieten op nieuwe posities
• daily loss limits
• stop management
• eerst paper trading

Dat is volwassen gedrag.

Als je iets met financiële gevolgen gaat automatiseren, mag de eerste ontwerplaag niet zijn "Hoe maak ik het agressiever?" Hij moet zijn "Hoe voorkom ik dat het iets stoms doet om 9:47 op een rare dinsdag?"

Het routineschema weerspiegelt die mindset goed.

Pre-market is voor onderzoek en idee-generatie.

Market open is voor het uitvoeren van geplande trades in plaats van improviseren vanaf nul.

Midday is voor het wegsnijden van verliezers en het aandraaien van controle op winnaars.

Wekelijkse review is voor het beoordelen van het systeem en het bijstellen van de meta-laag.

Dat ritme duwt de agent weg van impulsief gedrag en richting procesdiscipline. Zelfs het gebruik van trailing stops en loss-drempels toont een besef dat AI-zelfvertrouwen niet hetzelfde is als risicobeheersing.

Als ik deze architectuur zou aanpassen, zou ik die guardrails behandelen als het eigenlijke kernproduct en de signaalgeneratie als de secundaire laag. Signalen komen en gaan. Risico-architectuur is wat het experiment lang genoeg in leven houdt om te leren.

GitHub als persistentielaag is een slimme, saaie keuze

Ik bedoel dat als compliment.

Een van de sterkste tekenen dat een systeem is gebouwd door iemand pragmatisch is wanneer de persistentielaag met opzet saai is.

Dit project bewaart zijn working state in een private GitHub-repository. De cloudroutines clonen de repo, draaien de job, werken files bij en committen de wijzigingen terug. Dat betekent dat het geheugen, de logs, strategie-documenten en operationele geschiedenis van de agent allemaal leven in een geversioneerde, inspecteerbare tijdlijn.

Dat is dramatisch beter dan alles verstoppen in vluchtige chatgeschiedenis.

Het levert je ook een paar concrete voordelen op:

• je kunt inspecteren hoe de strategie zich heeft ontwikkeld
• je kunt wekelijkse veranderingen in prompts of memory files vergelijken
• je kunt herstellen van slechte edits
• je kunt auditen waarom een beslissing is genomen
• je kunt het systeem migreren tussen omgevingen zonder de state handmatig te herbouwen

Er zit hier ook een dieper lesje in.

Wanneer mensen het over "AI agents" hebben, zijn ze vaak geobsedeerd door het model en investeren ze te weinig in de omringende software-hygiëne. Maar autonomie zonder auditbaarheid is gewoon chaos met een mooie branding.

Een Git-backed memory-systeem is niet glamoureus. Het is precies het soort saaie infrastructuur dat autonome workflows overleefbaar maakt.

De notificatielaag vertelt je veel over de bouwer

De walkthrough gebruikt ClickUp voor samenvattingen en alerts in plaats van standaard te kiezen voor Telegram of een luider notificatiekanaal.

Dat is een kleine keuze, maar het onthult iets nuttigs: het systeem probeert niet elke state-verandering in drama te veranderen.

Goede autonome workflows zouden interrupt-gedreven moeten zijn, niet ruis-gedreven.

Pre-market stuurt alleen urgente berichten.

Market open meldt alleen wanneer er daadwerkelijk een trade plaatsvindt.

Midday logt activiteit zonder te spammen.

Wekelijkse review produceert een verteerbare samenvatting.

Dat is het juiste patroon. Als elke routine om aandacht schreeuwt, negeert de menselijke operator op den duur alles. Een nuttige notificatielaag escaleert alleen wanneer een persoon echt iets moet weten.

Dit telt zelfs buiten trading. Ik gebruik hetzelfde principe in automatiseringsontwerp in het algemeen: als een workflow me pingt elke keer dat hij ademhaalt, heb ik een behoeftige robot gebouwd, geen betrouwbaar systeem.

De grootste les: leer de agent als een beginner, niet als een genie

Mijn favoriete analogie in de walkthrough is die van het fietsen.

Je gooit iemand op dag één niet het verkeer in en noemt dat een leerstrategie.

Je begint met zijwieltjes. Dan een rustige straat. Dan een echte weg.

Zo zouden deze systemen precies gebouwd moeten worden.

Begin met paper trading.

Schrijf de strategie helder op.

Definieer wat als geldig signaal telt.

Log elke actie.

Herzie fouten.

Scherp prompts aan.

Vergroot autonomie langzaam.

Die progressie is veel gezonder dan de gangbare "verbind model met API en bid"-aanpak. Hij respecteert het feit dat AI-agents niet betrouwbaar worden omdat je ze toestemming hebt gegeven. Ze worden betrouwbaar omdat je een omgeving hebt gecreëerd waarin goed gedrag makkelijker is dan slecht gedrag.

Dat is het echte vakmanschap.

Niet de prompt-theatraliek. Niet de screenshot van een trade-bevestiging. Het vakmanschap zit in de operationele beperkingen.

Waar ik denk dat dit kan breken

Ik vind de architectuur goed, maar ik denk ook dat iedereen die dit probeert keihard eerlijk moet zijn over de failure modes.

Ten eerste kan het model nog steeds overfitten op wat het meest leesbaar is in de context. Als één sterke onderzoeksnotitie overtuigender is geschreven dan de andere, kan de agent de narratieve kwaliteit overwegen in plaats van het werkelijke bewijs.

Ten tweede is verouderd geheugen gevaarlijk. Een strategie-file die drie weken geleden klopte, kan stilletjes slechte sturing worden als de marktomstandigheden verschuiven en niemand het document bijwerkt.

Ten derde erven API-geïntegreerde systemen de zwakheden van elke externe afhankelijkheid. Brokerage, onderzoek, notificaties, repo-sync, schedule-uitvoering, environment variables, branch-rechten, rate limits. Elk bewegend onderdeel voegt nog een manier toe waarop de workflow op het verkeerde moment kan falen.

Ten vierde kunnen logs rommel worden in plaats van geheugen als ze niet agressief worden samengevat. Een lang journal is niet automatisch een nuttig journal.

En ten vijfde is het psychologische risico reëel. Als de agent een sterke schrijfstijl heeft, kan hij zekerder klinken dan hij verdient. Dat kan de operator verleiden om kwaliteit van uitleg te vertrouwen in plaats van kwaliteit van uitkomst.

Ik zou een systeem als dit alleen draaien als ik een routine had voor het reviewen van de reviewer: niet alleen "welke trades heeft het gemaakt," maar "welke aannames blijven opduiken, welke files worden te zwaar, en waar rationaliseert het systeem in plaats van te redeneren?"

Wat ik onmiddellijk uit deze architectuur zou jatten

Zelfs als ik nul interesse had in geautomatiseerd traden, zou ik direct meerdere ideeën uit deze setup jatten.

Het eerste is het scheduled-routine-model voor het verdelen van werk over de dag.

Het tweede is de file-based memory-architectuur om de agent geaard te houden tussen runs.

Het derde is de GitHub-backed persistentielaag met versiegeschiedenis als auditlog.

Het vierde is de bias richting spaarzame, hoge-signaal-notificaties.

En het vijfde is het volharden in paper mode voordat live mode aan de beurt komt.

Dat laatste is bijna overal van toepassing. Voordat een agent productie-infra, klantgegevens, facturen, security-acties of echt kapitaal aanraakt, laat hem eerst in shadow mode opereren. Kijk hem denken. Kijk hem loggen. Kijk hem fout zijn in een veilige omgeving.

Die discipline is wat een nuttig autonoom systeem onderscheidt van een duur verhaal.

Wat ik zou eisen voordat ik dit echt geld zou laten aanraken

Als iemand me zou vragen waar ik de grens trek tussen "leuke prototype" en "systeem dat ik zou vertrouwen met een live account," zou mijn antwoord vrij streng zijn.

Ik zou minstens vier dingen op orde willen hebben.

Het eerste is een shadow-periode lang genoeg om patroon-drift bloot te leggen. Geen twee dagen. Geen geluksweekje. Ik zou willen dat de agent in paper mode lang genoeg draait om te tonen hoe hij zich gedraagt over saaie sessies, volatiele sessies, nieuwsrijke sessies en dagen waarop niets doen de juiste keuze is.

Het tweede is beslissingsreview op these-niveau, niet alleen op trade-niveau. Veel bouwers reviewen alleen of de trade winst of verlies maakte. Dat is niet genoeg. Ik wil weten of de redenering intern consistent was, of de aangehaalde catalysts echt waren, of de sizing paste bij de gestelde overtuiging en of de exit-logica de geschreven regels volgde.

Het derde is harde operationele fallback. Als GitHub-sync faalt, als de brokerage-API niet beschikbaar is, als een onderzoekscall rommel teruggeeft, of als environment variables ontbreken, zou het veiligste gedrag moeten zijn: stoppen en het falen loggen, niet eromheen improviseren. Autonome systemen verdienen vertrouwen deels door wat ze weigeren te doen.

Het vierde is een regelmatig strategie-snoeiritueel. Een onderschat risico in file-based memory-systemen is opstapeling. Elke week voeg je meer notities toe, meer lessen, meer meningen, meer uitzonderingen. Op den duur kan de agent eindigen met het lezen van een museum van half-dode overtuigingen. Ik zou een wekelijkse of maandelijkse opruimronde willen waarin verouderde aannames worden verwijderd, levende regels schoon worden herschreven en de kernstrategie compact genoeg blijft om scherp te blijven.

Dat is het stuk dat veel AI-bouwers onderschatten. Het systeem heeft niet alleen intelligentie nodig op runtime. Het heeft onderhoudsdiscipline nodig tussen runs.

En eerlijk gezegd, dat zou de echte edge kunnen zijn in projecten als dit. Niet de model-upgrade. Niet de API-stack. Niet de promptbewoording. De edge is of de menselijke operator de omgeving schoon genoeg houdt zodat de agent verstandige beslissingen kan blijven nemen.

Mijn visie

Deze walkthrough is interessant omdat hij AI-autonomie behandelt als systems engineering in plaats van wensdenken.

Ja, de kop is een 24/7 AI trading agent in Claude Code.

Maar de echte les is breder: als je een AI-agent serieus werk continu wil laten doen, geef hem dan routines, geheugen, risicogrenzen, geversioneerde state, selectieve notificaties en een job die smal genoeg is dat oordeel er daadwerkelijk toe kan doen.

Zou ik blind vertrouwen op een AI trading agent met echt geld? Nee.

Zou ik deze architectuur bestuderen als een template voor het bouwen van langdurig draaiende agents die met meer discipline opereren dan het gebruikelijke demo-aas? Absoluut.

Dat is het deel dat aandacht waard is.

Want de toekomst van nuttige AI-agents zal waarschijnlijk niet één gigantische alwetende bot zijn die alles tegelijk doet. Het zullen systemen zijn als deze: gepland, beperkt, gelogd, gereviewd en gebouwd om in de tijd te verbeteren.

En eerlijk gezegd, dat is een veel betere toekomst dan wat de hype-handelaars verkopen.

Laten we samenwerken

Op zoek naar het bouwen van AI-systemen, het automatiseren van workflows of het schalen van je tech-infrastructuur? Ik help graag.

• Fiverr (custom builds & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise-oplossingen): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (security-diensten): xcybersecurity.io