Agent SDKs & Protocols

AI agents are programs that use language models to reason, plan, and take action — calling tools, reading files, browsing the web, or coordinating with other agents. Building agents requires two things: an SDK to orchestrate model calls and tool use, and protocols so agents can discover and communicate with external services. This section covers the major vendor SDKs for building agents and the emerging protocols that let them interoperate.

Each major AI lab now ships an official SDK for building agentic applications on top of their models. These SDKs handle the orchestration loop — sending messages, parsing tool calls, executing tools, and feeding results back to the model — so you can focus on defining the tools and behavior your agent needs.

Here is a minimal example of building an agent with the Claude Agent SDK. You define tools as decorated Python functions, create an Agent with a model and system prompt, and call run() to start the orchestration loop. The SDK handles sending tool calls to your functions and feeding results back to the model automatically.

from claude_agent_sdk import Agent, tool

@tool
def search_docs(query: str) -> str:
    """Search documentation for relevant info."""
    return f"Results for: {query}"

agent = Agent(
    model="claude-sonnet-4-6",
    tools=[search_docs],
    system="You are a helpful coding assistant."
)
result = agent.run("How do I set up MCP?")

The @tool decorator automatically generates a JSON schema from the function signature and docstring. When the model decides to call search_docs, the SDK executes the function, passes the result back, and lets the model continue reasoning. This loop repeats until the model produces a final text response.

SDKs let you build agents, but protocols let agents connect to the outside world and to each other. Three protocols are emerging as standards: MCP for connecting agents to tools and data sources, A2A for agent-to-agent communication, and AGENTS.md for capability discovery. Together they form the "connective tissue" of the agentic ecosystem.

The agent ecosystem is moving fast, and there is no single "right" choice. Vendor SDKs give you the tightest integration with a specific model — if you are building on Claude, the Claude Agent SDK will give you access to features like extended thinking and computer use that generic frameworks cannot. If you need multi-agent handoffs, the OpenAI Agents SDK has first-class support. For multi-modal use cases, Google ADK is purpose-built.

Protocols, on the other hand, are model-agnostic. Adopting MCP means your tools work with any agent that speaks MCP — Claude Code, Cursor, Windsurf, and dozens of other clients. Publishing an AGENTS.md makes your agent discoverable without any infrastructure changes. These are safe investments regardless of which SDK you choose.

We are in the early days of agent infrastructure — roughly where web development was in 1995. SDKs, protocols, and conventions are evolving rapidly. The patterns that matter most right now are: define your tools cleanly (MCP), give your agent clear instructions (system prompts and AGENTS.md), and instrument everything (tracing and logging). The specific libraries will change; the principles of clean tool interfaces and observable behavior will not.

As you build your own agents, remember that the goal is not to automate everything — it is to automate the right things. An agent that reliably handles 10 well-defined tasks is more valuable than one that attempts 100 tasks and fails unpredictably. Start small, test thoroughly, and expand the agent's capabilities as you build confidence in its reliability.