It is a software toolkit for building AI agents that can read, act, and check their own work.

SDK stands for software development kit, which is a package of ready-made building blocks that programmers use to build something. The Claude Agent SDK gives developers the same agent loop, built-in tools, and context management that power Claude Code, available in the TypeScript and Python programming languages. According to Anthropic’s documentation, it was formerly called the Claude Code SDK, and the name changed because it is useful for far more than coding.

In simple terms, the SDK handles the hard, repetitive parts of running an agent. When Claude decides to read a file, run a command, or search the web, the SDK carries out that action and hands the result back to Claude, which then decides what to do next. This repeats until the task is complete. With the ordinary Claude API, a developer must write that loop by hand. With the Agent SDK, the loop is already built.

flowchart LR
    A["Your program gives Claude a task"] --> B["Claude decides what to do"]
    B --> C["The SDK runs the tool: read, edit, search, or run"]
    C --> D["The result goes back to Claude"]
    D --> E{"Is the task done?"}
    E -- "No" --> B
    E -- "Yes" --> F["Your program receives the final result"]
        

A few simple words appear again and again in this topic. Here they are in plain English.

An agent is an AI that does work, not just an AI that answers questions.

In an ordinary chat, you ask a question and get an answer. The AI does not leave the conversation. An agent is different. Given a goal, such as “find and fix the bugs in this file”, it can read the file, understand it, edit it, run the tests, notice that a test failed, and try again. It uses tools to affect the world outside the chat, and it uses the results of those tools to decide its next move.

This ability is powerful because many real jobs are not single questions. They are chains of steps where each step depends on what the previous one revealed. An agent can handle such chains without a human guiding every step. That same freedom is also why safety matters so much, a point we return to later.

Three related things share the same family, and it helps to tell them apart.

There are three ways a developer might use Claude, and each sits at a different level. The Messages API is the most basic: you send a request and receive a reply, and you write any loop or tool handling yourself. Claude Code is a finished product for software engineers, where Claude works in a terminal and other places. The Agent SDK sits between them: it offers the engine of Claude Code as a library you can program, so you can build your own agent products without starting from nothing.

flowchart TD
    A["Claude models"] --> B["Messages API: you build the loop"]
    A --> C["Agent SDK: loop, tools, permissions included"]
    C --> D["Claude Code: a finished product on the same engine"]
    C --> E["Your own custom agent"]
        

The SDK comes with the main parts of an agent already assembled.

A first agent can be small, and it is worth keeping it that way.

Anthropic’s quickstart guides a developer through a short, practical first agent: one that reviews a small file for bugs and fixes them. The steps are simple to describe even if you are not a programmer. You install the SDK for your language, make sure your access credentials are set up securely, write a short program that gives the agent a task and a list of allowed tools, and run it. As the agent works, the program receives a stream of messages that show what Claude is doing, ending with a final result.

Tools are the agent’s hands. You decide which hands it gets.

Without tools, an agent can only talk. With tools, it can act. The quickstart shows that tools come in useful groups. Some tools only read, such as reading a file and searching for files or text. Others change things, such as editing a file. Others run commands on the machine, which is the most powerful and the most risky. Web search and web fetching let the agent look things up online.

The key lesson is to give the agent the smallest set of tools that lets it do its job. The documentation shows this clearly with example sets: read-only tools for analysis, read and edit tools for fixing code, and a broader set including command running for full automation.

Permissions set both which tools are allowed and how much human approval is needed.

The SDK offers two related controls. The first is the list of allowed tools, which decides which tools the agent may use at all. The second is the permission mode, which decides how much human oversight you want, from asking before actions, to automatically approving file edits, to approving everything. The quickstart shows a common middle setting in which file edits are approved automatically, while other actions still follow the usual rules.

Anthropic’s documentation also gives a precise caution about outside tools connected through MCP. These tools require explicit permission before Claude can use them. It advises preferring an explicit list of allowed tools over broad permission modes for this access, because the most permissive mode approves outside tools but also disables all other safety prompts, which is broader than necessary. In other words, give access to exactly the server you need, and nothing more.

flowchart TD
    A["Agent wants to use a tool"] --> B{"Is the tool on the allowed list?"}
    B -- "No" --> C["Blocked"]
    B -- "Yes" --> D{"What does the permission mode say?"}
    D -- "Ask" --> E["Pause for human approval"]
    D -- "Auto-approve for this kind of action" --> F["Run the tool"]
    D -- "Custom rule" --> G["Your code decides"]
        

Hooks let your own rules step in at key moments.

A hook is a point in the agent’s life at which your code gets a say. For example, before the agent uses a tool, a hook can look at what it is about to do. If the action breaks a rule, such as touching a protected folder, the hook can block it. After a tool runs, another hook can record what happened for an audit trail. Hooks turn a general-purpose agent into one that obeys your organization’s specific rules.

Big jobs go better when a main agent can hand pieces to helpers.

A subagent is a helper agent that the main agent can call on to do a focused piece of work. According to the documentation, each subagent has its own instructions, its own tool permissions, and its own working context. This has two benefits. First, the helper’s detailed reading and exploring happens off to the side, so the main agent’s context stays tidy and focused. Second, you can give each helper only the tools its small job requires, which keeps the power of each one narrow.

MCP is a standard way to plug outside tools and services into an agent.

Real work often needs information or actions from systems beyond files and commands: a ticket tracker, a database, a document store, a chat tool. The Model Context Protocol, or MCP, is an open standard for connecting AI agents to such services. The Agent SDK supports it, so a developer can attach an MCP server and the agent gains access to the tools it offers.

Two more controls shape how your agent behaves over time.

Custom system prompts

The SDK lets you give your agent a custom system prompt, which is a standing set of instructions about its role and rules. This is how an agent becomes a code reviewer, a research helper, or a support triager. Clear, specific instructions, kept as short as the job allows, work best, and sensitive secrets should never be placed in them.

Sessions

A session is one continuous piece of agent work. The documentation describes ways to continue, resume, or branch sessions, so that work can pick up where it left off instead of starting again. This helps with long tasks and with returning to earlier work. It also means that sessions can hold sensitive material, so treat stored sessions with the same care as other records.

The SDK is general. Its best uses are jobs that involve many steps and real tools.

An agent that can act needs more care than a chatbot that can only talk.

Let us follow an imagined developer named Arun as he builds his first agent.

Arun began small, kept the agent read-only at first, checked its work, added power one step at a time, and enforced limits in code. That is the habit of a careful agent builder.

Most agent problems come from a few avoidable habits.

The SDK saves a great deal of work and adds responsibility.

A checklist to keep beside you when you start building.

Quick answers to the questions beginners ask most often.

A toolkit, available for TypeScript and Python, that gives developers the same agent loop, built-in tools, and context management that power Claude Code, so they can build their own AI agents.

It is the renamed version. Anthropic’s documentation says the Claude Code SDK is now the Claude Agent SDK, reflecting that it is useful for much more than coding.

With the Messages API you write the tool-handling loop yourself. With the Agent SDK, the loop, built-in tools, and permission system are already provided.

It can read and search files, edit them, run commands, and search the web, depending on the tools you allow, and it can connect to outside systems through MCP.

Through a list of allowed tools, a permission mode that sets how much approval is needed, and hooks that let your own code approve, change, or block actions.

A helper agent that the main agent can hand a focused job, with its own instructions, tool permissions, and context, so the main conversation stays tidy.

The Model Context Protocol, an open standard for connecting AI agents to outside services. The SDK supports it, and the documentation notes that MCP tools need explicit permission.

It can be, if you work on a copy or version-controlled project in an isolated environment, grant minimal tools, keep approvals on at first, and review the changes. Never use your only copy.

Start with a small, read-only agent in a practice folder. Check its work, then add one capability at a time, with limits and logging in place.

You need to be comfortable with programming in TypeScript or Python. The quickstart is designed to get a first agent running quickly, but careful design and testing still take skill.

Agent runs use tokens, and billing arrangements, including how usage relates to subscription plans, have changed over time. Check the current documentation and your account information before running large jobs.

In the Agent SDK overview, quickstart, permissions, hooks, subagents, and MCP pages of Anthropic’s documentation, and in the TypeScript and Python reference pages.

The Claude Agent SDK is a toolkit for TypeScript and Python that packages the engine behind Claude Code, including the agent loop, built-in tools, permissions, hooks, subagents, MCP connections, sessions, and context management, so developers can build their own agents instead of writing everything from scratch. It sits between the basic Messages API and the finished Claude Code product. Because agents take real actions, the most important skills are safety skills: give the smallest set of tools, begin read-only, keep approvals on while learning, work on copies in isolated environments, guard credentials, treat outside content as untrusted, enforce rules in code with permissions and hooks, cap time and cost, and keep humans in the loop for important actions. Built this way, the SDK can turn a good idea into a useful, controlled agent.