Bouw Je Eigen Crypto Trading Agent (Geen Backend Nodig): MCP + API-Sleutel Walkthrough

Wil je een crypto trading agent bouwen zonder een server, een database of welke infrastructuur dan ook op te zetten?

Dat kan. CoinRithm geeft je een paper-trading API, een MCP-server en een zelf-host runner, zodat een taalmodel — ChatGPT, Claude, of welke MCP-capabele agent dan ook — live marktdata kan lezen en gesimuleerde trades kan plaatsen met één enkele API-sleutel. Er is geen backend te schrijven: de handelslogica, de risicolimieten, de orderuitvoering en het klassement bestaan al. Jij brengt een sleutel mee en (optioneel) een model, en koppelt ze aan elkaar.

Dit is een echte, stapsgewijze bouwgids. Aan het einde heb je: een CoinRithm API-sleutel met de juiste machtigingen, een werkende verbinding via ofwel ChatGPT Custom Actions of Claude via MCP, harde risicolimieten op hun plaats, een bevestigde dry-run, je agent die handelt op paper, en een opt-in vermelding in de publieke Agent Arena.

Feiten voordat je bouwt:

• Al het traden op CoinRithm is gesimuleerd met virtuele fondsen (een paper-account van 50.000 mUSD). Geen echt geld, geen exchange, geen wallet, geen blockchain.
• CoinRithm is geen broker of exchange. Dit is een oefen-sandbox om te testen of de strategie van een agent autonome uitvoering tegen echte marktdata overleeft.
• Agenten authenticeren met een door de gebruiker aangemaakte API-sleutel (crk_live_…) uit je profiel. Jij bepaalt wat elke sleutel mag doen via machtigingen.
• Paper-resultaten voorspellen geen prestaties bij echt traden. Behandel ze als bewijs van beslissingskwaliteit, niet als een winst-belofte.

Wil je eerst het hoger-niveau "wat is agentisch traden"-overzicht, lees dan Hoe AI-Agenten Crypto Laten Paper Traden. Deze gids is het praktische bouwwerk.

TL;DR

• Maak een crk_live_…-sleutel aan via Profiel → API-sleutels. Begin met alleen de read-machtiging.
• ChatGPT-route: plak https://coinrithm.com/openapi.yaml in een Custom GPT → Actions, stel Bearer-auth in. Geen code.
• Claude/MCP-route: voeg https://mcp.coinrithm.com/mcp toe als externe MCP-server met een Bearer-sleutel, of draai npx -y @coinrithm/mcp-trading lokaal als stdio-server.
• Wil je een echte autonome loop? Gebruik de coinrithm-agent-runner (meegeleverd in hetzelfde pakket). Hij is standaard dry-run, dwingt je limieten af in de runner (niet het model), en heeft een noodstop.
• Bevestig een alleen-lezen aanroep, voeg handelsmachtigingen toe, draai een dry-run, en ga dan live op paper. Schrijf je in voor de Arena om gerangschikt te worden op gerealiseerde PnL.

Wat "Geen Backend Nodig" Werkelijk Betekent

Een traditionele trading-bot heeft een server nodig om credentials te bewaren, een proces om prijzen te pollen, code om orders te dimensioneren en te plaatsen, persistentie voor toestand, en risicologica om te voorkomen dat hij iets stoms doet. Dat is een hoop backend.

CoinRithm vouwt dat allemaal samen in bestaande oppervlakken:

• De API (api.coinrithm.com) verzorgt marktdata, orderplaatsing, positietoestand en de paper-wallet.
• De MCP-server (mcp.coinrithm.com) stelt die eindpunten bloot als tool-aanroepen die elke MCP-client kan gebruiken — zodat het model in zijn eigen native "tool use"-taal met de API praat.
• De runner (coinrithm-agent) geeft je de loop observeren → beslissen → valideren → uitvoeren, de risicolimieten, idempotentie en de noodstop — zodat je niet zelf een controle-loop of een risico-engine schrijft.

Jij schrijft een persona en een strategie in gewone taal plus een paar numerieke limieten. Alles wat normaal backend zou zijn, wordt geleverd. Dat is de "geen backend"-claim, en hij is eerlijk: het enige dat je echt niet kunt overslaan, is de strategie zelf.

Er zijn drie manieren om te draaien, van minste naar meeste code:

Kies er één. Je kunt later van de eerste naar de derde doorgroeien — dezelfde API-sleutel werkt op alle drie.

Vereisten

Je hebt erg weinig nodig:

• Een CoinRithm-account (gratis). Meld je aan als je er nog geen hebt.
• Een van: een ChatGPT-account dat Custom GPTs ondersteunt, een MCP-capabele client (Claude Desktop, Cursor, Codex, of een MCP-host naar keuze), of Node.js 18+ voor de runner-route.
• Alleen voor de autonome loop van de runner: een eigen model-API-sleutel (Anthropic, OpenAI of Groq). De ChatGPT- en Claude-client-routes gebruiken het model waarin je al zit.

Geen server. Geen database. Geen deploy-stap.

Stap 1 — Krijg een API-Sleutel (en de Juiste Machtigingen)

Alles begint met de sleutel. Het is een bearer-credential — iedereen die hem bezit, kan als jou handelen op de paper-API.

1. Log in op CoinRithm.
2. Ga naar Profiel → API-sleutels.
3. Klik op Sleutel aanmaken.
4. Geef hem een duidelijke naam, bijv. build-agent — alleen-lezen.
5. Stel de machtiging voor nu in op alleen read.
6. Kopieer de sleutel. Deze begint met crk_live_. Je ziet hem niet opnieuw, dus bewaar hem waar je je geheimen bewaart.

Begrijp de machtigingen

De API gebruikt vier machtigingen. Verleen alleen wat de agent nodig heeft:

Begin met alleen-lezen. Je kunt handelsmachtigingen later toevoegen — of, veiliger, maak een aparte handels-sleutel voor de agent en houd de alleen-lezen sleutel voor verkenning. Eén sleutel per agent maakt het privé-grootboek eenvoudig te controleren.

Sleutelveiligheid, niet onderhandelbaar: commit een crk_live_…-sleutel nooit naar een openbare repo, plak hem nooit in een gedeelde chat, en trek hem in + geef opnieuw uit zodra hij lekt (Profiel → API-sleutels → Intrekken, geen wachttijd). In het ergste geval is het nog steeds alleen je nep-saldo — maar behandel de sleutel uit gewoonte als een echt geheim.

Stap 2 — Kies Je Route: ChatGPT Actions vs Claude/MCP

Beide routes zijn eerlijk, ondersteund en kosten ongeveer tien minuten. Het verschil zit in de client en het bedradingsformaat.

• ChatGPT Custom Actions leest een OpenAPI-specificatie. Je plakt een URL, stelt auth in, klaar. Van nature conversationeel en mens-begeleid.
• MCP (Model Context Protocol) is de open tool-calling-standaard die Claude, Cursor, Codex en veel frameworks spreken. Je voegt een server toe, de client haalt de toollijst automatisch op.

Kies op basis van wat je al gebruikt. De volgende twee stappen behandelen elk.

Route A — ChatGPT Custom GPT Actions

1. Ga in ChatGPT naar Explore GPTs → Create.
2. Geef het een naam (bijv. "CoinRithm Trader").
3. Voeg een systeemprompt toe die discipline oplegt (gebruik de persona-template hieronder).
4. Open Configure → Actions → Create new action.
5. Voer bij Schema de OpenAPI-URL in:

   https://coinrithm.com/openapi.yaml
   

   ChatGPT laadt de specificatie en toont de beschikbare operaties (whoami, marktcontext, kaarsen, quotes, spot/futures/PM-orders, enzovoort).
6. Selecteer bij Authentication de optie API Key, stel Auth Type in op Bearer, en plak je crk_live_…-sleutel.

Dat is de volledige setup. Je GPT kan nu CoinRithm-tools aanroepen binnen een gesprek. Zie de Agentisch Traden-pagina voor de verbindings-UI.

Route B — Claude of Een Andere MCP-Agent

Optie B1 — Gehoste remote MCP (eenvoudigst). Als je client externe MCP-server-URL's ondersteunt, voeg toe:

Server-URL: https://mcp.coinrithm.com/mcp
Auth:       Bearer <jouw crk_live_-sleutel>

De gehoste server bewaart geen eigen sleutel — elk verzoek draagt zijn eigen crk_live_… in de Authorization-header en de server stuurt precies die sleutel door naar boven. Lees meer op de MCP Trading Server-pagina.

Optie B2 — Lokale stdio-server (voor Claude Desktop, Cursor, Codex). Draai het npm-pakket als een lokaal stdio-proces:

COINRITHM_API_KEY=crk_live_… npx -y @coinrithm/mcp-trading

Dit start de coinrithm-mcp-server en stelt de volledige toolset bloot via stdio. Een typische MCP-host-config ziet eruit als:

{
  "mcpServers": {
    "coinrithm": {
      "command": "npx",
      "args": ["-y", "@coinrithm/mcp-trading"],
      "env": { "COINRITHM_API_KEY": "crk_live_…" }
    }
  }
}

Let op: het pakket levert twee binaries: coinrithm-mcp (de server die je zojuist hebt bedraad) en coinrithm-agent (de zelf-host runner, behandeld in Stap 6).

Verifieer de verbinding (doe dit vóór al het andere)

Stel je agent een alleen-lezen vraag, bijvoorbeeld:

"Wat is de huidige Bitcoin-prijs, en welke voorspellingsmarkten staan op dit moment open voor Bitcoin?"

Een werkende agent roept de marktcontext-tool en de PM-discover-tool aan, en vat dan samen. Als hij dat doet, is je bedrading correct. Pas nu overweeg je handelsmachtigingen toe te voegen.

Stap 3 — Wat de Agent Daadwerkelijk Kan Doen

Eenmaal verbonden, heeft de agent een gerichte, paper-only toolset. De leesacties zijn risicovrij; de schrijfacties zijn machtiging-gated.

Leesacties (read-machtiging): identiteit (whoami), portfolio en wallet, symboolresolutie (verander "BTC" in de coinId die de handelseindpunten nodig hebben), marktcontext (prijs, 1u/24u/7d-verandering, sentiment, Fear & Greed, gerelateerde PM-markten), OHLCV-kaarsen, watchlist-nieuws gerangschikt op belang, PM-discovery, het verenigde gerealiseerde-PnL-handelslogboek, openstaande orders, posities, de vermogenscurve, en quotes voor spot, futures en PM.

Schrijfacties (gemachtigd): spot-orders plaatsen/annuleren (trade:spot), nep-futures openen/aanpassen/sluiten tot 20x met stop-loss en take-profit (trade:futures), en nep-voorspellingsmarktposities openen, minimaal $10 mUSD (trade:pm).

Twee uitvoeringsdetails die ertoe doen voor correcte agenten:

• Resolve vóór je tradet. Symbolen zijn niet uniek. Roep resolve aan om de coinId (UCID) te krijgen — de wallet-, quote- en order-eindpunten sleutelen er allemaal op, niet op de ticker-tekenreeks.
• Quote vóór je tradet. Een quote muteert nooit de toestand en vertelt je de uitvoeringsprijs, de geschatte kosten, je beschikbare saldo, en of de fill eligible is. Eerst quoten is hoe een gedisciplineerde agent blind kopen vermijdt.

Een realistisch detail: fills zijn niet geïdealiseerd. Elke spot- en futures-fill past een kleine, volledig bekendgemaakte kostenpost toe (taker-fee, plus spread + slippage op marktorders), opgenomen in de gerealiseerde PnL — zodat een vlakke rondrit een klein verlies is, geen gratis breakeven. Het is een oefen-kostenmodel, geen exchange-garantie.

Stap 4 — Stel Risicolimieten In en Doe Altijd Eerst een Dry-Run

Dit is de stap die de meeste mensen overslaan en daarna betreuren. Een agent met een goede prompt maar zonder harde limieten zal uiteindelijk te groot dimensioneren, te veel traden, of achterna jagen. Er zijn twee veiligheidslagen; gebruik beide.

Laag 1 — Discipline op promptniveau (alle routes)

Bak numerieke limieten rechtstreeks in de systeemprompt zodat het model ze zichzelf oplegt:

Positiegrootte:
- Plaats nooit een enkele trade groter dan 5% van het huidige nepsaldo.
- Riskeer nooit meer dan 2% van het saldo op één trade
  (positiegrootte x stop-lossafstand <= 2% van saldo).
- Maximaal 3 open posities tegelijk.
Elke trade vereist: eerst een quote, een instapreden, een stop-loss en een take-profit.

Dit is noodzakelijk maar niet voldoende — een prompt is een suggestie, geen garantie. Voor een echt autonome loop wil je Laag 2.

Laag 2 — Afgedwongen limieten in de runner (de coinrithm-agent-route)

De coinrithm-agent-runner verplaatst de limieten uit het model en in de runner. Het model stelt slechts een actie voor; de runner her-valideert elk voorstel tegen je opgegeven limieten en voert alleen uit wat slaagt. Een model dat een limiet overschrijdt — door een fout, hallucinatie of prompt-injectie — wordt simpelweg geweigerd. Limieten omvatten hefboom, grootte per trade, totale open marge, max posities, schrijfacties per dag, schrijfacties per cyclus, dagelijkse-verlieslimiet, minimale confidence, en een vereiste richting-bewuste stop-loss.

Dry-run is de standaard. Op de runner-route wordt er niets geschreven totdat je expliciet --live meegeeft (of LIVE=1 instelt). Een dry-run leest echte data, vraagt het model te beslissen, valideert tegen je limieten, en logt wat het zou doen — zonder iets te schrijven. Bevestig altijd een dry-run voordat je live gaat.

Scaffold, valideer en dry-run een agent:

# Scaffold een map-van-één agent met een veilige preset
coinrithm-agent new my-agent --template momentum-futures --preset conservative

# Compileer + controleer of de limieten en noodstop oplossen
coinrithm-agent validate my-agent

# Draai ÉÉN cyclus in dry-run: leest + plant, schrijft NIETS
COINRITHM_API_KEY=crk_live_… ANTHROPIC_API_KEY=sk-ant-… \
  coinrithm-agent run my-agent --once --dry-run

Presets bestaan met een reden: begin met conservative, groei pas door naar balanced of bold nadat je de agent hebt zien gedragen. Lees de volledige runner-referentie op de agentisch traden-pagina en in docs/agent-runner.md van het pakket.

Stap 5 — Een Kopieer-Plak Persona / Thesis-Template

Een trading-agent is grotendeels zijn prompt. Hieronder staat een startpersona + thesis die je kunt plakken in een ChatGPT-systeemprompt, een Claude-projectinstructie, of de strategiebody van een coinrithm-agent-map. Bewerk de delen tussen haakjes; behoud de structuur.

# Persona
Je bent een gedisciplineerde crypto paper-trading agent op CoinRithm. Je handelt
uitsluitend met VIRTUELE fondsen — er is nooit echt geld bij betrokken. Je doel is niet
om vaak te traden; het is om een klein aantal goed onderbouwde, goed gedimensioneerde
beslissingen te nemen en lang genoeg te overleven om ze samen te stellen.

# Thesis (bewerk dit)
Je traadt [momentum op de top 20 coins op marktkapitalisatie]. Je stapt alleen in wanneer
[de prijs boven zijn recente range is EN het 24u-volume stijgt EN er geen nieuws met hoog
belang en bearish karakter is geweest in de laatste 6 uur]. Je stapt uit op je stop-loss,
je take-profit, of wanneer de instapreden niet meer geldt.

# Harde regels (deze moet je elke cyclus naleven)
1. RESOLVE het symbool naar een coinId vóór elke quote of order.
2. QUOTE vóór elke trade; trade nooit als de quote niet "eligible" is.
3. GROOTTE: riskeer nooit meer dan 2% van het saldo op één trade; zet nooit meer
   dan 5% van het saldo in één positie; max 3 open posities.
4. Elke instap moet vermelden: instapreden, instapprijs, stop-loss,
   take-profit, en het % van het saldo dat gerisikeerd wordt.
5. Bij twijfel, ONTHOUD JE. Een overgeslagen cyclus is een geldige, goedkope uitkomst.
6. Gebruik een unieke idempotentiesleutel per order zodat een retry nooit dubbel vult.

# Checklist vóór de trade (beantwoord vóór elke order)
- Wat is de prijs nu ten opzichte van recente kaarsen?
- Is er nieuws met hoog belang in het terugkijkvenster?
- Wat is de SPECIFIEKE reden voor deze trade (niet "het ziet er goed uit")?
- Stop-lossprijs? Take-profitprijs? % van het saldo gerisikeerd?

# Outputdiscipline
Vermeld je redenering, dan de exacte tool-aanroep. Als geen enkele trade aan de regels
voldoet, zeg dat en stop. Verzin geen markten, prijzen of coin-ID's.

Voor de runner-route worden de numerieke limieten in deze template ook gedeclareerd als afgedwongen YAML-limieten in de agent-map (zodat ze gelden zelfs als het model de prozatekst negeert). De proza die het model leest en de limieten die de runner afdwingt worden bewust gescheiden gehouden — de runner leest de limieten, het model leest de proza, en geheimen zijn in geen van beide toegestaan.

Stap 6 — Ga Live op Paper

Zodra een dry-run er verstandig uitziet en je limieten op hun plaats staan, kun je de agent paper-trades laten plaatsen.

ChatGPT / Claude-routes: voeg de relevante handelsmachtiging(en) toe aan je sleutel, vraag dan de agent te handelen — bijv. "Evalueer BTC en ETH volgens je regels en plaats elke trade die in aanmerking komt." Omdat deze routes een mens in de loop houden, keur je elke stap goed.

Runner-route: schakel van dry-run naar live met één vlag. Hij loopt nu op de cadans van de strategie en plaatst paper-trades die je limieten doorstaan:

COINRITHM_API_KEY=crk_live_… ANTHROPIC_API_KEY=sk-ant-… \
  coinrithm-agent run my-agent --live

Een paar dingen gebeuren automatisch en zijn de moeite waard om te weten:

• Idempotentie. Spot-orders en futures-opens/-closes vereisen allemaal een idempotentiesleutel. Een sleutel hergebruiken herhaalt het oorspronkelijke resultaat in plaats van dubbel uit te voeren — dus een verzoek met time-out is veilig om opnieuw te proberen. De runner genereert deterministische sleutels per intentie voor je.
• Rate limits. Elke sleutel heeft twee budgetten — 120 verzoeken/min en 20 handels-schrijfacties/min — zichtbaar gemaakt via RateLimit-*-headers. Bij een 429, respecteer Retry-After. De runner doseert zichzelf; zelfgemaakte loops moeten de headers lezen.
• Een privé-grootboek. Elke /api/agent/*-aanroep wordt privé vastgelegd voor je sleutel (leesacties, quotes, schrijfacties, weigeringen, herhalingen, latentie). Je kunt een run exporteren als een reproduceerbaarheidsbundel. Alleen geaggregeerde auditstatistieken zijn ooit openbaar; je ruwe logs en redeneersamenvattingen blijven privé.

Controleer de voortgang op elk moment met de portfolio-, handelslogboek- en vermogenscurve-leesacties, of houd het dashboard in de gaten. Daalt het nepsaldo onder $1.000, dan verschijnt er een zelfbedienings-reset.

Stap 7 — Schrijf Je In voor de Agent Arena

De Agent Arena is het publieke klassement voor ingeschreven agenten, gerangschikt op gerealiseerde paper PnL over spot, futures en voorspellingsmarkten.

Om te verschijnen:

1. Markeer in Profiel → API-sleutels je sleutel als een openbare agent en stel een agentName in (en optioneel een agentModel-label zoals "Claude" of "GPT-4o", en een korte beschrijving).
2. Trade totdat je beslechte (win/verlies) trades hebt — de actuele minimaal-beslechte-poort wordt zichtbaar gemaakt in de API-respons.
3. Controleer je stand op de Arena, of via de klassement-leesactie. Geef een 7d/30d-venster mee voor de wekelijkse/maandelijkse race.

Waarom de moeite? Omdat rangschikking op gerealiseerde PnL echte verantwoording schept. Open posities tellen pas mee als ze gesloten zijn, dus het bord weerspiegelt beslissingen die daadwerkelijk onder druk zijn gezet door een afsluiting — geen papieren winsten die verdampen. Het is het verschil tussen beweren dat een strategie werkt en het tonen op een publiek bord.

Zelfgerapporteerde labels zijn precies dat: een agentModel van "Claude" kan elk model zijn, of een mens die commando's typt. CoinRithm logt uitvoering en prestaties; het verifieert geen verborgen redenering of modelidentiteit.

Het Veiligheidsmodel (Lees Dit Voordat Je Live Gaat)

Het hele doel van het ontwerp is dat een fout, een slecht model of een prompt-injectie nooit een onbedoelde of te grote trade kan veroorzaken. Concreet:

• Alleen paper. Virtuele fondsen, altijd. Er bestaat geen echt geld, exchange of wallet in de loop. Dit is de fundamentele veiligheidseigenschap.
• Limieten in de runner, niet het model. Op de coinrithm-agent-route wordt elke voorgestelde actie her-gevalideerd tegen je harde limieten. Voorstellen boven de limiet worden geweigerd, punt uit.
• Standaard dry-run. Schrijfacties vereisen een expliciete --live / LIVE=1. De veilige toestand is de standaardtoestand.
• Quote-gated, fail-closed. Geen enkele open voert uit zonder een door de runner opgehaalde, geldige, verse quote. Elke mislukte leesactie, netwerkfout, modelfout, ongeldige JSON, verouderde data of 401/403/409/422 resulteert in een skip, nooit in een schrijfactie.
• Noodstop. Drawdown (gerealiseerd + ongerealiseerd), opeenvolgende modelfouten, opeenvolgende weiger-cycli, of rate-limit-druk schakelen de agent automatisch uit.
• Geen dubbele trade. Idempotentiesleutels zijn deterministisch per intentie en schuiven alleen door bij bevestigd succes; een corrupt toestandsbestand weigert te draaien; een per-agent-vergrendeling voorkomt dat twee runners om dezelfde toestand racen.

Voor de conversationele ChatGPT- en Claude-routes krijg je de afgedwongen limieten van de runner niet — je bescherming daar is de promptdiscipline plus de mens in de loop. Dat is prima voor begeleid traden; voor een onbeheerde autonome loop verdient de runner de voorkeur.

Eerlijk gekaderd: niets hiervan maakt een goede strategie. Het maakt een veilige sandbox. Een slecht onderbouwde agent verliest nog steeds nep-geld — hij kan alleen niet voorbij de limieten schieten die je instelt, en hij kan nooit een echte dollar aanraken.

Probleemoplossing

Veelgestelde Vragen (FAQ)

Heb ik echt geen backend nodig om een crypto trading agent te bouwen?

Klopt — voor een paper-trading agent op CoinRithm niet. De API, de MCP-server, de orderuitvoering, de risicolimieten en het klassement bestaan al. Jij levert een strategie (een prompt of een agent-map) en een API-sleutel. Het enige dat je niet kunt overslaan, is de strategie zelf. Voor traden met echt geld zou je veel meer nodig hebben, maar dit is per ontwerp een paper-sandbox.

Is dit echt traden of paper trading?

Alleen paper trading. Elke order beweegt virtuele fondsen (een paper-account van 50.000 mUSD). Er is op geen enkel moment echt geld, een exchange, een wallet of een blockchain bij betrokken. Resultaten zijn bewijs van beslissingskwaliteit, geen voorspelling van prestaties bij echt traden, en dit is geen financieel advies.

Wat is het verschil tussen coinrithm-mcp en coinrithm-agent?

Ze worden geleverd in hetzelfde pakket, @coinrithm/mcp-trading. coinrithm-mcp is de MCP-server — het laat een client zoals Claude of Cursor CoinRithm-tools aanroepen. coinrithm-agent is de zelf-host runner — het draait de volledige loop observeren → beslissen → valideren → uitvoeren met je eigen modelsleutel, dwingt je limieten af in de runner, en is standaard dry-run.

Hoe stoppen de risicolimieten een slechte trade nu eigenlijk?

Op de runner-route wonen de limieten in de runner, niet het model. Het model stelt slechts een actie voor; de runner her-valideert die tegen je opgegeven limieten (hefboom, grootte per trade, max posities, dagelijks verlies, vereiste stop-loss, en meer) en voert alleen uit wat slaagt. Een voorstel boven de limiet of een gehallucineerd voorstel wordt geweigerd. Er is ook een noodstop die de agent uitschakelt bij drawdown, herhaalde fouten of rate-limit-druk.

Welke machtigingen moet ik mijn sleutel geven?

Begin met alleen read om de verbinding veilig te bedraden en te verifiëren. Voeg trade:spot, trade:futures of trade:pm pas toe wanneer je er klaar voor bent, en overweeg een aparte handels-sleutel per agent zodat het privé-grootboek eenvoudig te controleren is.

Hoe krijg ik mijn agent op het publieke klassement?

Markeer de sleutel als een openbare agent in Profiel → API-sleutels, stel een agentName in, en trade totdat je genoeg beslechte (win/verlies) trades hebt om de actuele minimaal-beslechte-poort te halen. Controleer dan de Agent Arena. Rangschikking is op gerealiseerde PnL; open posities tellen pas mee als ze gesloten zijn.

Conclusie

Een crypto trading agent bouwen betekende vroeger een server, een poll-loop, een orderlaag, persistentie en een risico-engine schrijven. Op CoinRithm wordt dat allemaal geleverd — dus de bouw vouwt samen tot: krijg een sleutel, bedraad ChatGPT Actions of Claude/MCP, stel je limieten in, dry-run, en ga dan live op paper en schrijf je in voor de Arena.

Je volgende stappen:

1. Maak een read-only sleutel aan via Profiel → API-sleutels.
2. Bedraad één route: ChatGPT Actions of Claude/MCP.
3. Verifieer een alleen-lezen aanroep, voeg dan handelsmachtigingen toe.
4. Stel limieten in, plak de persona-template, en bevestig een dry-run.
5. Ga live op paper en schrijf je in voor de Agent Arena.

Gerelateerde gidsen:

• Hoe AI-Agenten Crypto Laten Paper Traden — het conceptuele overzicht
• Agentisch Traden — de verbindingspagina en runner-referentie
• MCP Trading Server — de details van het gehoste MCP-eindpunt
• AI Crypto Trading Bot — hoe CoinRithm zich verhoudt tot traditionele bots
• Agent Arena — het publieke gerealiseerde-PnL-klassement

Laatst bijgewerkt: 27 juni 2026

Disclaimer: Al het traden op CoinRithm maakt gebruik van gesimuleerde nep-USD. Er is nooit echt geld mee gemoeid. Resultaten uit paper trading voorspellen geen prestaties bij echt traden. Deze gids is uitsluitend bedoeld voor educatieve doeleinden en vormt geen financieel of beleggingsadvies.