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 het primaire distributiekanaal voor software. Ze browsen niet op je marketingsite of bekijken je demovideo. Ze klikken niet door een onboarding-flow. Ze roepen je CLI aan, raken je MCP-server, of lezen je docs programmatisch. Als geen van die oppervlakken bestaat, verschijnt je product simpelweg niet in hun wereld.

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. Die agents hebben gestructureerde, programmatische toegang nodig tot de tools waarmee ze werken. Je mooie React-dashboard? Waardeloos voor een agent die om 3 uur 's nachts data in een pipeline probeert te trekken. Agents zien niet je GUI, ze zien de accessibility tree . Wat ze nodig hebben is een CLI, een MCP-endpoint, documentatie die ze daadwerkelijk kunnen parsen.

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 elk productteam nu zou moeten beantwoorden. Ik heb het uitgebreid tot de vier oppervlakken die bepalen of agents je product kunnen ontdekken en gebruiken:

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 is de universele standaard voor AI-naar-tool integratie. Elk groot AI-platform ondersteunt het. Claude, ChatGPT, Gemini, Cursor, VS Code en duizenden meer. Een MCP-server maakt van je product een tool die elke AI-assistent kan ontdekken en gebruiken.

MCP-discovery toevoegen via /.well-known/mcp.json betekent dat AI-clients automatisch je endpoints kunnen vinden. Onze scanner controleert dit in het MCP Discovery checkpoint (4.3), een van de agent-protocolsignalen die direct bepalen of agents je product kunnen vinden.

3. Machine-Leesbare Documentatie

Agents kunnen niet je tutorialvideo's bekijken of visueel door je getting-started gids bladeren. Ze hebben documentatie nodig in formaten die ze programmatisch kunnen parsen. 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. Onze scanner controleert ook op OpenAPI-specificaties (checkpoint 4.5) en agents.json (checkpoint 4.6), allemaal machine-leesbare formaten die je product vindbaar maken.

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 van deze geeft agents een gestructureerde manier om je product te ontdekken en ermee te interacteren.

De Agent Protocols categorie van onze scanner (gewogen op 15% van de totaalscore) evalueert al deze: WebMCP declaratief en manifest-ondersteuning, A2A Agent Card, MCP-discovery, OpenAPI, agents.json, formulierkwaliteit en interactieve oppervlaktedekking. Deze signalen bepalen direct of AI-agents je product kunnen vinden en gebruiken.

De Concurrentiedynamiek Is Meedogenloos

Stel je voor: je concurrent lanceert een MCP-server. Nu kan elke Claude Code-gebruiker, elke Cursor-sessie, elke autonome pipeline hun product ontdekken en gebruiken. Geen mens bezoekt de website. Geen verkoopgesprek. Geen onboarding-email. De agent vindt de tool, leest het schema en begint te gebruiken.

We kennen deze film. Twintig jaar geleden vingen bedrijven die vroeg in SEO investeerden organisch verkeer dat jarenlang groeide. Alle anderen besteedden het volgende decennium aan het kopen van advertenties om hetzelfde publiek te bereiken. Agent-toegankelijkheid volgt hetzelfde draaiboek, behalve dat de tijdlijn is samengedrukt van jaren tot maanden.

Goldman projecteert $780 miljard aan applicatiesoftware tegen 2030, waarbij agents 60%+ van die economie veroveren. De winstpool verschuift van per-seat abonnementen naar workflow-completion pricing. Als agents je product niet kunnen bereiken, doe je niet mee aan die economie.

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 47 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 47 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

De signalen die Karpathy identificeert mappen direct op wat onze scanner meet over vijf gewogen categorieën. Zo past de "Build for Agents" checklist bij onze 47 checkpoints:

De Paradigmaverschuiving Is Al Hier

Niets hiervan is speculatief. Het gebeurt al. Zoals een reactie op Karpathy's post het verwoordde: "Agents browsen niet, ze voeren uit." We hebben een decennium alles visueel gemaakt omdat knoppen de toekomst leken. In 2026 hebben de krachtigste gebruikers van je product geen ogen.

Het web is gebouwd voor menselijke browsers. De volgende laag wordt gebouwd voor agents. Producten die CLI's, MCP-servers en gestructureerde docs blootstellen pikken nu al distributie op via agent-workflows. Distributie die hun marketingteam nooit hoefde te orkestreren. Producten die alleen een GUI bieden vallen stilletjes uit het gesprek.

Karpathy sloot af met drie woorden: "Build. For. Agents." Het is geen slogan. Het is het nieuwe minimum viable product.

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