The Claude Agent SDK Just Changed Everything About Building AI Agents

What if you could give an AI the exact same tools you use every day?

Not a chatbot. Not a text generator. A digital worker with access to a terminal, a file system, and the ability to run code until a job is done.

That is exactly what Anthropic built. And on September 29, 2025, they released it to the world.

From Coding Tool to Universal Agent Engine

Here is the origin story that most people missed.

Anthropic originally built Claude Code as an internal tool for their own developers. The goal was simple: help programmers write better code faster. Claude Code could find files in a codebase, write and edit code, run tests, debug errors, and iterate until everything worked.

Then something unexpected happened.

Teams across Anthropic started using it for everything except coding. Deep research. Video creation. Note taking. Data analysis. Internal knowledge management. The tool designed for programmers became the engine powering almost every major workflow at the company.

The team realized they had built something much bigger than a coding assistant. They had built a general purpose agent harness.

So they renamed it. The Claude Code SDK became the Claude Agent SDK.

The Core Principle: Give Your Agent a Computer

Most AI agents work through predefined tools and rigid API calls. You build a tool for each specific action, wire everything together, and hope your agent knows when to use what.

The Claude Agent SDK takes a radically different approach.

Instead of giving Claude a list of tools, you give it a computer. Access to bash commands. The ability to read and write files. Permission to run code. The same environment a human knowledge worker operates in.

This single design decision unlocks capabilities that were previously impossible.

Need your agent to process a PDF attachment? It can write Python to extract the text, parse the content, and search for relevant information.

Need it to create a visualization? It can write the code, generate the chart, and iterate on the design until it looks right.

Need it to coordinate complex workflows across multiple systems? It can write scripts to handle each integration and orchestrate them programmatically.

The computer becomes the universal tool.

What You Can Build Today

The SDK gives you the primitives to automate almost any digital workflow. Here are the agent types developers are already building:

Finance Agents

Agents that understand your portfolio and investment goals. They can access market data through APIs, store historical information, run calculations through generated code, and provide analysis based on real numbers rather than generic advice.

Personal Assistants

Agents that go beyond simple scheduling. They can book travel by searching multiple options, manage your calendar across applications, prepare briefing documents by pulling context from various sources, and track information across conversations.

Customer Support Agents

Agents that handle high ambiguity requests by actually investigating the problem. They can pull customer data, check order history, review previous tickets, test potential solutions, and escalate to humans only when necessary.

Deep Research Agents

Agents that conduct comprehensive analysis across large document collections. They can search through file systems, cross reference information from multiple sources, synthesize findings, and generate detailed reports with citations.

The Agent Loop: How It Actually Works

Every effective agent follows the same fundamental pattern: gather context, take action, verify work, and repeat.

The Claude Agent SDK is built around this loop. Here is how each phase works in practice.

Gathering Context

Your agent needs more than a prompt. It needs the ability to find and retrieve relevant information on its own.

The SDK enables agentic search through the file system. When Claude encounters large files or document collections, it decides how to load information into its context using bash commands like grep, head, and tail. The folder structure itself becomes a form of context engineering.

For parallel information gathering, the SDK supports subagents. You can spin up multiple search agents simultaneously, each running different queries. They return only the relevant excerpts rather than full documents, keeping the main context focused.

When agents run for extended periods, the automatic compaction feature summarizes previous messages as the context limit approaches. Your agent can work for hours without running out of room.

Taking Action

Tools are the primary building blocks of execution. You define custom tools that Claude can invoke as needed. These become the main actions your agent considers when deciding how to complete a task.

Bash access provides flexibility for edge cases. Your agent can write and execute code on the fly when no predefined tool exists for a task.

The Model Context Protocol (MCP) provides standardized integrations to external services like Slack, GitHub, Google Drive, and Asana. Authentication and API calls are handled automatically, so your agent can interact with these systems without custom integration code.

Verifying Work

The SDK finishes the loop by evaluating output. Agents that check their own work are fundamentally more reliable.

Rule based feedback works best when you can define clear criteria. Code linting is a perfect example. The more specific the error messages, the better Claude can correct its mistakes.

Visual feedback matters for UI generation or formatted content. Your agent can screenshot its output and evaluate whether the result matches what was requested.

For fuzzier quality assessments, you can have a separate model judge the output. This adds latency but can catch issues that rules based checks miss.

Getting Started: The Technical Basics

The SDK is available in both Python and TypeScript. Here is a minimal example in Python:

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions

async def main():
    async for message in query(
        prompt="Find and fix the bug in auth.py",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Bash"]
        )
    ):
        print(message)

asyncio.run(main())

The Claude Code CLI is bundled with the package. No separate installation required.

Key configuration options include:

• allowed_tools: Control which capabilities your agent can use (Read, Write, Edit, Bash, Glob, Grep, and more)
• permission_mode: Set how the agent handles file modifications (interactive approval or automatic acceptance)
• max_turns: Limit how many iterations the agent can take
• system_prompt: Customize the agent's behavior and constraints
• output_format: Request structured JSON output matching a schema you define

The SDK supports authentication through the Anthropic API, Amazon Bedrock, or Google Vertex AI.

New Features That Matter

Recent releases have added capabilities that expand what agents can do:

Structured Outputs

Agents can now return validated JSON matching your schema. Define the structure you need, and the SDK ensures the output conforms. This makes it much easier to integrate agent results into downstream systems.

File Checkpointing

One of the most requested features. You can now save your agent's progress and roll back to previous states. This is essential for exploring different approaches or recovering from unwanted modifications.

Extended Context

Beta support for the context extension feature allows agents to work with much larger information sets. Enable it through the betas option in your configuration.

Custom MCP Tools

Beyond the growing ecosystem of pre built integrations, you can define custom tools as Python functions. These run as in process MCP servers, eliminating the need for separate processes.

The Bigger Picture

The Claude Agent SDK represents a shift in how we think about AI capabilities.

Traditional approaches treat AI as a function: input goes in, output comes out. The SDK treats AI as a worker: it has an environment, it can take initiative, it can iterate until the job is done.

This is the same infrastructure that powers Claude Code. The same system that lets Anthropic's own teams automate complex knowledge work across their organization. Now it is available to every developer.

The question is no longer whether AI can help with a task. It is whether you can give AI the right tools to figure out how.

Start Building

The Claude Agent SDK is available now through the Anthropic API. Documentation lives at docs.claude.com, and you can find the Python and TypeScript packages on GitHub.

If you are already building with the old Claude Code SDK, migration is straightforward. The core patterns remain the same. The namespace changed, and some method signatures updated for consistency.

The agents you build today are limited only by the tools you provide and the workflows you can imagine.

What will you build first?

---

This article explores the Claude Agent SDK released by Anthropic in September 2025. For the latest documentation and examples, visit the official Anthropic developer platform.