Agents

What it is

Overview

The orchestration layer that turns a model into an actor. An agent is a program that uses an LLM to decide which tools to call, in what sequence, until a goal is reached. The model provides the reasoning; the agent provides the loop, the tool registry, the memory, and the policy for when to stop.

Five things to keep in mind as you read:

• Agent = LLM + loop + tools + memory. Without the loop, it’s just a chat completion. Without the tools, it can’t act on the world.
• Two distinct shapes share the layer. Frameworks (libraries) and products (completed agents users install).
• Open frameworks and SDKs are mature. LangChainⓘLangChainagentsThe earliest widely-adopted LLM agent and RAG orchestration framework (2022), now with the LangGraph extension for stateful multi-step agent workflows. Chat about this → Open full entry →, LlamaIndexⓘLlamaIndexretrieval-memoryAn open-source RAG framework focused on connecting LLMs to external data, with strong document-ingestion tooling and a smaller surface area than LangChain. Chat about this → Open full entry →, CrewAI, Mastra, and the 2026 vendor agent SDKs (OpenAI, Anthropic, Google, Microsoft, AWS, Vercel). Almost every one is MIT or Apache-2.0.
• Closed end-user products dominate mindshare. Claude Code, Cursor, Devin. Open competitors exist (GooseⓘGooseagentsBlock's open-source coding agent, BYOK across multiple model providers, with MCP support and a permissive license; the most cited fully-open agent platform in 2026. Chat about this → Open full entry →, OpenHands, Aider) and are technically credible.
• This is the layer the user sees. Lock-in is tighter here than below because the agent owns the workflow.

The rest of this page walks the frameworks, then the products, then arrives at the sovereignty question that follows the user-experience layer.

The agent-SDK layer

An agent SDK is the build-it-in-code layer: a library that gives you the agent loop, a tool registry, memory and sessions, and multi-agent orchestration, so you do not reimplement them against a raw model API. It is distinct from a finished agent product (Claude Code, Cursor, Goose), which is an SDK someone else already assembled, and from a managed platform, where the vendor runs the agent for you.

In 2026 the layer splits two ways under the sovereignty lens: vendor agent SDKs from the model labs and hyperscalers (OpenAI, Anthropic, Google, Microsoft, AWS, Vercel) and independent, model-agnostic frameworks (LangChain, LlamaIndex, CrewAI, Pydantic AI, Mastra).

Agent SDKs compared

Four things stand out, and the first two cut against the expected “vendor equals lock-in” story:

• The vendor SDKs are open, and mostly model-agnostic. All six vendor SDKs ship under MIT or Apache-2.0, and five of the six work across many model providers (Vercel through a unified provider API, the others through LiteLLM or provider connectors). You can point most of them at open-weights models.
• The Claude Agent SDK is the real outlier. It is the only model-tied SDK in the set (Claude only, though servable via the Anthropic API, Amazon Bedrock, Google Vertex, or Azure), and its license needs care: the package is MIT, but its README states that use is governed by Anthropic’s Commercial Terms of Service. Open code, gated use.
• MCP is close to table stakes. Every vendor SDK, plus Pydantic AI and Mastra, ships MCPⓘMCPprotocolsAn open protocol from Anthropic that standardizes how language models discover and call external tools, data sources, and prompts via a small JSON-RPC interface. Chat about this → Open full entry → support in the core library. The three older independents reach it through a separate package instead: LangChain via langchain-mcp-adapters, LlamaIndex via llama-index-tools-mcp, CrewAI via crewai-tools. The protocol itself sits at the protocols layer.
• Microsoft folded AutoGen and Semantic Kernel into one framework. The Microsoft Agent Framework reached 1.0 in April 2026, superseding both AutoGenⓘAutoGenagentsA Microsoft Research framework for multi-agent systems, with a conversation-pattern API for orchestrating multiple specialized agents to solve tasks collaboratively. Chat about this → Open full entry → and Semantic Kernel, which are now maintenance-only. On Microsoft’s stack, this is the current framework to start from, not AutoGen.

What is left to tell them apart is language and opinionation. The Vercel AI SDK and Mastra are the TypeScript-native picks; the rest are Python-first, with Google ADK the most multi-language (five). On opinionation, LangGraph hands you low-level graphs to wire yourself, while CrewAI gives you batteries-included role-based “crews”. The agent loop itself is short; what an SDK adds is the tool integrations, the session and memory wiring, the streaming, and production-grade tracing. For a small team, picking one and standardizing matters more than picking the theoretically best one.

End-user agent products

Completed agents the user installs and runs. This is where the sovereignty fight actually happens.

Open coding agents.

• Goose (Block) — open-source AI agent for software engineering, MCP-native, extensible via “recipes”. Apache 2.0 (Goose project).
• OpenHands (formerly OpenDevin) — open autonomous software engineering agent, runs in a sandboxed container, capable of multi-step coding tasks (OpenHands repository).
• Aider — terminal-first pair-programming agent, smallest surface area, runs against any model via an API key (Aider documentation).
• Cline — VS Code extension, open source, capable of full agentic workflows inside the editor (Cline repository).
• Continue — VS Code / JetBrains agent extension, open core with team-tier hosted features (Continue project).

Closed coding agents.

• Claude Code (Anthropic) — terminal-first agent built on Claude, the most-deployed closed coding agent of 2025-2026.
• Cursor (Anysphere) — VS Code fork with deeply-integrated AI features. The mindshare leader for developer-facing AI tooling.
• Devin (Cognition Labs) — autonomous software engineer positioned as a remote-worker replacement; closed.
• GitHub Copilot — the longest-running closed agent in the category, now agent-capable beyond completion.

The open coding agents are competitive on the well-defined task (“edit this codebase to do X”). They fall behind on the integrated-IDE experience and on the model that powers them (the closed agents bundle premier closed models by default).

What’s open and what isn’t

Layered.

• Open frameworks: every framework worth naming is open source. The framework layer is solved.
• Open products: Goose, OpenHands, Aider, Cline, Continue, plus a long tail. Cover most use cases.
• Closed products: Claude Code, Cursor, Devin, Copilot. Dominate developer mindshare.
• The model the agent runs against: orthogonal. An open agent can use a closed model; a closed agent can sometimes use open weights. The combination determines the sovereignty posture.

Four meaningful combinations:

Most developers in 2026 sit in the first row. The fourth row is viable; the trade-off is the closed-model performance edge, which is real but narrowing.

The editorial tension

The agent is the layer that sees the user. Everything below it (silicon, compute, weights, runtime, retrieval) shows up to the user through the agent’s UI. A team using Cursor with Claude is running closed AI even when every layer underneath could be open; a team using Goose with self-hosted DeepSeek is running open AI even when the broader market is dominated by closed products.

That asymmetry is why the sovereignty argument concentrates at this layer. The agent owns the workflow, the accumulated project context, the integration surface (filesystem, browser, shell access), and the model-selection policy. Changing underlying models is mechanically easy; changing agents requires rebuilding the workflow.

The strategic question for an open-AI advocate is whether the open agents close enough of the experience gap to displace the closed defaults at scale, or whether the closed products keep the developer mindshare and the open agents stay as the sovereignty option for users who specifically want it. The 2026 trajectory is the second one: Cursor and Claude Code are gaining share, the open agents are improving but not catching up on integration polish, and the “I use Goose because I want the open path” user is a small fraction of the developer audience. Whether that fraction grows enough to matter is the open question through 2027.