Build for Agents: Waarom CLI's het Nieuwe Distributiekanaal Zijn

Andrej Karpathy plaatste vorige week iets dat meer aandacht verdient dan de gebruikelijke Twitter-discussie. In een post die bijna 2 miljoen views trok, betoogde de voormalig Tesla AI-directeur dat CLI's interessant zijn juist omdat het "legacy" technologie is. Niet ondanks dat het oud is, juist daarom. stdin/stdout, flags, JSON-output, pipes. De Unix-filosofie heeft per ongeluk de perfecte interface voor AI-agents gebouwd, tientallen jaren voordat iemand wist dat ze zouden bestaan.

Het echte punt ging niet over CLI's. Het was een vraag aan elke productbouwer: "Als je een product of dienst hebt, denk dan: kunnen agents er toegang toe krijgen en het gebruiken?" Als het antwoord nee is, heb je een probleem. Je product wordt onzichtbaar voor misschien wel het snelst groeiende distributiekanaal dat software ooit heeft gezien. Dit is de kernvraag achter AI agent readiness .

Karpathy's These: Legacy Is het Nieuwe Voordeel

De demo was simpel maar veelzeggend. Karpathy vroeg Claude om de Polymarket CLI te installeren (een in Rust gebouwde command-line tool voor het bevragen van voorspellingsmarkten) en om "willekeurige dashboards, interfaces of logica" te bouwen. Drie minuten later had Claude een werkend terminal-dashboard met de hoogst verhandelde Polymarket-contracten en hun 24-uurs prijsveranderingen.

Geen API-integratiecode. Geen auth-flow. Geen SDK-setup. Een CLI die gestructureerde data uitvoert, en een agent die weet wat ermee te doen.

Daarna deed hij hetzelfde met de GitHub CLI. Claude navigeerde repos, inspecteerde issues, reviewde PR's, las code. De agent reeg bestaande command-line tools aaneen tot workflows waar een developer uren over zou doen om handmatig te koppelen.

Denk na over waarom dit werkt. CLI-tools volgen conventies die al tientallen jaren niet veranderd zijn. Ze nemen flags. Ze spuwen tekst of JSON uit naar stdout. Ze componeren via pipes. Ze hebben --help flags die hun eigen mogelijkheden beschrijven. Dat is in essentie alles wat een AI-agent nodig heeft: ontdekbaarheid, gestructureerde I/O, composeerbaarheid. Zonder een UI te hoeven screenshotten of een DOM te hoeven parsen.

Agents Zijn het Nieuwe Distributiekanaal

Zoom uit van de CLI-invalshoek en het plaatje wordt groter. Agents worden een belangrijk distributiekanaal voor software. Sommige gebruiken gestructureerde interfaces zoals CLI's, MCP-servers en machine-leesbare documentatie. Browseragents kunnen ook gerenderde marketingsites en onboarding-flows navigeren. Producten moeten daarom zowel programmatische als browsergebaseerde toegang ondersteunen.

En die verschuiving ging snel. MCP ging van nul naar 97 miljoen maandelijkse SDK-downloads in twaalf maanden. Meer dan 10.000 actieve servers draaien. OpenAI, Google DeepMind, Microsoft, Cloudflare, ze adopteerden het allemaal. Anthropic doneerde MCP in december 2025 aan de Linux Foundation, niet als gebaar maar omdat de standaard al had gewonnen. Een MCP-server draaien begint te voelen als een webserver draaien. Het is gewoon wat je doet.

85% van de enterprises zal naar verwachting AI-agents ingezet hebben. Gestructureerde, programmatische toegang is waardevol voor betrouwbare automatisering. Tegelijk blijkt dat browseragents de DOM, accessibility tree en screenshots kunnen combineren wanneer ze een GUI gebruiken. Een CLI, MCP-endpoint of machine-leesbare documentatie vult die browserinterface aan met een meer deterministisch pad.

Waarom CLI's Per Ongeluk Perfect Zijn voor AI Agents

Er is een reden waarom Karpathy "legacy" tussen aanhalingstekens zette. Hij zegt niet dat CLI's verouderd zijn. Hij zegt het tegenovergestelde. De dingen die ze oud maken (stabiele conventies, tekst-gebaseerde I/O, voorspelbaar gedrag) zijn precies de dingen die ze perfect maken voor agents.

Justin Poehnelt, die Google Workspace-tooling bouwt, publiceerde onlangs een gedetailleerde gids over het ontwerpen van CLI's specifiek voor AI-agents. Zijn kerninzicht bleef bij me hangen: "Human DX optimaliseert voor ontdekbaarheid en vergeving. Agent DX optimaliseert voor voorspelbaarheid en verdediging in de diepte." Dat zijn wezenlijk verschillende ontwerpdoelen.

Zijn praktische aanbevelingen omvatten het accepteren van ruwe JSON-payloads als eersteklas input (niet alleen gemaksflags), het blootstellen van runtime-querybare schema's zodat agents mogelijkheden kunnen introspecteren zonder docs te laden, het implementeren van field masks om responsgrootte te beperken en tokenbudget te besparen, en het toevoegen van --dry-run flags zodat agents acties kunnen valideren voordat ze worden uitgevoerd.

De Vier Agent-Toegankelijke Oppervlakken

Karpathy's post eindigt met een checklist die het uitbreiden waard is. Ik zie vier oppervlakken waarop producten machineleesbare paden voor compatibele agents kunnen publiceren:

1. Command-Line Interface (CLI)

Een CLI is het meest directe pad voor agents om met je product te interacteren. Als je product een API heeft, zou het een CLI moeten hebben. Punt. De Polymarket CLI die Karpathy demonstreerde is gebouwd in Rust. Agents kunnen markten bevragen, trades plaatsen en data ophalen, allemaal vanuit de terminal zonder overhead.

De belangrijkste ontwerpprincipes voor agent-vriendelijke CLI's. Standaard JSON uitvoeren wanneer stdout geen TTY is, een --output json flag aanbieden, ruwe payload-input ondersteunen naast gemaksflags, en de CLI zelfbeschrijvend maken via schema-introspectiecommando's.

2. MCP Server

Het Model Context Protocol definieert een gestructureerde manier om AI-systemen met externe tools te verbinden. Verschillende grote clients ondersteunen MCP. Een server publiceert een compatibele toolinterface, terwijl clientondersteuning, configuratie en autorisatie nog steeds bepalen of die wordt gebruikt.

MCP-discovery toevoegen via /.well-known/mcp.json publiceert endpointmetadata op een bekende locatie. Onze scanner registreert of dat discovery-document aanwezig en geldig is als Agent Protocols-signaal. Dat bewijst niet dat een client het endpoint heeft ontdekt of gebruikt.

3. Machine-Leesbare Documentatie

Tutorialvideo's en interactieve getting-started gidsen zijn minder deterministisch voor geautomatiseerde retrieval. Voeg documentatie toe die agents direct kunnen parsen, zoals Markdown-bestanden, llms.txt, OpenAPI-specificaties en gestructureerde kennisbanken.

De llms.txt standaard (ons checkpoint 1.4) is specifiek hiervoor gemaakt. Het is een enkel bestand in de root van je domein dat AI-modellen vertelt wat je site doet, welke content beschikbaar is en hoe ze kunnen navigeren. Een robots.txt voor AI-begrip in plaats van crawling, al bepalen clients zelf of ze het lezen. Onze scanner controleert ook op OpenAPI-specificaties en agents.json als gepubliceerd machineleesbaar interfacesignaal.

4. Agent Protocol Endpoints

Naast MCP omvat de opkomende agent-protocolstack WebMCP voor browsergebaseerde agent-interacties, Google's A2A voor agent-naar-agent communicatie, en agents.json voor het adverteren van wat je AI-agents kunnen. Elk publiceert of biedt gestructureerde interfacemetadata; ondersteuning en gebruik verschillen per client.

De stabiele-kernbijdrage van de categorie Agent Protocols meet OpenAPI-documentatie en bruikbaarheid, live verificatie van OpenAPI en MCP, en gestructureerde API-foutreacties. Een A2A Agent Card is opkomend bonusbewijs en heeft geen invloed op de hoofdscore. WebMCP is experimenteel bewijs dat niet meetelt voor de score. Daaronder vallen formulierkwaliteit en bewijs over interactieve oppervlakken. Deze checks registreren gepubliceerde signalen, niet of een agent het product zal gebruiken.

De Concurrentiedynamiek Is Meedogenloos

Een MCP-server geeft compatibele clients een gestructureerd integratiepad. Dat pad kun je testen, documenteren en onderhouden, maar de aanwezigheid zegt niet hoeveel clients het ontdekken of succesvol gebruiken.

We kennen deze film. Twintig jaar geleden vingen bedrijven die vroeg in SEO investeerden organisch verkeer dat jarenlang groeide. Die geschiedenis verklaart waarom teams vroeg in machineleesbare interfaces kunnen investeren, maar legt geen adoptiecurve voor agentinterfaces vast.

Goldman projecteert $780 miljard aan applicatiesoftware tegen 2030, waarbij agents 60%+ van die economie veroveren. Die prognose geeft aanleiding om met machineinterfaces te experimenteren, maar stelt niet vast welke producten agents zullen gebruiken.

Wat Nu Te Doen

Genoeg over waarom. Dit is wat je concreet moet doen, op volgorde van impact:

1. Lever een CLI met JSON-output. Als je product een API heeft, verpak het in een CLI die JSON-input accepteert en gestructureerde JSON uitvoert. Dit is het pad met de minste weerstand naar agent-toegankelijkheid. Gebruik --output json of detecteer automatisch wanneer stdout geen TTY is.
2. Deploy een MCP-server. Gebruik de officiële TypeScript of Python SDK. Stel je kernacties beschikbaar als MCP-tools. Voeg /.well-known/mcp.json toe voor discovery.
3. Exporteer docs in markdown. Maak een llms.txt bestand in de root van je domein. Publiceer een OpenAPI-spec. Zorg dat je documentatie beschikbaar is als platte tekst of markdown, niet alleen als gerenderde HTML.
4. Voeg agents.json toe. Adverteer je AI-agent mogelijkheden met een machine-leesbaar agents.json bestand. Dit vertelt andere agents wat je product kan en hoe ze ermee kunnen interacteren.
5. Meet je agent readiness. Scan je site om te zien waar je staat over alle 70 checkpoints, van crawlertoegang en gestructureerde data tot agent-protocollen en security-headers.

We Hebben Zelf Ook een CLI Gebouwd: @isagentready/cli

Ik doe wat ik predik. Naast onze MCP-server en Claude Code skill hebben we @isagentready/cli uitgebracht, een command-line tool die elke website scant op AI agent readiness, direct vanuit je terminal. Het implementeert elk agent-vriendelijk CLI-patroon dat in deze post wordt besproken.

Installeer het globaal of draai het direct met npx:

# Globaal installeren
npm install -g @isagentready/cli

# Of direct draaien
npx @isagentready/cli scan example.com

Eén commando geeft je scores, lettercijfers en een categorie-uitsplitsing over alle 70 checkpoints:

A+  example.com  98/100
  Scanned in 1.7s

  Categories

  ███████████████ 100%  AI Content Discovery (30% weight)
  █████████████░░  89%  AI Search Signals (20% weight)
  ███████████████ 100%  Content & Semantics (20% weight)
  ███████████████ 100%  Agent Protocols (15% weight)
  ███████████████ 100%  Security & Trust (15% weight)

Voeg --verbose toe om elk individueel checkpoint te zien, of --json voor machine-leesbare output. Maar hier wordt het interessant voor agents: de CLI detecteert automatisch wanneer stdout wordt gepiped en schakelt dan vanzelf over naar JSON:

# Gepiped → auto-JSON, geen flag nodig
isagentready results example.com | jq '.overall_score'

# Field masks om tokenbudget te besparen
isagentready results example.com --fields domain,overall_score,letter_grade

# Bekijk de rankings
isagentready rankings --grade high --json

# Stream alle rankings als NDJSON
isagentready rankings --page-all --fields domain,overall_score | wc -l

# Valideer zonder de API te raken
isagentready scan example.com --dry-run

# Runtime schema-introspectie voor agents
isagentready schema scan

Elk patroon dat Justin Poehnelt aanraadde zit erin. Auto-detectie van non-TTY modus, expliciete --output json|text override, field masks voor context window-beperkingen, --dry-run voor validatie, NDJSON-streaming en een schema-commando voor runtime-introspectie. De CLI bevat ook een CONTEXT.md bestand, gestructureerde instructies die AI-agents kunnen lezen om conventies en invarianten te begrijpen.

Het resultaat: elke AI-agent (Claude Code, Cursor, een custom pipeline) kan de CLI installeren en direct websites scannen, scores ophalen en rankings opvragen zonder één documentatiepagina te lezen. Drie toegangspaden naar dezelfde data: de webscanner , de CLI en de MCP-server . Mensen krijgen de GUI, agents krijgen de interface die voor hen werkt.

Hoe Onze Scanner Agent-Toegankelijkheid Meet

Delen van Karpathy's checklist overlappen met gepubliceerde signalen die de scanner meet. Deze tabel beschrijft die beperkte aansluiting:

De Paradigmaverschuiving Is Al Hier

Deze interfaceformaten bestaan vandaag en hun gepubliceerde signalen zijn meetbaar. Werkelijke discovery, interactie en taaksucces vereisen runtimebewijs buiten de statische score.

Het web is gebouwd voor menselijke browsers en geautomatiseerde clients gebruiken meerdere modaliteiten. Producten kunnen CLI's, MCP-servers en gestructureerde docs naast een GUI aanbieden zonder een interface als bewijs van adoptie te behandelen.

Karpathy sloot af met drie woorden: "Build. For. Agents." Het is een bruikbare ontwerpvraag, geen gemeten voorspelling over productgebruik.

Bronnen

• Andrej Karpathy over CLI's als agent-native interfaces — X - Originele post over CLI's als "legacy" technologie voor AI-agents (feb 2026)
• You Need to Rewrite Your CLI for AI Agents — Justin Poehnelt - Gedetailleerde gids over agent-first CLI-ontwerppatronen
• web2cli: Every Website Is a Unix Command — GitHub - CLI-tool die websites omzet naar parseerbare commando's voor agents en mensen
• Introductie Polymarket CLI — Suhail Kakar op X - De in Rust gebouwde CLI die Karpathy's post inspireerde
• @isagentready/cli — GitHub - Open-source CLI voor het scannen van AI agent readiness vanuit de terminal
• IsAgentReady: Wat is MCP? Het Model Context Protocol voor AI Agents
• IsAgentReady: Wat is WebMCP en waarom heeft je website het nodig
• IsAgentReady: Wat is Google's A2A Protocol? Agent-naar-Agent Communicatie
• IsAgentReady: Wat is agents.json? AI Agent-mogelijkheden adverteren
• IsAgentReady: De Staat van AEO — Belangrijkste Inzichten uit Vercel's 2026 Rapport