JetBrains Just Ranked Every Agentic Framework — Here's What They Missed
JetBrains published a comparison of 10 agentic frameworks. Their take is solid for beginners. Here's what they missed about production — and how the Vertical Agent Method fills the gap.
TL;DR: JetBrains published a thorough comparison of 10 agentic frameworks — LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, and more. Their analysis covers orchestration paradigms, multi-agent support, memory, and human-in-the-loop capabilities. It’s a good starting point for developers choosing a framework. But it starts with the wrong question. It asks “which framework should I use?” instead of “do I need a framework at all?”
Key takeaways:
- JetBrains ranks LangGraph as the production standard for deterministic agent workflows with strong human-in-the-loop support
- Role-based frameworks (CrewAI, AutoGen) are best for rapid prototyping but harder to constrain in production
- The comparison misses the most important question: do you need an agentic framework, or just a custom loop?
- OpenAI Agents SDK and Phidata are the notable new entries since 2025
- The Vertical Agent Method flips the decision: start with the workflow, not the framework
JetBrains published a guide ranking 10 agentic frameworks. It’s well-researched, includes a comparison table, and covers the three orchestration paradigms — graph, role, and chain-based.
It also misses the point.
Not because the analysis is wrong. It’s accurate. The frameworks are compared fairly, the criteria are relevant, and the recommendations are reasonable. LangGraph wins for production. CrewAI wins for prototyping. OpenAI Agents SDK wins for managed deployments.
The problem is the question the guide answers: “which framework should I pick?”
The real question is: “do you need a framework at all?”
What JetBrains got right
The comparison table is useful. Ten frameworks scored across five dimensions: orchestration, multi-agent, memory, human-in-the-loop, and best-fit use case.
| Framework | Best For |
|---|---|
| LangGraph | Production agent workflows with deterministic control |
| CrewAI | Rapid prototyping with role-based teams |
| AutoGen | Conversational multi-agent systems |
| OpenAI Agents SDK | Hosted agent applications (managed) |
| LangChain | Quick LLM app prototyping |
| LlamaIndex | Knowledge-heavy, retrieval-centric agents |
| Haystack | Production RAG and context-heavy AI |
| Semantic Kernel | Enterprise AI (Microsoft ecosystem) |
| Phidata | Data and tool-heavy agents |
| smolagents | Lightweight experiments |
The three orchestration paradigms are a helpful mental model:
- Graph-based (LangGraph, OpenAI SDK). Directed graphs with nodes and edges. Deterministic, debuggable, production-grade. More upfront design work.
- Role-based (CrewAI, AutoGen). Assign roles like Planner, Researcher, Builder. Intuitive for prototyping. Harder to constrain at scale.
- Chain-based (LangChain, smolagents). Dynamic loops with maximum flexibility. Best for creative and research tasks. Less predictable.
If you’re new to agentic frameworks, this taxonomy alone is worth the read.
Where the guide falls short
The guide treats every problem as one that needs an agentic framework. It assumes the reader has already decided to use one. The question is just which one.
In practice, many agent workflows don’t need a framework at all. We covered this in our own best AI agent frameworks comparison — the most honest answer was “it depends on what you’re building.”
I’ve shipped production agents using LangGraph, custom loops built on raw API calls, and even simple shell scripts. The framework choice was never the bottleneck. The workflow definition was.
A customer support agent that reads a knowledge base and responds to emails needs different infrastructure than an agent that orchestrates a 50-step code migration. The first might work fine as a 50-line Python script with a single LLM call. The second needs LangGraph’s state machine and human-in-the-loop interrupts.
JetBrains’ comparison doesn’t help you make that distinction.
The Vertical Agent Method approach
The Vertical Agent Method starts with one question: “what’s the workflow?”
Not “which framework should I learn?” Not “which one has the most GitHub stars.” The workflow defines the architecture. The architecture defines the framework requirements.
| Workflow Type | Framework Decision |
|---|---|
| Simple automation (email → response) | Custom loop. No framework needed. |
| Multi-step process with branching | LangGraph. Graph-based state machine. |
| Team of specialized agents | CrewAI or AutoGen. Role-based coordination. |
| Enterprise deployment with governance | OpenAI Agents SDK or Semantic Kernel. |
| Research / exploration | Chain-based (LangChain, smolagents). |
This is the opposite of how most developers approach it. Most pick a framework first, then try to fit their problem into it. The framework’s constraints shape the solution — and not always in a good way.
The JetBrains guide is a good reference for the second step — once you know you need a framework. Just don’t skip the first step.
What’s new since 2025
The guide includes three frameworks that weren’t in the conversation a year ago:
OpenAI Agents SDK. Formerly Swarm, now a graph-based managed framework with strong multi-agent support. Best for teams already in the OpenAI ecosystem. The tradeoff: you’re locked into OpenAI’s infrastructure.
Phidata. Agent-centric framework built for data-heavy and tool-heavy agents. Strong memory patterns. Worth watching if your agents process lots of structured data.
smolagents. Minimalist framework from HuggingFace. Good for experiments and learning. Not production-ready.
Haystack also deserves a mention — it’s expanded from a RAG framework into full agentic orchestration. If you’re building knowledge-intensive agents, it’s worth evaluating alongside LangGraph and LlamaIndex.
The bottom line
JetBrains’ guide is a solid reference for framework comparison. Bookmark it for when you need to decide between LangGraph and CrewAI.
Just don’t start there.
Start with the workflow. Figure out what the agent actually needs to do, how complex the state machine needs to be, whether human oversight is required, and what the failure modes are. Then pick the simplest framework that handles those requirements.
Most agent projects don’t fail because of the wrong framework choice. They fail because the workflow wasn’t defined well enough to know what success looks like.
FAQ
What are the three orchestration paradigms for agentic frameworks? Graph-based uses directed graphs for deterministic control — best for production. Role-based assigns team roles like Planner and Researcher — great for prototyping. Chain-based uses dynamic loops — ideal for creative tasks but less predictable.
Which framework does JetBrains recommend for production? LangGraph. Deterministic workflows, native state management, and strong human-in-the-loop support make it the leading standard for production-grade agents.
What new frameworks are in the 2026 landscape? OpenAI Agents SDK (formerly Swarm), Phidata for data-heavy agents, and smolagents for lightweight experiments are the notable additions since 2025.
Does every agent need a framework? No. Simple automations — read input, call an LLM, produce output — work fine as custom loops. Adding a framework adds complexity. Define the workflow first, then decide if a framework adds value.
Related Posts
Read Best AI agent frameworks 2026 for our earlier comparison of LangGraph, CrewAI, AutoGen, and building from scratch. Also see The Vertical Agent Method framework for the workflow-first methodology.
This article was published on Agentic Up (https://agenticup.dev) — practical guides for developers and founders building with AI agents. Reach me at [email protected].
