In 12 months, we went from "AI coding assistants" to fully autonomous coding agents backed by competing SDKs, protocols, and ecosystems. Here's the definitive breakdown of who's winning — and what it means for engineering teams.

The Landscape in February 2026

Twelve months ago, building an AI agent meant stitching together LangChain, a vector database, and a prayer. Today, every major cloud provider and AI lab has shipped a purpose-built agent SDK. The market went from experimental to production-grade in a single year.

Here's the current state of play:

OpenAI

Codex + Agents SDK

OpenAI went all-in on agentic coding. GPT-5.3-Codex (February 2026) supports the full software lifecycle — debugging, deploying, monitoring, writing PRDs, and more. The latest Codex-Spark variant runs on Cerebras chips, delivering 1,000+ tokens per second.

The Agents SDK provides three core primitives: Agents, Handoffs, and Guardrails. It has the lowest learning curve of any framework — a working agent in under 20 lines of code.

Key features: Built-in worktrees, parallel cloud environments, Skills for code understanding, Automations for CI/CD

Governance: Guardrails as a first-class SDK primitive. AGENTS.md donated to Linux Foundation.

Anthropic

Claude Code + Agent SDK + MCP

Anthropic took the safety-first approach. Claude Code pioneered OS-level sandboxing with filesystem and network isolation. The permission model defaults to read-only, requiring explicit user approval for every mutation.

The Model Context Protocol (MCP) — Anthropic's open standard for agent-tool communication — became the de facto industry standard. In December 2025, Anthropic donated MCP to the newly formed Agentic AI Foundation under the Linux Foundation, co-founded with OpenAI and Block.

Key features: OS-level sandboxing (bubblewrap/seatbelt), multi-agent teams, MCP ecosystem

Governance: Best-in-class. Sandboxing reduces permission prompts by 84%. Detected first AI-orchestrated cyberattack.

AWS

Strands Agents + Bedrock AgentCore

AWS entered the agent SDK race in May 2025 with Strands Agents (Apache-2.0 licensed). Version 1.0 shipped in July with multi-agent orchestration, the Agent-to-Agent (A2A) protocol, and session management. TypeScript support arrived in December 2025.

Bedrock AgentCore provides the enterprise runtime: serverless deployment, OAuth/Cognito/IAM identity, CloudWatch observability, and support for 8-hour long-running tasks. It's the most enterprise-ready deployment story in the market.

Key features: A2A protocol, edge device support, Strands steering, evaluation framework

Governance: Best identity story (OAuth, Cognito, IAM). Native observability with OTEL.

GitHub

Copilot Agent Mode + Coding Agent

GitHub's agent strategy is distribution. With 4.7 million paid Copilot users as of January 2026, agent mode is now the default workflow for complex tasks. The Copilot Coding Agent (launched at Build 2025) lets you assign GitHub issues directly to Copilot, which then reads the codebase, writes code, runs tests, and opens draft pull requests.

Project Padawan previews the fully autonomous future: assign an issue, walk away, come back to a reviewed PR.

Key features: Multi-model support (Claude, Gemini, OpenAI), next edit suggestions, agent session logs

Governance: GitHub's enterprise control layer. Session logs for full audit trail.

Cognition

Devin 2.0

The first "AI software engineer" grew up fast. Devin 2.0 (April 2025) slashed pricing from $500/month to $20/month, democratizing autonomous coding agents. ARR exploded from $1M to $73M in 9 months.

Enterprise customers include Goldman Sachs, Santander, and Nubank. Devin 2.0 introduced execution plans that users can edit and approve before task execution, addressing the governance gap.

Key features: Proactive codebase exploration, editable execution plans, enterprise integrations

Governance: Human-reviewable execution plans. Enterprise SSO and access controls.

The Framework Layer: LangGraph, CrewAI, and the Open-Source Ecosystem

Below the product layer, an equally fierce battle is playing out in open-source agent frameworks:

LangGraph

The market leader. Part of the LangChain ecosystem with 47M+ PyPI downloads. Graph-based state machines enable traceable, debuggable agentic workflows. Lowest latency and token usage in benchmarks.

Best for: Complex multi-step reasoning, production workloads needing observability

CrewAI

The fastest-growing multi-agent framework with 20,000+ GitHub stars. Unique role-based approach where agents collaborate like a crew — each with defined responsibilities, tools, and handoff protocols.

Best for: Multi-agent collaboration, role-based task decomposition

OpenAI Agents SDK

Minimal abstractions, maximum accessibility. Three primitives: Agents, Handoffs, and Guardrails. A working agent in under 20 lines of code. Nearly matches LangGraph in efficiency benchmarks.

Best for: Rapid prototyping, teams new to agent development

AWS Strands

Model-driven agents in a few lines of code. A2A protocol for inter-agent communication. TypeScript and Python support. Edge device deployment. Deep AWS integration via Bedrock AgentCore.

Best for: AWS-native teams, edge deployment, enterprise identity requirements

The Protocol Wars: MCP vs. A2A vs. AGENTS.md

The real battle isn't just about SDKs — it's about the protocols that define how agents communicate with tools, data sources, and each other. Three protocols are competing for dominance:

Model Context Protocol (MCP) — Anthropic → Linux Foundation

MCP defines how agents connect to external tools and data sources. Think of it as USB-C for AI agents — a universal interface that any tool can implement. Originally created by Anthropic, MCP was donated to the Agentic AI Foundation in December 2025.

Adoption: Supported by Claude Code, Cursor, Windsurf, GitHub Copilot, and dozens of open-source tools. MCP servers exist for Slack, GitHub, databases, file systems, and more. It's the clear winner for agent-to-tool communication.

Agent-to-Agent Protocol (A2A) — AWS/Google

While MCP handles agent-to-tool communication, A2A handles agent-to-agent communication. Developed by Google and adopted by AWS Strands 1.0, A2A enables seamless handoffs between agents, session state sharing, and coordinated multi-agent workflows.

Adoption: AWS Strands Agents, Google ADK. Still early, but critical for multi-agent architectures.

AGENTS.md — OpenAI → Linux Foundation

A standard for describing agent capabilities and behavior in plain text. Think of it as a README for AI agents — telling other agents and humans what an agent can do, what tools it has access to, and what guardrails it follows.

Adoption: Donated to the Agentic AI Foundation alongside MCP. Early stage but backed by OpenAI, Anthropic, and Block.

"The Agentic AI Foundation is the most significant industry collaboration since the Cloud Native Computing Foundation."

Anthropic, OpenAI, Block, Google, Microsoft, AWS, Cloudflare, and Bloomberg — all under one governance umbrella at the Linux Foundation.

The Comparison Matrix: What Matters for Engineering Teams

Choosing an agent stack isn't just about features. It's about governance, security, and how much control you retain over what your agents are doing. Here's what matters:

Capability	OpenAI	Anthropic	AWS	GitHub
Sandboxing	Cloud only	OS-level	Container	Cloud only
Permission Model	SDK-level	Read-only default	IAM-based	Enterprise controls
Agent Identity	API keys	Per-session	OAuth/IAM	GitHub SSO
MCP Support	Partial	Native	Yes	Yes
Multi-Agent	Handoffs	Teams	A2A protocol	Single agent
Audit Trail	API logs	Session logs	CloudWatch/OTEL	Session logs
Speed	1000+ tok/s	Fast	Varies by model	Multi-model

The Numbers That Define the Market

4.7M

Paid GitHub Copilot users (Jan 2026)

$73M

Devin ARR (June 2025, up from $1M in Sept 2024)

47M+

LangChain/LangGraph PyPI downloads

20K+

CrewAI GitHub stars

1,000+

Tokens/sec (OpenAI Codex-Spark)

Dec 2025

Agentic AI Foundation launched

The Missing Layer: Governance Across Agent Stacks

Here's the problem every engineering team faces: no matter which agent SDK you choose, governance is fragmented.

→ Your team uses Cursor for frontend, Claude Code for backend, and Copilot for DevOps. Each has different permission models, different audit trails, and different security postures.

→ Your architect sets coding standards in a design system doc. None of your AI agents know about it. Each generates code that diverges from the standard in different ways.

→ Your security team runs Snyk scans post-commit. But AI agents generate code 10x faster than humans. By the time vulnerabilities are detected, they've already been built upon.

→ Your PM tracks the roadmap in Linear. But a developer asks Claude to "quickly add" a feature that isn't on the roadmap. Nobody knows until the PR is open.

The agent SDKs are solving the capability problem brilliantly. What they're not solving is the governance problem: ensuring that all the code being generated — by whichever agent, in whichever IDE, using whichever model — aligns with your security policies, design systems, and strategic priorities.

The hard truth:

You can't build governance into every agent SDK. You need a governance layer that sits above all of them. One that understands your codebase, your design system, your roadmap — and validates every line of AI-generated code against those standards, regardless of which agent wrote it.

What to Bet On in 2026

If you're an engineering leader deciding where to invest, here are our predictions:

1. MCP Wins the Protocol War

With Anthropic, OpenAI, Google, Microsoft, and AWS all backing the Agentic AI Foundation, MCP is becoming the TCP/IP of agent communication. Invest in MCP-compatible tools and integrations.

2. Multi-Agent Becomes the Default

Single-agent architectures are already hitting limits. CrewAI, LangGraph, and Strands all point to the future: teams of specialized agents coordinating via protocols. Build your tooling around multi-agent from day one.

3. Governance Becomes a Product Category

Just as observability (Datadog), security scanning (Snyk), and CI/CD (GitHub Actions) became essential DevOps categories, AI code governance will become its own market. Teams need a unified layer that governs all AI agents regardless of SDK.

4. The EU AI Act Forces Everyone's Hand

August 2026 enforcement means every company deploying AI agents in the EU needs documented governance, audit trails, and human oversight. This isn't optional — it's regulatory. Fines reach up to 7% of worldwide turnover.

5. Speed Becomes a Commodity, Governance Becomes the Differentiator

With Codex-Spark hitting 1,000+ tokens/sec and every SDK optimizing for speed, raw velocity is becoming table stakes. The teams that win will be the ones that ship fast and ship right.

This is what Cortex is building

A unified governance layer that sits above every agent SDK. Real-time monitoring of AI-generated code against your security policies, design systems, and roadmap — regardless of whether it was written by Copilot, Claude, Cursor, or Codex.

See How Cortex Unifies AI Governance

The Agent SDK Wars: How OpenAI, Anthropic, and AWS Are Racing to Own the Agentic Stack