Claude Agent SDK (Anthropic)

Analogy - The Careful Doctor

Imagine two doctors. One gives instant prescriptions without listening much. The other listens carefully, thinks deeply, explains their reasoning, and asks for your consent before any procedure. Claude's agent approach is like the second doctor - it thinks step-by-step, explains its reasoning (extended thinking), and asks for permission before taking important actions. Safety and transparency are core values.

Anthropic's Agent Approach:

Anthropic provides the building blocks for agents rather than a heavy framework. Their philosophy is: Claude is already good at tool use and reasoning - you just need to put it in an agentic loop with the right tools. The key components are:

• Claude API with Tool Use: Claude excels at deciding when and how to use tools
• Extended Thinking: Claude shows its reasoning process before acting - visible chain-of-thought
• Model Context Protocol (MCP): A standard protocol for connecting AI agents to external data and tools
• Computer Use: Claude can control a computer GUI - click, type, navigate browsers
• Claude Code (CLI Agent): A production agent that writes, edits, and runs code autonomously

SDK vs Framework:

Unlike OpenAI's Agents SDK which provides a specific framework (Runner, Handoffs), Anthropic provides powerful primitives (tool use, thinking, MCP) and lets you build your own agent architecture. Think of it as giving you premium building materials vs giving you a pre-built house.

What is Extended Thinking?

Extended thinking lets Claude "think out loud" before responding. Before giving an answer or calling a tool, Claude writes out its reasoning in a thinking block. You can see exactly WHY it made each decision.

User: "Should I invest in Reliance or TCS for long term?"

[Claude's Extended Thinking - visible to developer]
"The user wants investment advice. I should NOT give specific
 investment recommendations as I am an AI. However, I can compare
 the two companies on fundamentals. Let me use the stock_data tool
 to get current financials. I should also add a disclaimer..."

[Claude's Response]
Calls: get_stock_fundamentals("RELIANCE")
Calls: get_stock_fundamentals("TCS")
Then provides a balanced comparison with disclaimer.

Why This Matters for Agents:

• Debuggability: When an agent makes a wrong decision, you can see exactly what it was thinking
• Better Decisions: Thinking before acting leads to more accurate tool selection and fewer mistakes
• Safety: You can audit the reasoning process, not just the final action
• Trust: Users and developers can verify the agent's logic chain

Budget Tokens:

You can control how much Claude thinks using a "thinking budget" (max_tokens for thinking). More thinking = better decisions but higher cost and latency. For simple tasks, a small budget works. For complex multi-step decisions, give it room to think deeply.

What is MCP?

Model Context Protocol (MCP) is an open standard created by Anthropic for connecting AI models to external data sources and tools. Think of it as USB for AI - just like USB created a universal connector for devices, MCP creates a universal connector for AI tools.

The Problem MCP Solves:

Before MCP, every AI app had to write custom integrations for every tool. Want to connect to Gmail? Write Gmail integration. Want Slack? Write Slack integration. Want a database? Write database integration. Now multiply that by every AI app that exists. MCP says: write the integration ONCE as an MCP server, and ANY MCP-compatible AI app can use it.

Before MCP:
  App1 -- custom code --> Gmail
  App1 -- custom code --> Slack
  App2 -- custom code --> Gmail  (duplicate!)
  App2 -- custom code --> Slack  (duplicate!)

With MCP:
  Gmail MCP Server (write once)
  Slack MCP Server (write once)
  App1 -- MCP protocol --> Gmail MCP Server
  App1 -- MCP protocol --> Slack MCP Server
  App2 -- MCP protocol --> Gmail MCP Server  (reuse!)
  App2 -- MCP protocol --> Slack MCP Server  (reuse!)

MCP Architecture:

• MCP Host: The AI application (Claude Desktop, your custom app)
• MCP Client: Connects to MCP servers, manages connections
• MCP Server: Provides tools, resources, and prompts. Each server wraps one data source or service
• Transport: Communication layer (stdio for local, SSE/HTTP for remote servers)

The Agentic Loop Pattern:

Anthropic recommends a simple agentic loop rather than complex frameworks:

1. Get user input
2. Call Claude with tools + extended thinking
3. While Claude returns tool_use:
   a. Execute the tool
   b. Send result back to Claude
   c. Claude decides: use another tool OR respond
4. Return Claude's final response to user

This simple loop handles 90% of agent use cases.
No framework needed - just a while loop.

Claude Code - A Real Production Agent:

Claude Code is Anthropic's CLI tool that is itself an AI agent built with Claude. It can:

• Read and understand entire codebases
• Write, edit, and refactor code across multiple files
• Run terminal commands and tests
• Search the web for documentation
• Use MCP servers for additional capabilities

Claude Code demonstrates that powerful agents do not need heavy frameworks - just a good model, good tools, and a simple agentic loop.

Computer Use Agent:

Claude can control a computer like a human - moving the mouse, clicking buttons, typing text, and reading the screen. This enables automation of GUI-based tasks that have no API: filling web forms, using legacy enterprise software, or navigating complex admin panels.

Anthropic's Safety Guidelines:

• Ask, do not assume: If the task is ambiguous, Claude should ask for clarification rather than guessing
• Confirm before acting: For irreversible actions (deleting files, sending emails), always confirm with the user
• Fail gracefully: When a tool fails, explain what happened and suggest alternatives
• Stay in scope: Agents should refuse tasks outside their defined capabilities

Performance Tips:

• Use Haiku for simple tasks: Claude 3.5 Haiku is fast and cheap for routing, classification, and simple extraction
• Use Sonnet for most agents: Claude Sonnet offers the best balance of quality, speed, and cost
• Use Opus for complex reasoning: Reserve Opus for tasks requiring deep analysis and multi-step reasoning
• Cache system prompts: Use prompt caching to reduce costs for repeated conversations

MCP Best Practices:

• Keep MCP servers focused - one server per data source or service
• Add authentication and rate limiting to MCP servers
• Log all MCP tool calls for debugging and audit
• Use local (stdio) transport for development, remote (SSE) for production

Q: How does Anthropic's approach to agents differ from OpenAI's?

Q: What is MCP and why is it significant?

Q: What is extended thinking and why does it matter for agents?