Veel mensen kennen AI inmiddels als een chatvenster: je typt een vraag, je krijgt tekst terug, je kopieert die ergens naartoe. Een terminal-agent werkt anders. In plaats van alleen antwoorden te geven, kríjgt deze AI toegang tot je bestanden, je versiebeheer en je commandoregel — en doet hij het werk zelf. Hij leest je project, bedenkt een aanpak, voert commando's uit en controleert achteraf of het klopt.
Dat verschil — van praten over het werk naar het werk uitvoeren — is de kern van wat we een terminal-agent of AI-CLI noemen. In dit hoofdstuk leggen we het fundament: wat zo'n agent is, hoe hij verschilt van de AI die je al kent, en waarom dit ook telt voor wie nooit een regel code schrijft.
Key Takeaways
- •Een terminal-agent (AI-CLI) draait in de command line en kan zelf bestanden lezen, code wijzigen, commando's uitvoeren en met git werken — niet alleen tekst genereren.
- •Het verschil met een chatbot zit in de agentic loop: context verzamelen, actie ondernemen, resultaat verifiëren, en die cyclus herhalen tot de taak af is.
- •IDE-autocomplete vult regels aan binnen één bestand; een terminal-agent overziet je hele project en werkt over meerdere bestanden tegelijk.
- •De grote spelers zijn Claude Code (Anthropic), Codex CLI (OpenAI), Gemini CLI (Google) en open-source opties zoals Aider.
- •Het is niet alleen voor developers: bij Anthropic gebruiken marketing-, legal- en designteams deze tools voor data-bewerking, prototypes en automatisering.
Van antwoord geven naar werk uitvoeren
Een gewone chatbot is een woordmachine. Je stelt een vraag, het achterliggende taalmodel voorspelt het meest waarschijnlijke antwoord, en je krijgt tekst. Wil je dat antwoord ergens gebruiken, dan doe je dat zelf: kopiëren, plakken, testen, corrigeren.
Een terminal-agent voegt daar handen aan toe. Naast het taalmodel dat redeneert, krijgt de agent gereedschap waarmee hij kan handelen. In de officiële documentatie van Claude Code wordt dat treffend de agentic harness genoemd: de laag rond het model die het tools, geheugen en een uitvoeromgeving geeft, en daarmee een taalmodel verandert in een werkende agent (code.claude.com).
Concreet betekent dat: de agent kan bestanden openen en lezen, code aanpassen, nieuwe bestanden maken, in de terminal commando's draaien, tests uitvoeren, met git werken en zelfs het web raadplegen. Elk van die acties levert nieuwe informatie op, die de agent gebruikt om de volgende stap te bepalen. Hij praat niet over het werk — hij voert het uit, onder jouw toezicht.
De agentic loop: lezen, plannen, uitvoeren, verifiëren
Wat een terminal-agent fundamenteel onderscheidt, is de manier waarop hij werkt. Geen enkele actie staat op zichzelf; ze vormen een cyclus. De documentatie van Claude Code beschrijft drie fasen die in elkaar overlopen: context verzamelen, actie ondernemen en resultaat verifiëren (code.claude.com).
Een voorbeeld maakt het tastbaar. Vraag je een agent om falende tests te repareren, dan ziet de loop er ongeveer zo uit:
- •De testsuite draaien om te zien wat er faalt.
- •De foutmeldingen lezen.
- •Zoeken naar de relevante bronbestanden.
- •Die bestanden lezen om de code te begrijpen.
- •De bestanden aanpassen om het probleem op te lossen.
- •De tests opnieuw draaien om te controleren of het werkt.
Faalt stap zes, dan begint de cyclus opnieuw. De agent corrigeert zichzelf en koppelt tientallen acties aan elkaar tot de taak af is. Dit zelfcorrigerende karakter is precies wat een AI-agent onderscheidt van een eenmalige tekstgenerator.
Jij blijft in de loop
Autonoom betekent niet onbewaakt. Je kunt op elk moment ingrijpen om de agent een andere richting op te sturen of extra context te geven. En de meeste tools werken standaard met een vraag-en-toestemmingsmodel: voordat de agent een bestand wijzigt of een commando uitvoert, vraagt hij om akkoord. Claude Code kent bijvoorbeeld een plan mode waarin de agent alleen leesrechten gebruikt en een plan voorlegt voordat er iets verandert (code.claude.com). Hoe je die controle goed inricht, behandelen we in Veilig werken met AI-agents.
Hoe verschilt dit van een chatbot en van IDE-autocomplete?
Het is makkelijk om een terminal-agent te verwarren met twee dingen die je waarschijnlijk al kent. Het onderscheid is belangrijk, want het bepaalt waarvoor je het inzet.
Tegenover een chatbot (zoals ChatGPT of Claude in een browservenster): een chatbot ziet alleen wat jij in het gesprek plakt en levert alleen tekst terug. Een terminal-agent ziet je hele project op de schijf, voert acties uit en ondervindt de gevolgen van die acties — een test die slaagt of faalt, een commando dat een fout teruggeeft. Die feedbacklus is er bij een chatbot niet.
Tegenover IDE-autocomplete (zoals de regel-voor-regel suggesties in een editor): autocomplete werkt binnen het bestand waar je cursor staat en helpt je sneller typen terwijl jij de regie houdt over elke regel. Een terminal-agent neemt een hele taak aan, overziet meerdere bestanden tegelijk en maakt samenhangende wijzigingen door je project heen. De officiële docs vatten het samen: dit is anders dan inline assistenten die alleen het huidige bestand zien (code.claude.com).
Tools als Cursor zitten daar overigens tussenin: een editor met agent-functies. De grens vervaagt, maar het onderscheid in werkingsmodel — alleen tekst, regel-aanvulling, of een complete taak-loop — blijft de meest bruikbare manier om erover na te denken.
Waarom de verschuiving naar de terminal?
De command line is geen toevallige keuze. De terminal is precies de plek waar de echte hefbomen van softwareontwikkeling samenkomen: het bestandssysteem, versiebeheer met git, het draaien van tests, builds en deployments. Wie toegang heeft tot de terminal, heeft toegang tot vrijwel alles wat je met een project kunt doen.
Daar zit de winst. Door de agent in die omgeving te plaatsen, kan hij niet alleen voorstellen dóen maar ze ook uitvoeren én controleren. De vijf categorieën gereedschap die Claude Code beschrijft, laten dat goed zien: bestandsbewerkingen, zoeken, uitvoeren (shell-commando's, tests, git), web, en code-intelligentie (code.claude.com). Het is geen toeval dat al die hefbomen van oudsher via de terminal lopen.
Een tweede reden is geheugen en context. Een terminal-agent kan een projectspecifiek instructiebestand inlezen en zo elke sessie weten wat de conventies en achtergrond van jouw project zijn. Daarbovenop bouwen veel tools voort met uitbreidingen zoals MCP, waarmee je de agent koppelt aan externe diensten en databronnen.
De hoofdrolspelers, kort gepositioneerd
Het veld telt een handvol serieuze opties. We zetten ze hier alleen neer; een echte afweging — wat past bij jouw team, budget en stack — staat in De juiste AI-CLI kiezen.
- •Claude Code van Anthropic — een agentic coding-tool die in je terminal leeft en je codebase begrijpt (github.com/anthropics/claude-code). Wil je hier dieper in, dan is onze Claude Code masterclass het startpunt.
- •Codex CLI van OpenAI — omschreven als een lichtgewicht coding-agent die lokaal in je terminal draait, open source onder Apache-2.0 (github.com/openai/codex).
- •Gemini CLI van Google — een open-source AI-agent die Gemini rechtstreeks naar je terminal brengt, eveneens onder Apache-2.0 (github.com/google-gemini/gemini-cli).
- •Aider — open-source "AI pair programming in your terminal", werkt met vrijwel elk model en commit wijzigingen automatisch via git (github.com/Aider-AI/aider).
De gemene deler: ze draaien in de terminal, ze werken met je bestanden en git, en ze volgen dezelfde agentic loop. De verschillen zitten in het onderliggende model, de prijs, de openheid en het ecosysteem.
En wat betekent dit als je geen developer bent?
Hier wordt het interessant voor een MT. De reflex is om terminal-agents in het hokje "iets voor het engineering-team" te plaatsen. Dat is te smal. Anthropic publiceerde hoe hun eigen niet-technische teams Claude Code inzetten, en de voorbeelden zijn herkenbaar voor elke bedrijfsfunctie (claude.com/blog):
- •Het groei-marketingteam verwerkt CSV-bestanden met honderden advertenties om onderpresteerders te identificeren en varianten te genereren, en bouwde een Figma-plugin die tot honderd advertentievarianten maakt door koppen en beschrijvingen te wisselen.
- •Het juridische team bouwde een prototype-keuzemenu ("phone tree") om collega's bij de juiste advocaat te laten uitkomen — zonder ontwikkelaars in te schakelen.
- •Datawetenschappers voeren hun hele codebase aan de agent om datapijplijnen en afhankelijkheden te begrijpen, en bouwen visualisaties zonder zelf de code te doorgronden.
- •Het security-team laat Claude Code meerdere documentatiebronnen samenvoegen tot markdown-runbooks en troubleshooting-gidsen, en lost incidenten bij het debuggen ongeveer drie keer sneller op.
De rode draad: deze mensen schrijven geen software in de klassieke zin. Ze beschrijven in gewone taal wat ze willen, en de agent doet het uitvoerende werk — data opschonen, een wegwerp-prototype bouwen, een terugkerende klus automatiseren. Voor operations en marketing opent dat een categorie taken die voorheen óf handwerk was óf een ticket bij IT.
Dat betekent niet dat je morgen je hele afdeling de terminal in stuurt. Het betekent dat de drempel om een proces te automatiseren of een idee te valideren fors lager ligt dan je denkt — mits je weet wat de tool wel en niet hoort te doen.
Het fundament staat — hoe nu verder?
Je weet nu wat een terminal-agent is: geen chatbot en geen autocomplete, maar een AI die binnen de agentic loop zelfstandig leest, plant, uitvoert en verifieert, met jou aan het stuur. Je kent de belangrijkste spelers en je ziet dat de toepassing breder is dan alleen code.
De logische volgende vraag is: hoe doe je dit verantwoord? Een agent met toegang tot je bestanden en commandoregel is krachtig, en dat vraagt om duidelijke grenzen. Lees daarom verder in Veilig werken met AI-agents, waar we toestemmingen, sandboxing en het draaien van agents in afgeschermde of cloud-omgevingen behandelen. Daarna helpt De juiste AI-CLI kiezen je bij de concrete afweging, en sluit AI-CLI's invoeren in je team het verhaal af met de organisatorische kant.