For 24 months this field ran on one joke. You announce a new agent framework. Post a 90 second video of it booking a fake flight. Get 12k github stars. No one ever deploys it. No one runs it for more than an hour. No one uses it for actual work.

That ended last week.

Two projects hit the top of GitHub trending back to back. Neither posted a flashy demo. Neither made claims about AGI. They just solved the two unglamorous, hard problems that every single person trying to run agents has been stuck on.

DeerFlow orchestrates sub agents, sandboxes untrusted code, and stays running. Cognee gives agents actual persistent memory that works across sessions. This is not another demo. This is production infrastructure.

DeerFlow 2.0: the orchestrator that beat every other project to #1

On February 28 2026 DeerFlow 2.0 hit #1 GitHub trending globally. It did this 36 hours after release. No marketing. No blog post. Just engineers finding something that actually worked and starring it.

This is not the same DeerFlow that was posted last year. This is a complete ground up rewrite. Zero code is shared with the 1.x branch. The original deep research prototype is now in maintenance mode. All active work moved to 2.0.

This was the right call. Every mistake from the first generation of agent frameworks was thrown out. No unnecessary abstractions. No forced graph DSL. No 17 layers of indirection between you and the LLM.

The setup experience that every agent framework should copy

You can get DeerFlow running locally end to end in about two minutes. That is not marketing copy. That is measured.

Clone the repo. Run make setup. That is it.

An interactive wizard walks you through picking an LLM provider, enabling web search, setting sandbox permissions, and writing out a valid config. No editing yaml by hand first. No chasing 12 different environment variables across 5 different files.

At any point you can run make doctor and it will tell you exactly what is broken and exactly how to fix it. No generic errors. No "something went wrong".

This sounds trivial. It is not. Every other agent framework gets this wrong. Every single one.

If you don't want to run the wizard you can just hand the entire install instructions to Claude Code, Cursor, Windsurf or any other coding agent in one sentence. The repo maintainers wrote the prompt specifically for agents to bootstrap themselves. That is the kind of detail you only add when you actually use your own software every day.

Model configuration

DeerFlow does not lock you into any LLM. It does not even ship with a default.

All model configuration is explicit, flat yaml. You can use OpenAI, Anthropic, OpenRouter, vLLM, Codex CLI, Claude Code OAuth, or any OpenAI compatible endpoint. There is no wrapper library you have to patch to add a new provider.

For reasoning models it correctly handles the non standard fields that vLLM and Qwen use for thought tokens. It preserves reasoning output across multi turn tool calls. No other framework does this correctly right now. Most will silently drop the reasoning block entirely on the second turn.

Sandboxing done right

This is the part that makes DeerFlow production ready. Everyone else treats sandboxing as an afterthought. DeerFlow built it first.

There are three execution modes:

• Local, for development only
• Isolated Docker containers per agent run
• Kubernetes pod provisioning for shared multi user deployments

Code generated by agents never runs on the host process. It never shares a filesystem. It never has network access unless explicitly granted.

You will not read this in any other agent framework readme. Every other project runs exec() on whatever code the LLM output directly on your laptop.

Deployment sizing

They published actual hardware requirements. Not "it runs on anything". Actual numbers.

Deployment target	Minimum	Recommended
Local evaluation	4 vCPU / 8 GB RAM	8 vCPU / 16 GB RAM
Docker development	4 vCPU / 8 GB RAM	8 vCPU / 16 GB RAM
Shared production server	8 vCPU / 16 GB RAM	16 vCPU / 32 GB RAM

They also tell you what not to do. Do not run a persistent server on macOS or Windows. Do not increase gateway worker count above 1. There is no shared state layer yet, multiple workers will break cancellation, SSE reconnects and event streams. Scale vertically first.

This is what engineering documentation looks like. It tells you what does not work.

Cognee: memory that doesn't just store vectors

The day after DeerFlow hit #1, Cognee took #2.

Everyone implements agent memory wrong. They take the user message, embed it, dump it into a vector database, and do top 3 similarity search on every turn. This works for 5 messages. It stops working completely after 50.

Cognee does not do that.

It builds a knowledge graph. It extracts entities, relationships, and outcomes. It remembers what worked, what failed, and what the agent actually did. It combines vector search with graph traversal. It has explicit separation between fast session memory and permanent long term memory.

This is not a new idea. Everyone talked about doing this for a year. No one shipped a working implementation that you could just install.

Four function API. That's it.

Cognee has exactly four public operations:

1. remember()
2. recall()
3. forget()
4. improve()

That is the entire API. No 70 method SDK. No plugins. No configuration DSL.

You call remember() with anything you want stored. You call recall() with a query. It automatically picks the right search strategy, routes between session and permanent memory, and returns relevant context.

await cognee.remember("User prefers detailed explanations.", session_id="chat_1")
results = await cognee.recall("What does the user prefer?", session_id="chat_1")

That is all. There is nothing else you need to learn.

The Claude Code integration that will change everything

Cognee ships an official plugin for Claude Code. This is the first useful agent memory plugin that exists for any coding agent.

It hooks directly into Claude Code's lifecycle:

• Initializes memory on session start
• Captures every tool call and output
• Injects relevant context before every user prompt
• Preserves memory across context window resets
• Syncs all session data to the permanent graph when you exit

Right now Claude Code forgets everything 10 minutes after you close the terminal. With this plugin it remembers every problem you solved, every mistake you made, every pattern that worked. Forever.

This is not a demo. This works today.

What this stack actually runs on

Right now you can put these two projects together and run a production agent system that will not fall over. This is the stack that every engineering team will be testing over the next three months.

There are still gaps. DeerFlow does not have native user authentication yet. Cognee's graph pruning logic is still very basic. Neither has proper horizontal scaling.

But none of that matters. For the first time there is open source infrastructure that does not require you to build 80% of the system yourself before you can run a single agent.

The gaps that are still missing

There are three unsolved problems left:

1. Cross agent memory permissions. Right now any agent can read anything stored in Cognee.
2. Proper rate limiting and cost accounting for DeerFlow multi tenant deployments.
3. Standardized checkpoint format for agent runs that works across both systems.

None of these are hard. All of them will be implemented in the next 90 days.

Where this is going

For two years everyone was waiting for the big company to release the agent framework. Everyone was waiting for OpenAI, Anthropic or Google to ship the standard.

That is not going to happen.

The standard will be open source. It will be built by engineers who actually run agents every day. It will be shipped on GitHub first. It will hit trending before anyone writes a press release.

That is what just happened.

If you are building agents this year, stop building your own orchestrator. Stop building your own memory layer. Go look at these two projects.

They work.