Het woord "agent" klinkt alsof je code schrijft die zelfstandig je e-mail beheert, je agenda plant en ondertussen je belastingaangifte indient. De werkelijkheid in 2025 is wat bescheidener, maar daarom niet minder interessant. Drie frameworks die vorig jaar serieuze tractie kregen — CrewAI, Microsoft AutoGen en Hugging Face smolagents — laten goed zien wat "agentisch" vandaag concreet betekent, en waar de grenzen nog liggen.

Wat "agent" eigenlijk betekent in 2025

Een AI-agent is in essentie een LLM die een loop uitvoert: redeneer → kies een actie → voer die actie uit → verwerk het resultaat → herhaal. Het verschil met een gewone chatbot is dat de model zelf beslist welke stap volgt, en dat acties echt iets doen — een bestand lezen, een API aanroepen, code uitvoeren. Hoe lang die loop duurt en hoe autonoom die is, verschilt enorm per implementatie.

In de praktijk werken agents het best voor taken van minder dan tien stappen met duidelijk afgebakende tools. Zodra je een agent vraagt om iets te doen dat vijftig beslissingen vereist en waarbij fouten cascaderen, loopt het mis. Een enquête onder 306 agent-practitioners bevestigt: betrouwbaarheid is de grootste drempel voor adoptie, niet gebrek aan capaciteit.

Drie hoofdparadigma's zijn er momenteel: tool-use (de agent roept functies aan en integreert de resultaten), multi-agent (meerdere gespecialiseerde agenten werken samen) en code-as-action (de agent schrijft Python-code die in een sandbox wordt uitgevoerd — flexibeler, maar vereist meer vertrouwen).

"Een agent die tien stappen zelfstandig afwerkt zonder te hallucineren is indrukwekkend. Een agent die honderd stappen autonoom uitvoert is voorlopig sciencefiction voor de meeste toepassingen."

CrewAI: rollen, taken en een beetje theater

CrewAI positioneert zich als het meest productierijpe van de drie. Het kernidee is dat je een crew samenstelt van agenten die elk een rol krijgen — denk aan "Senior onderzoeker", "Schrijver", "Redacteur" — en een taak toegewezen krijgen. De orchestrator (de Crew zelf) bepaalt wie wanneer aan de beurt is.

Concreet definieer je in Python een Agent met een role, een goal en een backstory. Die backstory voelt een beetje als roleplay, maar is functioneel: het beïnvloedt hoe het model reageert en welke toon het aanslaat. Vervolgens maak je een Task per stap, koppel je die aan een agent, en start je de crew. Uitvoering is standaard sequentieel, maar je kunt ook parallel of hiërarchisch werken.

from crewai import Agent, Task, Crew

researcher = Agent(role="Tech researcher",
                   goal="Find recent Belgian AI policy news",
                   backstory="Experienced journalist...")

task = Task(description="Summarize AI Act implementation in Belgium",
            agent=researcher)

crew = Crew(agents=[researcher], tasks=[task])
result = crew.kickoff()

Wat CrewAI in 2026 onderscheidt, is de volwassenheid van de infrastructuur. CrewAI Flows bieden event-driven orchestratie, er is native MCP-ondersteuning, A2A-communicatie en observability via event emitters. Met meer dan 12 miljoen dagelijkse agent-uitvoeringen is het geen hobbyproject meer. De keerzijde: voor een simpele taak voelt het kader van rollen en crews als overkill. CrewAI schittert wanneer je workflow meerdere specialisaties vereist die van elkaar afhankelijk zijn.

AutoGen: multi-agent graphs en een stille terugtrekking

Microsoft AutoGen was jarenlang dé referentie voor multi-agent coördinatie. Het onderscheidende idee: agenten communiceren via een chat-interface, waarbij een UserProxy-agent namens de gebruiker communiceert met een AssistantAgent. Dat klinkt simpel, maar het maakt het mogelijk om conversaties te laten lopen totdat een taak klaar is, met menselijke goedkeuring op kritieke stappen.

In 2025 nam Microsoft een opvallende stap: AutoGen wordt samengevoegd met Semantic Kernel tot het Microsoft Agent Framework, dat op 1 oktober 2025 in publieke preview ging. AutoGen zelf is in maintenance mode — kritieke bugfixes en securitypatches worden nog gedaan, maar nieuwe features komen niet meer. De 1.0 GA van het Agent Framework was gepland voor Q1 2026.

Het Agent Framework erft AutoGen's sterkste kant: een graph-based workflow API waarmee je complexe, meerstaps workflows definieert met sequentiële, parallelle of hybride uitvoeringspaden. Semantic Kernel brengt de productie-integraties mee — Azure-diensten, enterprise AI-pijplijnen, .NET-ondersteuning. Voor Python-gebruikers die vandaag beginnen is de vraag reëel: bouwen op het vertrouwde AutoGen 0.4, of meteen inzetten op het nieuwe Agent Framework?

Het antwoord hangt af van je context. Voor een bestaand AutoGen-project: ga niet migreren tenzij je actief nieuwe features nodig hebt. Voor een nieuw project in een Microsoft-ecosysteem: kijk naar Agent Framework. Voor iemand die gewoon lokaal wil experimenteren met multi-agent zonder Azure-afhankelijkheid: kijk naar de andere twee opties.

smolagents: minimaal, leesbaar, verrassend krachtig

Hugging Face lanceerde smolagents begin 2025 met een uitgesproken filosofie: de kern van een agent-framework past in zo'n 1.000 regels code. Geen verborgen magie, geen lagen van abstractie die je niet begrijpt. Het idee is dat je de broncode kunt lezen en begrijpen — en dat je dat ook moet kunnen als je agents inzet in productie.

Het meest opvallende kenmerk is de code-as-action-aanpak. Waar andere frameworks de agent functies laten aanroepen via JSON-schemas, laat smolagents de agent Python-code schrijven. Die code wordt uitgevoerd (lokaal of in een sandbox), het resultaat komt terug, en de agent gaat verder. Dit is flexibeler dan een vaste toolset — de agent kan variabelen onthouden over stappen heen, logica combineren, en tools samenstellen.

from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel

agent = CodeAgent(
    tools=[DuckDuckGoSearchTool()],
    model=HfApiModel("Qwen/Qwen2.5-72B-Instruct")
)

agent.run("Wat zijn de drie beste NAS-opties voor een thuisserver in 2026?")

smolagents is model-agnostisch: je kunt Hugging Face-modellen gebruiken, maar ook OpenAI, Anthropic, of een lokaal model via Ollama of LiteLLM. Dat maakt het ideaal voor wie wil experimenteren met open-source LLMs zonder vendor lock-in. De GitHub-repo groeide van 3.000 naar meer dan 26.000 sterren in iets meer dan een jaar — een teken dat de minimalistische aanpak aanslaat bij developers die moe zijn van overengineering.

Voor sandbox-uitvoering zijn er meerdere opties: E2B, Modal, Docker, of een WebAssembly-sandbox via Pyodide+Deno voor de paranoia-variant. Je kunt tools en agents delen via de Hugging Face Hub, wat een groeiend ecosysteem van herbruikbare componenten oplevert.

MCP en lokale modellen: de stille gamechanger

Naast de frameworks zelf zijn er twee ontwikkelingen die het agent-landschap in 2025 fundamenteel veranderden: het Model Context Protocol (MCP) en de verbeterde tool-calling van lokale modellen.

MCP, door Anthropic gelanceerd in november 2024 en snel overgenomen door OpenAI en Microsoft, is de USB-C-poort voor AI-agents: een gestandaardiseerde manier om agents te verbinden met externe tools en databronnen. Er zijn inmiddels tienduizenden MCP-servers beschikbaar voor alles van browserautomatisering tot databaseaccess. CrewAI heeft native MCP-ondersteuning ingebouwd; smolagents biedt een MCP-integratie via de tooling-laag. Het praktische voordeel: je hoeft niet meer voor elk framework een aparte toolwrapper te schrijven.

Op lokaal model-vlak is de vooruitgang eveneens groot. Qwen 3 (8B) scoort een F1 van 0,93 op tool-calling benchmarks — vergelijkbaar met veel cloud-modellen van een jaar geleden. Llama 3.1 en 3.3 worden breed ondersteund voor function calling in llama.cpp en vLLM. Dat betekent dat je een competente agent volledig lokaal kunt draaien op een degelijke laptop of thuisserver, zonder API-kosten of privacyzorgen.

De evaluatie-kant blijft een uitdaging. Benchmarks zoals WebArena en τ-Bench meten betrouwbaarheid over meerdere runs — en daar knelt de schoen. Een agent die 80% van de taken correct uitvoert, faalt bij één op de vijf uitvoeringen. Voor een hobbyproject is dat acceptabel; voor een workflow die je e-mails verstuurt of bestellingen plaatst, niet. De τ-Bench "pass^k"-metriek meet precies dit: hoe waarschijnlijk is het dat de agent k keer op rij slaagt? Die scores dalen snel bij k > 2.

Welk framework kies je?

De eerlijke samenvatting: alle drie zijn goed bruikbaar voor taken van vijf tot tien stappen met duidelijke tools. De keuze hangt af van wat je prioriteert.

CrewAI kies je als je meerdere gespecialiseerde rollen nodig hebt die samenwerken, en als je productie-infrastructuur wil met MCP, observability en event-driven flows. De leercurve is hoger, maar het platform is het meest volwassen.

AutoGen/Agent Framework kies je als je in een Microsoft-ecosysteem werkt, .NET gebruikt, of als je chat-gebaseerde human-in-the-loop-workflows nodig hebt. Houd wel rekening met de transitie van AutoGen naar Agent Framework.

smolagents kies je als je snel wilt beginnen, de code wilt begrijpen, lokale of open-source modellen wilt gebruiken, of als je een simpele taak hebt die geen volledig multi-agent-orkest rechtvaardigt. De minimalistische codebase maakt debuggen een stuk aangenamer.

Wat alle drie gemeen hebben: autonomy is nog steeds een groot woord. De frameworks zijn het gereedschap; de echte uitdaging is het definiëren van taken die klein genoeg zijn om betrouwbaar autonoom te worden uitgevoerd. Begin klein, meet betrouwbaarheid serieus, en schaal daarna op.

Veelgestelde vragen

Kan ik deze frameworks volledig lokaal draaien zonder cloud-API?
Ja. Alle drie ondersteunen lokale modellen via Ollama of LiteLLM. Qwen 3 8B en Llama 3.3 zijn momenteel de sterkste keuzes voor tool-calling lokaal — Qwen 3 8B scoort een F1 van 0,93 op standaard benchmarks.
Wat is het verschil tussen tool-calling en code-as-action?
Bij tool-calling roept de agent een functie aan via een JSON-schema. Bij code-as-action (smolagents) schrijft de agent Python-code die direct wordt uitgevoerd. Code-as-action is flexibeler maar vereist een sandbox voor veiligheid.
Is AutoGen nog relevant nu het in maintenance mode staat?
Voor bestaande projecten absoluut — securityfixes worden doorgezet. Voor nieuwe projecten in Microsoft-context is het Agent Framework de logische opvolger. Buiten dat ecosysteem zijn CrewAI of smolagents een betere startpositie.
Hoe meet ik of mijn agent betrouwbaar genoeg is?
Run dezelfde taak meerdere keren en meet hoe vaak het resultaat correct is. τ-Bench's "pass^k"-methode is hiervoor een goed model: hoe groot is de kans dat de agent vijf opeenvolgende runs correct afwerkt? Dat getal is bijna altijd lager dan je verwacht.