The AI Agent Stack in 2026: Which Harnesses and Frameworks Actually Made It to Production

For two years, the honest answer to "which framework should we build our agents on?" was "ask again next month." The tools churned that fast. APIs broke on minor releases, abstractions were renamed, and the reference architecture you picked in the spring was legacy by the fall.

That era ended in a tight window. Between October 2025 and April 2026, the core of this field shipped its first stable 1.0 releases. LangChain and LangGraph on 22 October 2025, the Microsoft Agent Framework on 3 April 2026, with Pydantic AI, Mastra, and the major lab SDKs all reaching maturity around the same time. The message to builders flipped from "everything breaks every month" to "pick a stable base." That single shift is the story of the 2026 agent stack, and it is why the question of what to build on finally has durable answers.

We build and run these systems for companies in Cyprus and the wider region, so this is written from the position of choosing tools we then have to maintain. Here is how the landscape actually sorts out, and how to choose within it.

First, a reality check: you may not need a framework at all

Before naming winners, the most useful thing a senior lead can hear is that roughly 40% of agentic tasks are best handled by raw LLM API calls with structured output. Plain JSON mode, no framework. If a workflow can be drawn as a flowchart with no loops and no branches, adding a framework is a liability: more latency, more cost, more surface area, no benefit.

That test matters because the rest of this piece is a catalog of powerful tools, and the discipline is knowing when not to reach for them.

The four layers of the stack

"Harness" and "system" get used loosely in this field, which muddies every comparison. It helps to split the stack into four layers, because the leaders, the buyers, and the definition of "good" differ in each.

Layer 1: developer frameworks and SDKs

Choosing a framework is mostly choosing a paradigm, not a vendor. Four recurring patterns organise the field.

Graph-based and durable-workflow

Execution modelled as an explicit stateful graph with checkpointing and human-in-the-loop. This is where the industry standard lives.

The uncompromising leader is LangGraph (LangChain, Inc.; MIT-licensed, Python with a JS/TS port). It is architected around cyclic control flow and the StateGraph primitive: you define nodes (computational steps) and edges (logic-driven routing), so every state change is a visible transition in the graph. That transparency makes it the most reliable model for auditing complex business logic, and its checkpointing API is the most dependable mechanism available for time-travel debugging and state recovery.

The adoption signals are real but worth reading carefully. LangChain says LangGraph has powered agents at Uber, LinkedIn, and Klarna, a first-party claim, and Klarna in particular reports its assistant handles two-thirds of support chats, doing the work of 700 to 850 agents and projected to drive a $40M profit improvement. Momentum indicators point the same way: LangGraph is credited with roughly 34.5 million monthly downloads, and the parent LangChain project sits around 137k GitHub stars, having raised $125M at a $1.25B valuation in October 2025.

The tradeoff LangGraph asks you to accept is verbosity. Data from Uvik Software puts a standard tool-using agent at 4 lines of code with LangChain's high-level create_agent, versus 17 lines with LangGraph's StateGraph. That 13-line delta is the price of explicit control over state, conditional routing, and interrupts: cheap if you need it, wasteful if you do not.

Role and conversation-based

Agents with roles collaborating, or a conversational multi-agent group chat. CrewAI (Python, MIT, built independently of LangChain) is the most-starred pure multi-agent framework, and it is fast to prototype with: you define agents by role, goal, and backstory, organised into "crews" that run sequential or hierarchical processes, plus "Flows" for more deterministic control. The caution is equally clear. It offers less fine-grained control than graph-based frameworks, which in long-running tasks can produce unpredictable hallucination loops. One report frames it bluntly as a prototype-first tool that often gets refactored to LangGraph once durability matters.

The AutoGen lineage sits in the same paradigm but has fragmented. The active successor, AG2, uses a Hub and Channel model with typed channels (consulting, workflow), plus a write-ahead log and audit trail inside the Hub. That suits research-grade reasoning chains and agent-debate patterns where the history of the conversation is the primary state. Two warnings attach to it: AG2 v1.0 (import ag2) is not a drop-in upgrade from the original AutoGen namespace and requires real migration work, and the original AutoGen v0.2 is now a procurement error, since maintainer velocity moved to AG2. Microsoft, meanwhile, folded classic AutoGen (in maintenance mode) and Semantic Kernel (converging) into a single Microsoft Agent Framework, which shipped 1.0 on 3 April 2026 with stable APIs, long-term support, and connectors spanning Azure OpenAI, OpenAI, Anthropic, Bedrock, Gemini, and Ollama.

Code-agent and model-driven

Minimal scaffolding that leans on the model's own reasoning, sometimes letting the agent write executable code as its action space. Hugging Face's smolagents champions this paradigm in roughly a thousand lines of readable code: ideal for minimalist research and scripts, and a poor fit for building multi-agent production systems. AWS Strands runs a model-driven loop and is the AWS-native choice, inheriting IAM and VPC security directly.

Minimal typed SDKs

A small, un-opinionated core instead of heavy orchestration. This is where the big labs converged, and they now form a coherent set.

• OpenAI Agents SDK is lightweight and provider-agnostic, built on four primitives: Agents, Handoffs, Guardrails, and Sessions. It is the production successor to the educational Swarm, which OpenAI has explicitly retired. Its handoffs primitive is the cleanest abstraction for transferring control between agents without polluting context, and it is best inside OpenAI-centric stacks.
• Claude Agent SDK (Anthropic), renamed from "Claude Code SDK," exposes Claude Code's mature agent harness (file, shell, custom tools, hooks) so you can build your own agents. Its strongest signal is dogfooding: it powers Claude Code, so every code path is validated by Anthropic's flagship agentic product. It offers superior hooks for safety and skills for reuse, and it intentionally omits multi-provider routing, a feature if you are Anthropic-first, a dealbreaker if you need model portability.
• Pydantic AI brings type safety as a first-class requirement, enforcing validated structured outputs the Pydantic way so agents do not break downstream services with non-conforming JSON, with strong observability through Logfire.
• Google ADK (Agent Development Kit) is an open-source, code-first, model-agnostic toolkit with built-in evaluation and tight deployment to Vertex AI Agent Engine and GKE, supporting both MCP and A2A. Google reported 7M+ ADK downloads by November 2025.

Rounding out the layer: LlamaIndex is the data and RAG-centric option, best-in-class for document ingestion, retrieval, and knowledge assistants, increasingly built around document agents and OCR via LlamaParse and LlamaCloud. Agno (formerly Phidata) is a performance-focused Python framework that also ships a runtime and UI to deploy agents as services, and its v2.7.3 release on 14 July 2026 was the freshest of any framework surveyed. Mastra is the leading full-featured TypeScript framework, TS-native rather than a port, delivering Python-quality primitives (workflows and evals) to Node.js and Next.js shops, with around 150,000 weekly npm downloads and named use at PayPal, Replit, and Adobe. LangChain DeepAgents is a batteries-included harness built on top of LangGraph.

If you want the short version of where to land:

The underlying rule is stack-first selection: choose the framework that aligns with where your auth, logging, and infrastructure already live. Start with high-level abstractions like create_agent to cut boilerplate for standard tasks, and refactor down to low-level graphs the moment you need explicit control over state transitions, durable checkpointing, or multi-agent handoffs.

Layer 2: agentic coding harnesses

This is the most commercially valuable and fastest-moving segment, and the one where "harness" is most literal: each tool wraps a model in a loop of tools (file edits, shell, tests) to autonomously perform software engineering.

Claude Code (Anthropic) runs across terminal and CLI, desktop apps, VS Code and JetBrains extensions, web, mobile, Slack, and GitHub Actions. Its 2026 feature set emphasises Dynamic Workflows that run many parallel subagents with verification, scheduled Routines, and computer use; it is included in Claude's Pro and Max tiers. OpenAI Codex, the agentic tool rather than the 2021 model, positions itself as "one agent for everywhere you code," spanning desktop app, IDE extension, CLI, and cloud, integrated with GitHub, Slack, and Linear, and bundled with ChatGPT plans, riding a documented progression of Codex-tuned models through late 2025. Cursor (Anysphere), a VS Code fork with agent and background-agent modes, is the segment's commercial standout; the most reputable signal on its scale is a report that it was in talks to raise $2B at a $50B valuation after reaching $2B ARR, with other circulating figures uncorroborated.

The open-source cohort is where GitHub mindshare concentrates. Google Gemini CLI is an open-source terminal agent with MCP support and Google Search grounding, and carries the largest star count in this cohort. OpenHands (formerly OpenDevin) is a self-hostable control center that can run its own agent or drive Claude Code, Codex, and Gemini across local, remote, and cloud backends. Cline is an autonomous coding agent available as an SDK, IDE extension, or CLI, with plan and act modes and bring-your-own-model; its fork Roo Code appeared archived as of May 2026 per its repo page, a surprising claim worth independent confirmation. Aider is model-agnostic, git-aware pair programming in your terminal.

The async and enterprise tier is filling in fast: GitHub Copilot's coding agent reached general availability on 25 September 2025 (assign it an Issue, it opens a PR), Google Jules went GA on 6 August 2025, and Google Antigravity, an agent-first development platform, launched in public preview alongside Gemini 3 in November 2025. Amp (Sourcegraph) offers remote long-running Orbs and multiplayer agents, Replit Agent brings natural-language app-building to non-experts, and Factory Droid targets terminal-heavy and CI-heavy work.

Consolidation is real and verifiable here: Cognition, the maker of Devin, acquired Windsurf's product, IP, and team on 14 July 2025, and was subsequently reported valued at $10.2B.

Layer 3: no-code and low-code orchestration

For teams building agents without deep coding, open-source and self-hostable platforms dominate GitHub mindshare, though their licenses range from truly permissive to restricted. n8n is a fair-code workflow-automation platform (under a Sustainable Use License, not OSI open-source) that pivoted hard toward AI agents; it raised $180M at a $2.5B valuation in October 2025 and reported 230,000+ active users and $40M+ ARR as of March 2025. Langflow is a low-code visual builder now owned by DataStax, which IBM agreed to acquire in February 2025, folding it into IBM's watsonx orbit. Dify bundles RAG, agents, model management, and observability into an agentic-workflow platform and raised a $30M Series Pre-A in March 2026. Flowise, Sim, Botpress, and Rivet round out the open cohort.

Funded SaaS agent-builders compete on ease of use for non-technical citizen developers rather than on open code: Gumloop ($50M Series B led by Benchmark in March 2026, with customers including Shopify and Ramp), Relevance AI ($24M Series B by Bessemer), Stack AI ($16M Series A, focused on regulated enterprises), Lindy (a Series B led by Battery Ventures), and Zapier Agents, layered on Zapier's 9,000+ app catalog. One clarification worth carrying forward: Lindy is a no-code product for end users, not a programmable SDK for engineers, so filing it alongside developer frameworks is a category error.

The hyperscaler platforms are converging on the same production primitives: multi-agent coordination, A2A, MCP tool use, managed runtimes, evaluations, and governance. Microsoft Copilot Studio and Power Automate brought computer-using agents to GA in May 2026 (running OpenAI's CUA and Claude Sonnet 4.5), with a Service Agent reaching GA in Microsoft 365 Copilot in June 2026. Google Vertex AI Agent Builder combines ADK, the Agent Engine managed runtime, governance (Model Armor, IAM agent identities), and registration into Gemini Enterprise. Amazon Bedrock AgentCore is a framework-agnostic platform that reached GA on 13 October 2025 with 8-hour execution windows, A2A support, a Gateway that turns MCP servers and APIs into tools, managed memory, and observability. The dividing lines across this whole layer are self-host versus SaaS, developer versus citizen-developer, and hyperscaler lock-in versus the flexibility and lower cost of open, indie stacks.

Layer 4: supporting infrastructure

The defining infrastructure story of 2025 and 2026 is that the major agent standards all landed in one neutral home. Anthropic's Model Context Protocol (MCP), the de facto standard for the agent-to-tools-and-data axis, MIT-licensed, was donated to the Linux Foundation's new Agentic AI Foundation on 9 December 2025, co-founded by Anthropic, Block, and OpenAI, with Google, Microsoft, AWS, Cloudflare, and Bloomberg among the supporters. Direct competitors backing one standard is rare, and it matters: MCP is now the universal interface for tools, eliminating the need to rewrite custom integration code for every framework. Anthropic reported 10,000+ active public MCP servers and 97M+ monthly SDK downloads; the MCP reference-servers repo carries roughly 87k stars, and an official MCP Registry launched in preview in September 2025.

MCP handles the agent-to-tools axis; two more protocols complete the picture. Google's Agent2Agent (A2A), the agent-to-agent axis, Apache-2.0, was donated to the Linux Foundation on 23 June 2025 with 100+ supporting companies, and Cisco's AGNTCY joined the Linux Foundation in July 2025. The emerging mental model is a layered stack rather than a winner-take-all fight: MCP for agent-to-tools, A2A for agent-to-agent, and AG-UI (from CopilotKit) for agent-to-user. Some fragmentation remains, most visibly the overloaded "ACP" acronym, claimed simultaneously by IBM's Agent Communication Protocol, Zed's Agent Client Protocol, and an Agentic Commerce Protocol.

Two more tiers sit underneath. Observability is both consolidating and heavily funded: LangSmith is LangChain's proprietary platform, Langfuse (open-source, MIT) was acquired by ClickHouse in January 2026 as ClickHouse announced a $400M Series D, and Braintrust raised $80M at roughly $800M in February 2026, alongside open-source options including Arize Phoenix (under the more restrictive Elastic License 2.0), OpenLLMetry and Traceloop, Helicone, AgentOps, and W&B Weave. Tracing is no longer optional; integrations like LangSmith and Pydantic Logfire enable real-time monitoring of agent trajectories and the time-travel debugging that durable execution makes possible.

Finally, a distinct memory layer has crystallised as its own tier, sitting above the vector databases it uses for storage: Mem0 (Apache-2.0, a $24M Series A in October 2025), Letta (formerly MemGPT), and Zep (built on Graphiti temporal knowledge graphs). The vector databases commonly paired with agents, Qdrant, Chroma, Weaviate, proprietary Pinecone, and the pgvector Postgres extension, increasingly serve as substrate beneath these memory frameworks rather than as the memory solution themselves.

What it means for builders

Four throughlines tie the layers together, and they are the most defensible way to read 2026.

If you are weighing this decision for a real system rather than a prototype, the layer you pick matters less than whether the surrounding harness is built to survive production. See how we build AI agents that run inside the tools a business already uses, or tell us what you are building on today. We will give you a straight answer about whether it will hold.