Agentic APIs - Landscape Notes
Personal notes and opinionated takes on the agentic API landscape as of March 2026.
The Big Picture
The agentic space has converged on a clear stack:
Layer 3: Products Claude Code, Copilot CLI, Cursor, Aider
Layer 2: SDKs Claude Agent SDK, OpenAI Agents SDK, Copilot SDK
Layer 1: Protocols MCP (tools), A2A (agents), ACP (merged into A2A)MCP won the tool-integration layer. A2A is winning the agent-to-agent layer. The SDK layer is still fragmented.
What Actually Matters
MCP is the one protocol you need to know
MCP has won adoption. Claude, Copilot, Cursor, Windsurf, VS Code - they all support it. If you’re building tools that agents can use, build an MCP server. Everything else follows.
A2A matters for multi-agent systems at scale, but most developers won’t need it directly. Your SDK handles A2A for you.
ACP is dead (merged into A2A). Historical interest only.
The SDKs are converging
All three major SDKs (Claude, OpenAI, Copilot) have the same core abstraction: Agent = model + tools + instructions + loop. The differences are:
- Claude: best reasoning (extended thinking), largest context, computer use
- OpenAI: best multi-agent primitives (handoffs, guardrails, tracing)
- Copilot: best language coverage (Go, .NET), GitHub integration
If you’re building production agents, pick based on your constraints (model preference, language, ecosystem) rather than API design. They’re all good enough.
Agentic CLIs are the real product
The SDKs are plumbing. The CLIs are where the value is. Claude Code and Copilot CLI are genuinely useful tools today. Understanding how they work (tool systems, permission models, context management) is more practical than knowing API details.
Key Decisions
When building agents
| Decision | Recommendation |
|---|---|
| Which SDK? | Match your model preference. Claude SDK for Claude, OpenAI for GPT, Copilot for multi-model. |
| Which protocol for tools? | MCP. Always MCP. |
| Single vs multi-agent? | Start single. Add agents only when you hit context or specialization limits. |
| Framework (LangGraph, CrewAI)? | Skip unless you need their specific features. The vendor SDKs are sufficient for most use cases. |
When consuming agents
| Decision | Recommendation |
|---|---|
| Which CLI? | Claude Code for transparency and hackability. Copilot CLI for GitHub integration. Aider if you want git-native. |
| IDE agent mode? | Copilot agent mode in VS Code is the most mature. Cursor’s Composer is close. |
| Autonomous coding agent? | Copilot Coding Agent for GitHub issues. Claude Code with --dangerously-skip-permissions for local tasks. |
Framework Landscape (LangGraph, CrewAI, AutoGen)
These exist but are losing relevance as vendor SDKs mature:
- LangGraph - graph-based agent orchestration. Good if you need complex state machines. Overkill for most use cases.
- CrewAI - role-based multi-agent framework. Good metaphor (agents as team members) but limited flexibility.
- AutoGen/AG2 - Microsoft’s multi-agent conversation framework. Powerful but complex. Being superseded by the Copilot SDK for Microsoft ecosystem.
My take: unless you have a specific need these frameworks solve, use the vendor SDKs directly. Less abstraction, fewer dependencies, more control.
Things to Watch
- GitHub Agentic Workflows - Markdown-defined CI/CD with AI. Could change how we think about automation. Technical preview now.
- A2A adoption - if A2A reaches critical mass, agent-to-agent delegation becomes a reality, not just a demo.
- MCP server ecosystem - the more MCP servers exist, the more capable every agent becomes. This is a network effect.
- Cost - agentic workflows are expensive. Each tool call is an API call. A complex task can cost $1-5 in API calls. Watch this when building production systems.
- Copilot SDK GA - when it leaves preview, it’ll be the easiest way to embed agentic capabilities in Go/.NET apps.
Two Permission Philosophies
A fundamental split is emerging:
- OS-level sandboxing (Codex CLI) - kernel-level isolation (Seatbelt, Landlock). Stronger guarantees, coarser control. Can’t be prompt-injected around.
- Application-level rules (Claude Code) - pattern matching + hooks. Fine-grained, programmable, cross-platform. Runs in same process.
Neither is “right.” Codex for untrusted environments, Claude Code for power users.
AGENTS.md - Watch This
An emerging cross-tool standard for repo-level agent instructions. Already supported by Codex, Cursor, Copilot, and Windsurf. Claude Code still uses proprietary CLAUDE.md, Gemini uses GEMINI.md. Convergence seems inevitable.
Context: Brute Force vs Smart Retrieval
Two camps:
- Brute force (Gemini CLI, Codex): 1M token context, just load everything. Simple but expensive.
- Smart retrieval (Claude Code, Aider): 200K context + summarization/repo maps. Cheaper, but can miss things. Aider’s tree-sitter repo maps achieve 98% token reduction.
Gotchas
- Context window is the real bottleneck. Not model quality, not tool availability. Managing context is the hard problem.
- Agents are non-deterministic. Same prompt, different results. Don’t build systems that require exact reproducibility.
- Permission models are immature. Most systems are either “ask for everything” (annoying) or “allow everything” (dangerous). This will improve.
- Tracing is essential. Multi-step agent workflows are impossible to debug without tracing. Use OpenAI’s built-in tracing or add your own from day one.
- Cost compounds fast. An agent that makes 20 tool calls at $0.01 each seems cheap. At 1000 users/day, that’s $200/day just for one workflow.
- Agent Skills are the cross-cutting standard. SKILL.md files with YAML frontmatter work across Copilot and Claude Code. Progressive loading (metadata for discovery, full body on match). Worth adopting even if you only use one tool today.