The agent framework landscape
Job ads name an average of a bit over two frameworks, and the multi-agent ones rarely appear alone. So breadth matters more than depth here: you need to be able to place each framework and say what it optimises for, not to have shipped all of them.
Note: verified 2026-08-12. AutoGen and Semantic Kernel merged into Microsoft Agent Framework, which reached 1.0 GA in April 2026; both predecessors are in maintenance mode. Talking about them as separate live projects dates you by a year.
The landscape by what it optimises for
| Framework | Optimises for |
|---|---|
| LangGraph | explicit state graphs, durability |
| CrewAI | role-based teams, fast to express |
| MS Agent Framework | enterprise .NET/Python, Azure |
| OpenAI Agents SDK | minimal surface, handoffs |
| Google ADK | code-first agents, Vertex |
| Strands (AWS) | model-driven, Bedrock-adjacent |
| Pydantic AI | type safety, small footprint |
The useful axis is how much structure the framework imposes. LangGraph makes you draw the graph; CrewAI lets you describe roles and infers the rest. That is the trade-off between control and speed-to-first-demo, and it is the answer to “which would you pick”.
The ones worth being able to discuss
CrewAI — roles and tasks
researcher = Agent(
role="Researcher",
goal="Find recent filings",
backstory="...",
tools=[search],
)
crew = Crew(agents=[researcher, writer], tasks=[t1, t2])You describe a team, not a control flow. It is the fastest way to express “these three specialists collaborate”, and the cost is exactly that: the control flow is implicit, so debugging why the crew did something odd is harder than reading a graph.
Sequential and hierarchical process modes cover most of what people build. Python 3.10-3.13 as of 1.15.
Microsoft Agent Framework — the merged one
The important fact is the merger. AutoGen contributed multi-agent conversation, Semantic Kernel contributed plugin orchestration, and the result is a graph-based state machine with first-class Azure integration and both .NET and Python SDKs.
Name it when the shop is Microsoft. Mentioning AutoGen or Semantic Kernel as current choices is the tell that your knowledge stopped in 2025.
OpenAI Agents SDK — deliberately small
Agents, handoffs, guardrails, sessions and tracing. That is nearly the whole surface, which is the appeal: little to learn, tracing built in, and provider-agnostic despite the name.
Handoffs are its distinctive idea — an agent transfers the conversation to another agent rather than calling it as a tool, so the receiving agent owns the thread. It also covers realtime and voice agents, which matters if the product is conversational.
from agents import Agent, Runner
refunds = Agent(name="Refunds", tools=[issue_refund])
triage = Agent(
name="Triage",
instructions="Send refund requests to Refunds.",
handoffs=[refunds],
)
result = await Runner.run(triage, "I want my money back")Compare that with the CrewAI block above. Triage does not get a reply back and
carry on — it is out of the conversation, and Refunds answers the user
directly. A tool call returns; a handoff does not.
Google ADK and AWS Strands
Both are cloud-vendor SDKs that are genuinely usable off their cloud, and both are Apache 2.0.
ADK is code-first with a workflow runtime, graph execution and agent-to-agent delegation; it lands naturally on Vertex. Strands is model-driven — a model, a system prompt and tools, with the framework staying out of the way — and AWS runs it in its own products, which is a decent reliability signal.
Mention the one matching the employer’s cloud.
What the choice actually turns on
Not features. The questions that decide it:
- Does the task need durable, resumable runs? That narrows it fast — see Durable execution and human-in-the-loop.
- Whose cloud? Vendor SDKs integrate with their platform’s identity, observability and hosting for free.
- Do you need multi-agent at all? Usually not — see Multi-agent patterns. Five agents at 90% each is about 59% end to end.
- Type safety and footprint? Pydantic AI.
Gotcha: the frameworks converge on the same primitives — an agent, tools, handoffs, state, tracing — so migration is mostly mechanical. Which means the framework is a weak differentiator, and treating the choice as strategic is itself a signal. What is not portable is your evals, your observability and your tool contracts, which is where the effort should go.
The position to hold
Frameworks cluster tightly on pay because they are commodity knowledge. The sentence that separates a senior answer:
“I’d use LangGraph where the flow needs to be explicit and resumable, and CrewAI or the Agents SDK where it’s a small collaboration and speed matters more. The framework is the least portable-relevant decision — what I’d actually own is the evaluation, the cost model and the failure behaviour.”
That reframes the question from which SDK you know to what you are accountable for, which is where the money is.
Related
Interview angle 6
- “Which agent frameworks have you used?” - place them by what they optimise for rather than listing logos: LangGraph for explicit, resumable state graphs; CrewAI for role-based teams expressed fast; the OpenAI Agents SDK for a minimal surface with handoffs; the vendor SDKs where the cloud already decided.
- “What happened to AutoGen and Semantic Kernel?” - they merged into Microsoft Agent Framework, which went GA in April 2026, and both are in maintenance mode. Naming either as a current choice dates you.
- “CrewAI or LangGraph?” - how much structure you want imposed. CrewAI describes a team and infers the control flow, which is fast to write and harder to debug when the crew does something odd. LangGraph makes you draw the graph, which is more work and inspectable.
- “What’s distinctive about the OpenAI Agents SDK?” - handoffs. One agent transfers the conversation to another, which then owns the thread, rather than calling it as a tool. Plus a deliberately tiny surface — agents, tools, guardrails, sessions, tracing — and built-in tracing.
- “How would you choose?” - durability requirements first, then whose cloud, then whether multi-agent is warranted at all. The frameworks converge on the same primitives, so migration is mechanical and the choice is a weaker decision than it looks.
- “So the framework doesn’t matter?” - it is the entry ticket. What is not portable is the evaluation suite, the observability and the tool contracts, so that is where the effort and the accountability should sit.