Wat doet DeerFlow precies?

DeerFlow staat voor Deep Exploration and Efficient Research Flow. Dat klinkt ingewikkelder dan het is. In de kern is het een orkestratielaag: één hoofdagent die meerdere sub-agents aanstuurt, elk met een eigen taak. Eén zoekt informatie op, een tweede vat samen, een derde schrijft code op basis van die samenvatting. Allemaal gecoördineerd door DeerFlow, zonder dat jij dat handmatig hoeft te regelen.

Normaal betekent multi-agent (meerdere AI-agents die samenwerken) een berg custom code om context door te sturen, fouten op te vangen en de volgorde te bewaken. DeerFlow neemt dat van je over.

Het framework biedt drie dingen die ik direct interessant vind:

• Sub-agent orkestratie: je definieert wie wat doet, DeerFlow regelt de handoff.
• Geheugenbeheer: zowel kortetermijncontext (lopend gesprek) als langetermijngeheugen, zodat agents kunnen leren van eerdere runs.
• Sandboxing: agent-gegenereerde code voer je niet zomaar uit op je server. DeerFlow isoleert die uitvoering in een lokale omgeving, Docker-container of Kubernetes-pod.

Dat laatste is voor mij het meest waardevol. Als een agent code produceert die je niet 100% vertrouwt, wil je niet dat die zomaar op je productieserver draait. Met de instelling auto_approve_permissions: false in je config gaat er niets door zonder jouw goedkeuring. Eén regel, grote impact.

DeerFlow is ontwikkeld door ByteDance en bereikte in februari 2026 de eerste plek op GitHub Trending na de lancering van versie 2. Of dat betekent dat het de standaard wordt? Dat weet ik nog niet. Maar de technische basis is serieus genoeg om te testen.

Opzetten in minder dan 10 minuten: hoe werkt dat?

Je kloont de repo, typt drie regels en een wizard regelt de rest. Dat is het. DeerFlow vraagt je welke LLM je wilt gebruiken, of je web search wilt, en welke sandbox-modus je kiest. Daarna schrijft het zelf een config.yaml en slaat API-keys op in een .env bestand. Voor developers die graag zelf alles instellen: er is ook een uitgebreid template beschikbaar.

De setup ziet er zo uit:

git clone https://github.com/bytedance/deer-flow.git
cd deer-flow
make setup

De make setup wizard doorloopt de belangrijkste keuzes: LLM-provider, web search, sandbox-modus en schrijftoegang tot bestanden. Binnen een paar minuten heb je een werkende basisinstallatie.

Wil je meer controle? Dan gebruik je make config, dat kopieert het volledige configuratietemplate zodat je alles handmatig kunt aanpassen: subagent runtime-limieten, modelconfiguraties per agent, sandbox-instellingen.

Er is ook een ingebouwde health check:

make doctor

Dat commando controleert of alles klopt en geeft concrete suggesties als er iets mist. Klinkt als een detail, maar als je met Docker-containers en API-keys werkt, is een geautomatiseerde check een stuk betrouwbaarder dan zelf uitzoeken wat er misgaat.

Voor Docker-ontwikkeling:

make docker-init
make docker-start

Dit start je services met hot-reloading, zodat je config-wijzigingen direct worden opgepikt zonder handmatige herstart. Prettig als je iteratief werkt.

Welke AI-modellen werken met DeerFlow?

Vrijwel alles. GPT-4o, Gemini 2.5 Flash via OpenRouter, lokale modellen via vLLM, en zelfs CLI-gebaseerde tools zoals Claude Code. Je koppelt elk model aan een specifieke sub-agent, zodat je de goedkopere of snellere optie kunt inzetten voor eenvoudige taken en het zwaardere model reserveert voor de moeilijke stappen.

DeerFlow gebruikt langchain_openai:ChatOpenAI als basis voor OpenAI-compatibele providers. Dat betekent dat alles met een OpenAI-compatibele API direct werkt, inclusief OpenRouter (die toegang geeft tot honderden modellen) en lokale vLLM-deployments.

Een voorbeeld uit de config.yaml:

models:
  - name: gpt-4o
    use: langchain_openai:ChatOpenAI
    model: gpt-4o
    api_key: $OPENAI_API_KEY

  - name: openrouter-gemini
    use: langchain_openai:ChatOpenAI
    model: google/gemini-2.5-flash-preview
    api_key: $OPENROUTER_API_KEY
    base_url: https://openrouter.ai/api/v1

  - name: lokaal-qwen
    use: deerflow.models.vllm_provider:VllmChatModel
    model: Qwen/Qwen3-32B
    api_key: $VLLM_API_KEY
    base_url: http://localhost:8000/v1

Elk model wijs je toe aan een specifieke sub-agent. Dat is slim: je kunt de goedkopere Gemini Flash inzetten voor het samenvatten van bronnen, en GPT-4o alleen gebruiken voor de stap die echt redenering vereist. Zo houd je de kosten in de hand.

Mijn voorkeur zou zijn om te beginnen met één model, de workflow stabiel te krijgen, en dan pas te differentiëren per agent. Direct met vijf verschillende modellen starten maakt debuggen lastig. Kies voor de eerste tests een model dat je al kent.

Als je meer wilt weten over het switchen tussen AI-modellen in een bestaande setup, is het artikel over LLM model migratie zonder gedoe een goede aanvulling.

Hoeveel server heb je nodig voor een stabiele DeerFlow-omgeving?

Voor productie raadt ByteDance 8 vCPU en 16 GB RAM aan als startpunt. Bij zware workflows, zoals meerdere agents tegelijk met actieve sandbox, heb je al snel 16 vCPU en 32 GB RAM nodig. Op minder dan 8 vCPU krijg je bottlenecks zodra de sandbox actief is. Linux met Docker is de meest stabiele deploymentkeuze.

Dit is het onderdeel dat veel tutorials overslaan, maar dat je later duur kan komen te staan. DeerFlow is geen lichtgewicht tool. De sandbox-modus voert code uit in geïsoleerde containers, en dat kost resources.

Richtlijnen voor productie:

• Minimaal: 8 vCPU, 16 GB RAM, 40 GB vrije SSD
• Intensief gebruik: 16 vCPU, 32 GB RAM (voor multi-agent runs of rapportgeneratie)
• OS: Linux met Docker is de aanbevolen combinatie

Voor development werkt Docker uitstekend en geeft het je isolatie zodat je lokale machine niet vervuild raakt met dependencies.

Naar mijn idee is dit ook het punt waar DeerFlow verschilt van simpelere AI-tools: het is infrastructuur, geen plugin. Je zet het op zoals je een backend-service opzet, niet zoals je een Chrome-extensie installeert. Dat vraagt een andere manier van denken.

Als je nu al nadenkt over de bredere verschuiving in hoe developers met AI werken, is het artikel over de developer rol in het AI-tijdperk een eerlijke blik op wat er verandert.

Is DeerFlow iets voor jou als developer?

DeerFlow is interessant als je complexe, meertraps AI-workflows wilt bouwen waarbij meerdere agents samenwerken. Het is niet geschikt als je simpelweg een chatbot wilt of een API wilt aanroepen. De leercurve is reëel, de infrastructuurvereisten zijn serieus, maar de controle die je terugkrijgt over hoe agents samenwerken is het waard als dat je use case is.

Eerlijk oordeel: DeerFlow is geen beginnersspeeltje. De setup is redelijk toegankelijk dankzij de wizard, maar zodra je meerdere agents met verschillende modellen gaat configureren en de sandbox serieus gaat inzetten, ben je bezig met infrastructuur.

Voor wie het wél interessant is:

• Developers die AI-workflows bouwen waarbij stappen van elkaar afhankelijk zijn
• Teams die agent-gegenereerde code veilig willen uitvoeren zonder hun productieserver te riskeren
• Projecten waarbij je wilt schakelen tussen LLM-providers per taak, voor kosten- of kwaliteitsoptimalisatie

Voor wie het minder geschikt is:

• Je wilt snel een chatbot of eenvoudige AI-assistent bouwen
• Je hebt geen server met minimaal 8 vCPU beschikbaar
• Je bent niet bekend met Docker en wil dat ook niet worden

Wat ik zelf zou doen: het lokaal opzetten met make setup, één eenvoudige workflow testen met twee agents en één model, en dan evalueren of de complexiteit gerechtvaardigd is voor het project. Niet direct in productie gooien.

Ben je ook bezig met het bouwen van AI-agents voor specifieke taken? Het artikel over AI-agents als ontwikkelteam laat zien hoe zo’n opzet er in de praktijk uitziet.