A vendor-neutral tour of every serious agent SDK on the market in April 2026 — Claude Agent SDK, OpenAI Agents, Google ADK, Microsoft Agent Framework, LangGraph, CrewAI, Mastra and the rest. Repo URLs, language, sweet spot, gotchas, and the decision framework Symprio uses to pick one.
Pick the wrong agent framework and your team spends three months fighting the abstractions. Pick the right one and the framework disappears — your developers ship behaviour, not boilerplate. The problem in April 2026 is that there are now fourteen serious agent development kits with non-trivial production users, and the marketing pages all read the same.
This post is the honest, vendor-neutral tour. Every kit gets a repo URL, the language it speaks natively, the workload it actually wins on, and the gotchas you only learn after shipping with it. At the end is the decision framework Symprio uses with Malaysian enterprise customers when they ask which one to pick.
The taxonomy: four families, different jobs
Before the kit-by-kit walkthrough, it helps to know the four families they fall into — picking inside a family is mostly preference; picking between families is an architecture decision.
- Vendor-led flagships — built by the model labs and clouds. Tightest integration with the model, fastest to adopt new model features, opinionated. Claude Agent SDK, OpenAI Agents SDK, Google ADK, Microsoft Agent Framework, AWS Strands.
- Orchestration frameworks — model-agnostic, focused on composing multi-step or multi-agent workflows. LangGraph, CrewAI, AutoGen, LlamaIndex Workflows.
- Type-first / Python-native — strong typing, FastAPI feel, fewer abstractions. Pydantic AI, DSPy, Smol Agents.
- TypeScript-native — for teams shipping agents inside web apps. Vercel AI SDK, Mastra.
Vendor-led flagships
Claude Agent SDK (Anthropic)
Repo: anthropics/claude-agent-sdk-python · anthropics/claude-agent-sdk-typescript
Language: Python and TypeScript
Sweet spot: autonomous coding agents, long-running tool-using workflows, anything that benefits from Claude's agentic strengths. The same primitives that power Claude Code itself — file system tools, sub-agents, hooks, MCP integration.
Gotcha: Claude-only by design. If you need to swap models for cost or compliance reasons, this is not the abstraction layer for you.
OpenAI Agents SDK
Repo: openai/openai-agents-python · openai/openai-agents-js
Language: Python and TypeScript
Sweet spot: the lightest production-grade SDK in the vendor-flagship family. Three primitives — agents, handoffs, guardrails — and that is the whole API surface. Successor to Swarm; what most OpenAI shops standardise on after outgrowing raw openai.ChatCompletion calls.
Gotcha: deliberately minimal — for complex DAG-style workflows you will end up reaching for LangGraph anyway.
Google Agent Development Kit (ADK)
Repo: google/adk-python · google/adk-java
Language: Python and Java
Sweet spot: Vertex AI Agent Engine deployments, Gemini-first workloads, Google Cloud-aligned enterprises. Strong evaluation tooling baked in, A2A (agent-to-agent) protocol native.
Gotcha: the documentation assumes you are running on Google Cloud — running ADK fully outside GCP is possible but you lose half the value.
Microsoft Agent Framework
Repo: microsoft/agent-framework
Language: .NET and Python
Sweet spot: the unified successor to Semantic Kernel and AutoGen — Microsoft has consolidated both into one framework as of late 2025. First-class Azure AI Foundry integration, enterprise governance built in, native MCP. The default for Microsoft-shop enterprise agents in 2026.
Gotcha: still maturing. If you have existing Semantic Kernel or AutoGen production code, migration is real work — both predecessors are now in maintenance mode.
AWS Strands Agents
Repo: strands-agents/sdk-python
Language: Python
Sweet spot: AWS-aligned shops running on Bedrock. Model-driven design (the model decides what tool to call rather than the framework dictating it), strong observability via CloudWatch. Powers the agents inside Amazon Q.
Gotcha: youngest of the vendor-flagship family — community is smaller, fewer third-party integrations than LangGraph or CrewAI.
Orchestration frameworks (model-agnostic)
LangGraph
Repo: langchain-ai/langgraph
Language: Python and TypeScript
Sweet spot: the de-facto standard for graph-based agent orchestration. Explicit state, explicit nodes, explicit edges — well-suited to workflows that need to be auditable, resumable, or human-reviewable. Heavy enterprise adoption.
Gotcha: the abstractions are powerful but verbose. Simple agents look heavy in LangGraph compared to Pydantic AI or the OpenAI SDK.
CrewAI
Repo: crewAIInc/crewAI
Language: Python
Sweet spot: role-based multi-agent crews. Define a Researcher, a Writer, a Reviewer; CrewAI handles the orchestration. Excellent for content workflows, research agents, anything that maps cleanly onto a team metaphor.
Gotcha: the role-based metaphor is a great mental model and a leaky abstraction — production debugging often means dropping out of CrewAI's helpers and reading the underlying prompts.
AutoGen (legacy)
Repo: microsoft/autogen
Status in 2026: being absorbed into Microsoft Agent Framework. Existing AutoGen code still works; new projects should start on Agent Framework instead.
LlamaIndex Workflows
Repo: run-llama/llama_index
Language: Python and TypeScript
Sweet spot: RAG-heavy agents. If your agent's primary job is to retrieve, reason and summarise across a corpus of enterprise documents, LlamaIndex is purpose-built for that. The Workflows API added proper agent orchestration in 2024.
Gotcha: historically RAG-first, agent capabilities are layered on. For pure-tool-use agents that do not retrieve, the framework can feel oversized.
Type-first and Python-native
Pydantic AI
Repo: pydantic/pydantic-ai
Language: Python
Sweet spot: if your team loves FastAPI, you will love Pydantic AI. Strong typing throughout, structured output as a first-class concept, model-agnostic, no surprises. Fast-growing in 2026 — frequently the choice of teams who tried LangChain and bounced off the abstractions.
Gotcha: single-agent-first. For complex multi-agent orchestration you can compose Pydantic AI agents but you may want LangGraph underneath at scale.
DSPy
Repo: stanfordnlp/dspy
Language: Python
Sweet spot: programming with LLMs rather than prompting them. DSPy compiles declarative pipelines and can automatically optimise prompts and few-shot examples against a metric. For teams treating LLM workflows as software-engineering rather than prompt-engineering, this is the framework.
Gotcha: conceptual learning curve is real — teams need to invest in understanding the compiler model before it pays off.
Smol Agents (Hugging Face)
Repo: huggingface/smolagents
Language: Python
Sweet spot: minimalist, code-first agents. The agent writes Python code to invoke tools rather than calling JSON tool schemas — surprisingly effective for tasks that compose well into code. ~1,000 lines of core framework, easy to read end to end.
Gotcha: code-execution agents need a sandbox in production. Hugging Face provides one but you should understand the security model before shipping.
TypeScript-native
Vercel AI SDK
Repo: vercel/ai
Language: TypeScript
Sweet spot: agents inside Next.js / React applications. generateText, streamText and tool() are the entire API for most use cases. Streaming-first, edge-runtime friendly, model-agnostic.
Gotcha: not a multi-agent orchestration framework. For complex agent graphs you will reach for Mastra or LangGraph.js on top.
Mastra
Repo: mastra-ai/mastra
Language: TypeScript
Sweet spot: the most complete TypeScript-native agent framework — workflows, agents, RAG, evals, memory, MCP, all in one cohesive API. From the team behind Gatsby. Strong dev-experience focus.
Gotcha: younger than the Python equivalents — fewer enterprise reference deployments to point to in 2026, though that is changing fast.
Letta (formerly MemGPT)
Repo: letta-ai/letta
Language: Python
Sweet spot: stateful agents with first-class long-term memory. Where most frameworks treat the conversation history as ephemeral, Letta makes memory a managed primitive — useful for personal assistants, customer-facing agents that need continuity, and any workload where the agent should "remember" across sessions.
Gotcha: not a general-purpose orchestrator — pair it with one of the families above for complex workflows.
How Symprio picks for Malaysian enterprise customers
The kit-by-kit list is the easy part. The harder question is which one to standardise on. Five questions, in this order:
- What language is your team most productive in? Python and TypeScript dominate; .NET shops should skip straight to Microsoft Agent Framework.
- Are you locked to one model vendor? Claude-only on Bedrock → Claude Agent SDK. Azure OpenAI shop → Microsoft Agent Framework. Gemini on Vertex → Google ADK. Multi-vendor → orchestration framework.
- How complex is the orchestration? Single agent calling tools → Pydantic AI or OpenAI Agents SDK. Multi-step DAG with branching → LangGraph. Role-based crew → CrewAI.
- How heavy is retrieval? Document-heavy RAG agent → LlamaIndex. Light retrieval → anything else.
- Where will it run? AWS Bedrock-first → Strands. Vertex → ADK. Azure AI Foundry → Microsoft Agent Framework. Self-hosted on Malaysian infrastructure → any model-agnostic orchestration framework, paired with an open-source LLM (Llama 3.3, Mistral, Qwen).
Two practical rules we apply to every Malaysian enterprise engagement:
- Optimise for switchable models, not switchable frameworks. Model leadership rotates every 2–3 months in 2026 (we wrote about this in our flagship LLM comparison). The framework you pick should make swapping the model trivial.
- Adopt MCP. Model Context Protocol has become the de-facto tool-integration standard. Frameworks with strong MCP support (Claude Agent SDK, Microsoft Agent Framework, Mastra, Pydantic AI) make it easier to share tools across agents and across kits.
Two anti-patterns we see often
1. Reaching for LangChain reflexively. LangChain (the parent of LangGraph) was the first popular agent framework and is still widely used, but for greenfield enterprise agent work in 2026 we more often recommend LangGraph (for orchestration) or Pydantic AI (for type-first agents) directly. They have lower abstraction tax for the same outcomes.
2. Building everything on the bare model SDK. Some senior engineering teams prefer to skip frameworks entirely and call openai.ChatCompletion or anthropic.messages.create directly. This works for prototypes and breaks at production scale once you need handoffs, evals, observability and tool registries — at which point you are reinventing one of the kits above. Pick the lightest kit that fits your needs (often OpenAI Agents SDK or Pydantic AI) rather than building from scratch.
Where to go from here
If you are starting fresh, we usually recommend prototyping the same agent in two frameworks for two days each, then committing. The cost of that experiment is small; the cost of a year on the wrong framework is not.
If you have already shipped agents and the framework is fighting you, an architecture review usually surfaces whether the right move is a refactor inside the current framework or a migration to a better-fit one. Talk to Symprio — we have shipped production agents on Claude Agent SDK, OpenAI Agents SDK, LangGraph, Pydantic AI and Microsoft Agent Framework, and we will tell you honestly which fits your team rather than which we are paid to push.
Symprio designs, builds and operates agentic AI systems for Malaysian enterprises across banking, insurance, fintech and shared services. Explore our Agentic AI practice or book a 30-minute architecture session.