Anthropic-Platform on AI Knowledge Base

Agent SDK — Overview

Mon, 01 Jan 0001 00:00:00 +0000

Introduction to Anthropic’s Agent SDK for building custom AI agents with tool use, MCP, and sub-agents.

Build with Claude — Overview

Mon, 01 Jan 0001 00:00:00 +0000

Central hub for understanding how to build applications with the Claude API.

Introduction to the Anthropic Platform

Mon, 01 Jan 0001 00:00:00 +0000

Overview of the Anthropic API platform, Claude models, and what you can build.

Tool Use — Overview

Mon, 01 Jan 0001 00:00:00 +0000

How Claude calls external tools and functions — the foundation for building agentic systems.

Get Started

Mon, 01 Jan 0001 00:00:00 +0000

API key setup, first API call, and quickstart for the Anthropic platform.

Working With Messages

Mon, 01 Jan 0001 00:00:00 +0000

The Messages API is the core primitive — understand message roles, content blocks, and conversation structure.

Streaming

Mon, 01 Jan 0001 00:00:00 +0000

Server-sent events (SSE) streaming for real-time token delivery and responsive UIs.

Implement Tool Use

Mon, 01 Jan 0001 00:00:00 +0000

Step-by-step guide to implementing the tool use loop: define tools, handle tool_use responses, send tool_result.

Structured Outputs

Mon, 01 Jan 0001 00:00:00 +0000

Get reliable JSON outputs from Claude using tool_use or constrained decoding.

Extended Thinking

Mon, 01 Jan 0001 00:00:00 +0000

Enable Claude’s chain-of-thought reasoning for complex problems that benefit from step-by-step analysis.

Vision

Mon, 01 Jan 0001 00:00:00 +0000

Send images to Claude for analysis, OCR, diagram interpretation, and multimodal reasoning.

Prompt Caching

Mon, 01 Jan 0001 00:00:00 +0000

Cache system prompts and repeated context to reduce latency and costs by up to 90%.

Adaptive Thinking

Mon, 01 Jan 0001 00:00:00 +0000

Admin

Mon, 01 Jan 0001 00:00:00 +0000

Administration Api

Mon, 01 Jan 0001 00:00:00 +0000

Agent Loop

Mon, 01 Jan 0001 00:00:00 +0000

Api And Data Retention

Mon, 01 Jan 0001 00:00:00 +0000

Bash Tool

Mon, 01 Jan 0001 00:00:00 +0000

The bash tool gives Claude direct shell access to execute commands, making it one of the most powerful and dangerous built-in tools available. It enables agents to run scripts, install packages, manage files, and interact with system utilities, forming the backbone of coding and DevOps automation workflows. Be deliberate about sandboxing: without proper isolation, Claude can execute arbitrary commands with the permissions of the host process. Start with a restrictive allowlist of commands and expand carefully, and always prefer higher-level tools like the text editor for file modifications where available rather than piping through sed or echo.

Batch Processing

Mon, 01 Jan 0001 00:00:00 +0000

Batch processing is the single biggest lever for cutting Claude API costs on non-urgent workloads — it runs requests asynchronously at roughly half the price, which is why it appears in both the cost-optimization and deployment paths. Pay close attention to the 24-hour completion window and the polling and retrieval flow, since batches are not interactive and you design around eventual results. The common pitfall is reaching for batch on latency-sensitive paths where it does not belong. OpenAI offers an equivalent Batch API with a similar discount but a different file-based job format; read the rate-limits page next to see how batch sidesteps per-minute caps.

Best Practices

Mon, 01 Jan 0001 00:00:00 +0000

This guide distills hard-won patterns for building reliable agent skills that perform well across diverse user inputs and edge cases. Pay particular attention to the guidance on error handling within skill execution and how to design tool descriptions that minimize misuse by the model. A common mistake is writing overly generic skill descriptions, which leads Claude to invoke skills in inappropriate contexts and degrades overall agent quality. Start here after completing the skills quickstart to refine your implementations before deploying to production.

Beta

Mon, 01 Jan 0001 00:00:00 +0000

Beta Headers

Mon, 01 Jan 0001 00:00:00 +0000

Build A Tool Using Agent

Mon, 01 Jan 0001 00:00:00 +0000

Choosing A Model

Mon, 01 Jan 0001 00:00:00 +0000

The essential decision guide for anyone evaluating which Claude model to use. Anthropic organizes its models into tiers — Haiku for speed and cost efficiency, Sonnet for the best balance of capability and price, and Opus for maximum intelligence on complex tasks. For product leaders, the key insight is that model selection is a business decision, not just a technical one: choosing Haiku over Opus can reduce costs by 10-20x while still handling most routine tasks. Compare this tiered approach with OpenAI’s model lineup (GPT-4o, GPT-4o mini, o1) and Mistral’s range to understand how the industry structures the speed-cost-quality tradeoff.

Citations

Mon, 01 Jan 0001 00:00:00 +0000

Claude Api Skill

Mon, 01 Jan 0001 00:00:00 +0000

Claude Code Analytics Api

Mon, 01 Jan 0001 00:00:00 +0000

Claude Code Features

Mon, 01 Jan 0001 00:00:00 +0000

Claude In Microsoft Foundry

Mon, 01 Jan 0001 00:00:00 +0000

Claude On Amazon Bedrock

Mon, 01 Jan 0001 00:00:00 +0000

Claude On Vertex Ai

Mon, 01 Jan 0001 00:00:00 +0000

Claude Prompting Best Practices

Mon, 01 Jan 0001 00:00:00 +0000

This is the most practically useful prompt engineering resource from Anthropic and contains techniques that will materially improve your output quality. Focus on the XML tag structuring approach, which is Claude’s preferred method for delineating sections of complex prompts and produces notably better results than unstructured instructions. A common mistake is transferring prompt patterns that work well with GPT-4 directly to Claude without adaptation – Claude responds better to direct instructions and explicit role definitions than to few-shot example-heavy prompts. Read through the examples carefully and experiment with each technique in the API playground before applying them to production prompts.

Client Sdks

Mon, 01 Jan 0001 00:00:00 +0000

Code Execution Tool

Mon, 01 Jan 0001 00:00:00 +0000

The code execution tool lets Claude run Python code in a sandboxed environment during a conversation, enabling data analysis, mathematical computation, and rapid prototyping without requiring external infrastructure. This is particularly valuable for tasks where Claude needs to verify its own reasoning through computation rather than relying on mental arithmetic or approximation. Note that the sandbox has limited package availability and no network access, so complex data science workflows may hit dependency walls. Use this tool when you need deterministic computation results embedded directly in Claude’s response rather than asking the user to run code separately.

Compaction

Mon, 01 Jan 0001 00:00:00 +0000

Completions

Mon, 01 Jan 0001 00:00:00 +0000

Computer Use Tool

Mon, 01 Jan 0001 00:00:00 +0000

Computer use enables Claude to interact with desktop environments through screenshots, mouse clicks, and keyboard input, effectively giving it the ability to operate any GUI application. This opens up automation for legacy software, web applications behind authentication, and workflows that lack APIs. Be aware that computer use is significantly slower and less reliable than API-based tool calling – treat it as a last resort for tasks that genuinely have no programmatic interface. Start with constrained screen regions and simple click-type sequences before attempting complex multi-window workflows, and always implement human-in-the-loop checkpoints for destructive actions.

Content Moderation

Mon, 01 Jan 0001 00:00:00 +0000

This guide covers using Claude as a content moderation layer, including prompt design for classification, handling ambiguous cases, and calibrating sensitivity thresholds for different content categories. The practical impact is significant: a well-tuned Claude moderation pipeline can replace or augment dedicated moderation APIs at lower cost while offering more nuanced category distinctions. Pay attention to the latency and cost tradeoffs between using Haiku for high-volume screening versus Sonnet for borderline cases that need deeper reasoning. Combining Claude moderation with traditional keyword filters as a first pass is a pattern worth adopting early to keep API costs manageable at scale.

Context Editing

Mon, 01 Jan 0001 00:00:00 +0000

Context Windows

Mon, 01 Jan 0001 00:00:00 +0000

Cost Tracking

Mon, 01 Jan 0001 00:00:00 +0000

Cost tracking in agentic workflows is substantially more complex than single-call API usage because agents make multiple model calls, tool invocations, and potentially spawn sub-agents — all of which accumulate tokens. This guide shows how to instrument the Agent SDK to capture per-turn and per-agent cost breakdowns. Focus on the callback hooks that expose token counts at each step, as these are the foundation for building budget limits and alerting. Without proactive cost tracking, a single runaway agent loop can consume your entire API budget in minutes, making this essential reading before any production deployment.

Custom Tools

Mon, 01 Jan 0001 00:00:00 +0000

Custom tools are how you give your agent the ability to take actions beyond conversation – calling APIs, querying databases, executing code, or interacting with any external system. Focus on how the tool’s JSON schema definition directly affects the model’s ability to invoke it correctly; poorly described parameters are the most common source of tool invocation failures. Pay special attention to error handling within tool implementations, since unhandled exceptions will surface as opaque failures in the agentic loop. If your tools need to call external MCP servers instead, read the MCP integration guide as an alternative approach.

Customer Support Chat

Mon, 01 Jan 0001 00:00:00 +0000

Building an AI-powered customer support chatbot with Claude, including architecture patterns and quality safeguards.

Data Residency

Mon, 01 Jan 0001 00:00:00 +0000

Define Tools

Mon, 01 Jan 0001 00:00:00 +0000

Develop Tests

Mon, 01 Jan 0001 00:00:00 +0000

Effort

Mon, 01 Jan 0001 00:00:00 +0000

Embeddings

Mon, 01 Jan 0001 00:00:00 +0000

Enterprise

Mon, 01 Jan 0001 00:00:00 +0000

The enterprise skills guide addresses deployment concerns that only surface at organizational scale: access control, audit logging, skill versioning, and multi-tenant isolation. Focus on the permission model and how skill execution contexts are sandboxed — getting this wrong can expose one tenant’s data to another. A key pitfall is treating enterprise skill deployment as a simple extension of single-user patterns; the authentication and authorization layers add meaningful complexity to the skill lifecycle. Read this after the quickstart and best practices guides, as it assumes familiarity with core skill mechanics.

Errors

Mon, 01 Jan 0001 00:00:00 +0000

Eval Tool

Mon, 01 Jan 0001 00:00:00 +0000

Fast Mode

Mon, 01 Jan 0001 00:00:00 +0000

File Checkpointing

Mon, 01 Jan 0001 00:00:00 +0000

Files

Mon, 01 Jan 0001 00:00:00 +0000

Fine Grained Tool Streaming

Mon, 01 Jan 0001 00:00:00 +0000

Fine-grained tool streaming gives you granular control over how tool call arguments and results are delivered incrementally, which is essential for building responsive UIs on top of agentic workflows. Focus on the event types and their ordering — understanding the difference between input_json delta events and tool_result blocks determines how you parse partial tool invocations. One subtle pitfall is assuming tool arguments arrive as valid JSON at each delta; you need to buffer and parse only after the tool use block is complete. Read this after the general streaming guide to layer tool-specific streaming behavior on top of basic SSE handling.

Glossary

Mon, 01 Jan 0001 00:00:00 +0000

Handle Streaming Refusals

Mon, 01 Jan 0001 00:00:00 +0000

Streaming refusals present a unique UX challenge: tokens have already been sent to the client before the model decides to refuse, so you cannot simply suppress the response. This guide covers detection strategies and graceful recovery patterns for when Claude mid-stream determines a request violates safety guidelines. Pay close attention to the stop reason codes and how they differ from normal completion events — your streaming parser needs to handle refusal signals without crashing or displaying partial unsafe content. Implement these patterns early in development rather than retrofitting them after users encounter jarring truncated responses in production.

Handle Tool Calls

Mon, 01 Jan 0001 00:00:00 +0000

Handling Stop Reasons

Mon, 01 Jan 0001 00:00:00 +0000

Hooks

Mon, 01 Jan 0001 00:00:00 +0000

Hooks function similarly to middleware in web frameworks, giving you interception points at key stages of the agent’s lifecycle such as before and after tool calls, at the start and end of turns, and during error handling. This is where you implement cross-cutting concerns like logging, metrics, guardrails, and input/output validation without cluttering your core agent logic. A common pitfall is adding too much latency in hook functions, especially in before-tool hooks, which compounds across multi-step agent runs. Read this after you are comfortable with the basic agent loop and custom tools, as hooks are most useful once you understand what you need to observe or control.

Hosting

Mon, 01 Jan 0001 00:00:00 +0000

This guide covers the infrastructure considerations for running agents in production, including containerization, scaling, and managing long-running agent sessions. A key challenge with hosting agents compared to traditional APIs is that agent runs can take tens of seconds or even minutes due to multi-step tool use, which affects timeout configuration, connection pooling, and load balancer settings. Focus on the recommendations for stateless vs. stateful deployments, as this choice impacts how you handle conversation persistence and recovery from failures. Read this after the secure deployment guide, since security constraints will inform your hosting architecture decisions.

How Tool Use Works

Mon, 01 Jan 0001 00:00:00 +0000

Increase Consistency

Mon, 01 Jan 0001 00:00:00 +0000

Output consistency matters most when Claude powers automated pipelines where downstream code parses its responses. This guide covers techniques like temperature reduction, few-shot examples, structured output formats, and explicit schemas that make Claude’s responses more deterministic. The single biggest lever is providing concrete output examples in your prompt – this anchors the model’s formatting far more reliably than verbal instructions alone. Read this before building any system that pipes Claude output into JSON parsers, database inserts, or multi-step agent workflows.

Ip Addresses

Mon, 01 Jan 0001 00:00:00 +0000

Legal Summarization

Mon, 01 Jan 0001 00:00:00 +0000

Using Claude to extract key information from legal documents and generate structured summaries.

Library

Mon, 01 Jan 0001 00:00:00 +0000

Anthropic’s prompt library is one of the fastest ways to internalize effective prompting patterns for Claude. Rather than reading it cover-to-cover, focus on prompts in your domain and study the structural techniques they use – XML tags for delineation, role-setting in the system prompt, and explicit output format instructions. Pay attention to how each example balances specificity with flexibility; overly rigid prompts tend to break when inputs vary. These curated examples also serve as a useful baseline when benchmarking your own prompts against known-good patterns.

Manage Tool Context

Mon, 01 Jan 0001 00:00:00 +0000

Mcp

Mon, 01 Jan 0001 00:00:00 +0000

MCP integration is what makes the Agent SDK extensible beyond its built-in capabilities, letting your agents connect to any MCP-compatible tool server including databases, APIs, file systems, and custom services. Focus on how the SDK discovers and registers MCP tools at agent initialization, since this determines what capabilities your agent advertises during the agentic loop. A key gotcha is that MCP server connection lifecycle must be managed carefully – servers that fail to start will silently remove tools from your agent’s available set. If you are already familiar with MCP from the protocol specification, this guide shows the practical integration points within the SDK’s agent framework.

Mcp Connector

Mon, 01 Jan 0001 00:00:00 +0000

The MCP Connector is the primary mechanism for giving Claude direct access to external tools and data sources through the Model Context Protocol within API calls. Focus on how connector configuration differs from local MCP server setup — the connector handles transport, authentication, and tool discovery on Anthropic’s infrastructure rather than your own. A common pitfall is neglecting to scope tool permissions tightly, which can lead to unexpected token consumption when Claude explores available tools. Read this alongside the remote MCP servers guide to understand the full picture of hosted versus self-managed MCP integrations.

Memory Tool

Mon, 01 Jan 0001 00:00:00 +0000

The memory tool allows Claude to persist information across conversation sessions, enabling agents to maintain user preferences, project context, and learned patterns over time. This bridges the gap between stateless API calls and the continuity users expect from long-running assistant relationships. Focus on understanding what gets stored and how retrieval works, since overloading memory with low-value data degrades relevance of future recalls. Design your memory strategy around high-signal items like user corrections and workflow preferences rather than attempting to memorize entire conversation histories.

Messages

Mon, 01 Jan 0001 00:00:00 +0000

Migration Guide

Mon, 01 Jan 0001 00:00:00 +0000

Model migrations between Claude generations often introduce subtle behavioral changes that break existing prompts, even when the new model is strictly more capable. This guide documents the specific differences you should test for when upgrading, including changes to output formatting, tool-use patterns, and response length tendencies. Focus on the recommended testing strategies before doing a production cutover, since regressions frequently appear in edge cases rather than typical inputs. If you rely heavily on structured output or function calling, test those paths first as schema adherence can shift between model versions.

Migration Guide

Mon, 01 Jan 0001 00:00:00 +0000

This migration guide is critical reading if you have existing agent code built on earlier Anthropic SDK patterns or third-party frameworks and want to move to the official Agent SDK. Focus on the mapping between old abstractions and new ones — particularly how tool definitions, conversation state management, and multi-turn loops translate. A common pitfall is assuming one-to-one correspondence between concepts; the Agent SDK introduces opinionated patterns around agent lifecycle and handoffs that may require rethinking your architecture rather than just swapping imports. Work through the migration incrementally, validating behavior at each step rather than attempting a full rewrite.

Mitigate Jailbreaks

Mon, 01 Jan 0001 00:00:00 +0000

Jailbreak mitigation is essential for any production deployment where Claude interacts with untrusted user input. This guide covers defense-in-depth strategies including system prompt hardening, input validation, and output filtering. A common pitfall is relying solely on system prompt instructions for safety – attackers routinely bypass single-layer defenses, so layering multiple techniques is critical. Read this alongside the harmlessness screens documentation to understand how Anthropic’s built-in protections complement your application-level guardrails.

Model Deprecations

Mon, 01 Jan 0001 00:00:00 +0000

Models

Mon, 01 Jan 0001 00:00:00 +0000

Modifying System Prompts

Mon, 01 Jan 0001 00:00:00 +0000

System prompt modification in the Agent SDK controls how you customize agent behavior, persona, and constraints without forking the SDK’s default prompt scaffolding. Focus on the merge strategy — the SDK combines your custom instructions with its own internal prompts, and understanding this layering prevents conflicts where your instructions get overridden or diluted. A critical pitfall is inadvertently removing safety-relevant default instructions when overriding the system prompt wholesale rather than appending to it. Start with targeted modifications using the provided extension points before considering full prompt replacement.

Multilingual Support

Mon, 01 Jan 0001 00:00:00 +0000

Openai Sdk

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Mon, 01 Jan 0001 00:00:00 +0000

This is the essential reference for understanding the Claude model family and should be one of the first pages you read before building anything with the Anthropic API. Focus on the capability differences between model tiers (Haiku, Sonnet, Opus) as this directly impacts your cost, latency, and quality tradeoffs in production. Pay attention to context window sizes and maximum output token limits, since these constraints will shape your prompt design and chunking strategies. When comparing with OpenAI’s model lineup, note that Anthropic’s naming convention signals capability tier rather than generation number.

Overview

Mon, 01 Jan 0001 00:00:00 +0000

Anthropic’s taxonomy of proven AI use cases with implementation guidance for each.

Overview

Mon, 01 Jan 0001 00:00:00 +0000

This overview introduces the agent skills framework, which provides a structured way to package and distribute reusable capabilities that Claude-based agents can invoke. Skills sit between raw tool definitions and full agent architectures, giving you a composable middle layer for common tasks like code review, PR creation, or domain-specific analysis. Start here before reading the individual tool docs to understand how skills orchestrate multiple tools into cohesive workflows. The key architectural decision is which capabilities to implement as standalone tools versus packaged skills, and this doc provides the mental model for making that choice.

Overview

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Mon, 01 Jan 0001 00:00:00 +0000

This overview establishes the conceptual framework for prompt engineering with Claude and should be read before diving into specific techniques or best practices. Focus on how Claude’s instruction-following behavior differs from other models – Claude tends to be more literal in its interpretation of prompts, which means precise wording matters more than with some competitors. The page introduces key concepts like system prompts, role assignment, and output formatting that are referenced throughout all other prompt engineering materials. After reading this, proceed to the best practices guide for actionable techniques you can apply immediately.

Overview

Mon, 01 Jan 0001 00:00:00 +0000

Parallel Tool Use

Mon, 01 Jan 0001 00:00:00 +0000

Pdf Support

Mon, 01 Jan 0001 00:00:00 +0000

This is the reference for sending PDFs to Claude, and it matters because Claude processes both the extracted text and the rendered page images, letting it reason over tables, charts, and scanned layouts that plain text extraction would lose. Pay close attention to the page and size limits and to token accounting, since each page consumes both text and image tokens and costs add up fast. A common pitfall is assuming PDFs are as cheap as text. Compared with Mistral’s and OpenAI’s image inputs the differentiator is native multi-page document handling; read the token-counting page alongside this to estimate cost.

Permissions

Mon, 01 Jan 0001 00:00:00 +0000

Permissions are critical for production deployments where agents interact with external systems or sensitive data. Focus on the least-privilege principle: grant only the capabilities an agent actually needs, and be especially careful with tool permissions that allow file system access or network calls. A common pitfall is developing with permissive settings and forgetting to lock them down before deployment, which can expose your system to prompt injection attacks that leverage overly broad tool access. Read this alongside the secure deployment guide for a complete security posture.

Plugins

Mon, 01 Jan 0001 00:00:00 +0000

Plugins extend the Agent SDK’s core behavior by hooking into the agent lifecycle at well-defined extension points, enabling cross-cutting concerns like logging, rate limiting, and custom authentication without modifying agent logic directly. Focus on the plugin interface and the ordering guarantees for plugin execution — multiple plugins can compose, but execution order matters for plugins that modify requests or responses. A common mistake is putting business logic inside plugins rather than skills, which makes agents harder to test and reason about. Read this after understanding skills to appreciate the boundary between agent capabilities and infrastructure concerns.

Pricing

Mon, 01 Jan 0001 00:00:00 +0000

Understanding AI pricing is critical for any build-vs-buy decision. Anthropic charges per token (roughly per word) with different rates for input and output, and prices vary dramatically between model tiers — Haiku can be 50x cheaper than Opus per token. The practical implication: a customer support chatbot handling 10,000 conversations per day might cost $50/month with Haiku or $2,500/month with Opus, so model selection directly impacts unit economics. Pay attention to prompt caching and batch API discounts, which can cut costs by 50-90% for predictable workloads. Compare these structures with OpenAI and Mistral pricing to understand the competitive landscape before committing to a provider.

Programmatic Tool Calling

Mon, 01 Jan 0001 00:00:00 +0000

Programmatic tool calling lets you force Claude to invoke a specific tool rather than deciding autonomously whether to use one, which is essential for deterministic agentic workflows where you need guaranteed structured output on every turn. This is particularly useful when building pipelines that must always extract data into a schema or always query an external system before responding. Be aware that forcing a tool call changes Claude’s behavior around the rest of the response – it will not produce any text content before the forced tool invocation. Read the general tool-use guide first to understand the baseline calling conventions, then use this doc to layer in the deterministic control patterns.

Prompting Tools

Mon, 01 Jan 0001 00:00:00 +0000

This guide is the definitive reference for writing effective tool definitions that Claude can invoke reliably. Focus on how parameter descriptions and tool descriptions influence Claude’s decision about when and how to call each tool – vague descriptions lead to incorrect invocations or tool avoidance. A common mistake is defining too many tools in a single request, which degrades selection accuracy; the guide offers practical thresholds. If you are building agentic applications with Claude, read this before the broader tool use documentation, as well-crafted tool prompts are the foundation of reliable agent behavior.

Python

Mon, 01 Jan 0001 00:00:00 +0000

The Python SDK is the more mature of the two language implementations and tends to receive new features first. Pay close attention to the async patterns used throughout – the SDK is built on asyncio, so understanding Python’s async/await model is a prerequisite for effective use. If you are coming from the raw Anthropic API client, note that the Agent SDK manages conversation state and tool execution loops for you, which is a significant shift in how you structure your code. Read the quickstart guide first if you have not already, then use this reference for Python-specific configuration details.

Quickstart

Mon, 01 Jan 0001 00:00:00 +0000

This is the fastest path to a running agent and the best starting point before diving into advanced SDK features. Focus on the AgentConfig pattern, which is the central abstraction for defining agent behavior, tools, and instructions. Pay attention to how the SDK handles the agentic loop automatically – understanding what happens behind the scenes here will save you debugging time later. Read this before the Python or TypeScript language-specific guides so you have the conceptual model in place first.

Quickstart

Mon, 01 Jan 0001 00:00:00 +0000

This quickstart walks you through building your first agent skill end-to-end, from definition to invocation within a Claude-powered agent. Focus on the skill registration pattern and how the runtime discovers and exposes skills to the model — getting this wiring right is foundational for everything else. Be aware that the quickstart uses simplified error handling; production skills need retry logic and graceful degradation as covered in the best practices guide. Work through this hands-on before reading the enterprise or best practices docs to build concrete intuition first.

Rate Limits

Mon, 01 Jan 0001 00:00:00 +0000

Understanding rate limits is essential before any production deployment, because hitting them surfaces as 429 errors that silently degrade user-facing latency if you have not built retry-with-backoff. Pay close attention to the distinction between requests-per-minute and tokens-per-minute limits and to the role of usage tiers, since you can be well under the request cap but blocked on tokens. The common mistake is testing at low volume and discovering the ceiling only under real load. Pair this with the batch-processing page, which moves bulk work off your interactive rate budget entirely.

Reduce Hallucinations

Mon, 01 Jan 0001 00:00:00 +0000

Hallucination reduction is arguably the most impactful guardrail topic for practitioners building retrieval-augmented or factual applications with Claude. The guide covers grounding techniques such as providing source documents, instructing the model to quote directly, and asking it to flag uncertainty. A key gotcha is that simply telling Claude “don’t hallucinate” is far less effective than structuring prompts so the model can cite or decline – give it an explicit escape hatch like “say I don’t know if the answer isn’t in the provided context.” Pair this with the evaluation techniques in the testing docs to measure hallucination rates systematically.

Reduce Latency

Mon, 01 Jan 0001 00:00:00 +0000

Latency optimization directly impacts user experience and cost in production Claude deployments. This guide walks through techniques like prompt length reduction, streaming, model selection trade-offs, and caching strategies that can cut response times significantly. Start with the quick wins – enabling streaming and trimming unnecessary context from prompts – before moving to architectural changes like prompt caching. Be aware that some latency reduction techniques (such as using smaller models or shorter prompts) trade off against output quality, so always measure both metrics together.

Reduce Prompt Leak

Mon, 01 Jan 0001 00:00:00 +0000

Prompt leakage is one of the most common security concerns in production LLM applications, and this guide provides concrete techniques for preventing Claude from revealing system prompts to end users. Focus on the layered defense approach — no single technique is sufficient, so you need to combine prompt structure, output filtering, and behavioral instructions. A frequent mistake is relying solely on “do not reveal your instructions” directives, which are trivially bypassed by indirect extraction attacks. Read this alongside the general guardrails documentation to build a comprehensive safety posture before shipping user-facing agents.

Remote Mcp Servers

Mon, 01 Jan 0001 00:00:00 +0000

Remote MCP servers let you host tool endpoints that Claude connects to over the network, enabling shared infrastructure across teams and persistent service integrations. Pay close attention to the authentication and transport sections — remote servers use SSE or streamable HTTP rather than stdio, which changes how you handle connection lifecycle and error recovery. A frequent gotcha is failing to implement proper OAuth or token refresh flows, causing silent tool failures mid-conversation. This guide pairs well with the MCP Connector docs to compare Anthropic-hosted versus self-hosted approaches to serving tools.

Search Results

Mon, 01 Jan 0001 00:00:00 +0000

Secure Deployment

Mon, 01 Jan 0001 00:00:00 +0000

This guide becomes essential the moment you move an agent from local development to any shared or production environment. Focus on the sections covering input sanitization and output validation, as prompt injection through user-supplied content is the most common attack vector for deployed agents. Be aware that securing an agent is different from securing a traditional API – you must account for the model’s ability to chain tool calls in unexpected ways, so defense-in-depth with both permission restrictions and monitoring is necessary. Read this in conjunction with the permissions guide, as the two together form a complete security strategy.

Server Tools

Mon, 01 Jan 0001 00:00:00 +0000

Service Tiers

Mon, 01 Jan 0001 00:00:00 +0000

Sessions

Mon, 01 Jan 0001 00:00:00 +0000

Skills

Mon, 01 Jan 0001 00:00:00 +0000

Skills in the Agent SDK are the primary abstraction for packaging reusable capabilities that agents can invoke — think of them as higher-level building blocks above raw tool definitions. Focus on how skill registration exposes capabilities to the agent runtime and how the SDK handles skill discovery, parameter validation, and result formatting. A subtle but important detail is how skill descriptions influence the model’s decision to invoke them; poorly written descriptions lead to unreliable skill selection. Read this reference alongside the agent-skills quickstart and best practices guides for the full picture from concept to production-ready implementation.

Skills Guide

Mon, 01 Jan 0001 00:00:00 +0000

Skills are a powerful abstraction for packaging reusable capabilities that Claude can invoke within IDE integrations and agent workflows. This guide walks through defining, registering, and composing skills so your agent can dispatch specialized behaviors without bloating the system prompt. Pay close attention to how skill discovery works at runtime, since misconfigurations here silently degrade agent performance rather than producing obvious errors. Read this alongside the Agent Skills overview doc to understand the full lifecycle from definition to invocation.

Slash Commands

Mon, 01 Jan 0001 00:00:00 +0000

Stop Reasons

Mon, 01 Jan 0001 00:00:00 +0000

Streaming Output

Mon, 01 Jan 0001 00:00:00 +0000

This guide dives into the practical implementation details of consuming streamed agent output, which is distinct from the higher-level decision of whether to use streaming at all (covered in the streaming vs. single mode guide). Focus on the event types emitted during a stream, particularly the distinction between text delta events and tool-use events, since your UI rendering logic needs to handle both gracefully. Watch out for the connection drop scenario – if a stream disconnects mid-response, you need a strategy for resuming or restarting the agent turn. Understanding the event structure here is also essential if you plan to build custom frontends or integrate with frameworks like AG-UI.

Streaming Vs Single Mode

Mon, 01 Jan 0001 00:00:00 +0000

This guide addresses a fundamental architectural decision you will face early in any agent project. Single-turn mode is simpler to implement and debug because you get a complete response at once, making error handling straightforward and retry logic clean. Streaming mode provides real-time token-by-token output that is essential for user-facing applications where perceived latency matters, but it introduces complexity around partial results and connection management. Start with single-turn mode during development and prototyping, then migrate to streaming when you need production-quality user experience.

Strict Tool Use

Mon, 01 Jan 0001 00:00:00 +0000

Structured Outputs

Mon, 01 Jan 0001 00:00:00 +0000

Structured outputs let you constrain agent responses to conform to a specific schema, which is essential for building reliable pipelines where downstream code depends on predictable JSON shapes. Focus on how schema definitions interact with the agent loop — the SDK validates output at the framework level rather than relying on prompt engineering alone. A key gotcha is that overly complex schemas can increase latency and reduce output quality, so start with flat structures and add nesting only when needed. Compare this approach with OpenAI’s structured outputs to understand the tradeoffs in schema expressiveness and enforcement guarantees.

Subagents

Mon, 01 Jan 0001 00:00:00 +0000

Subagents enable multi-agent architectures where a parent agent delegates specialized tasks to child agents with their own instructions, tools, and models. Unlike the OpenAI Agents SDK handoffs pattern, which transfers control entirely to another agent, the Anthropic subagent model uses delegation semantics where the parent retains control and receives the subagent’s result. Focus on how context is passed between parent and child agents, since over-sharing context inflates token costs while under-sharing causes the subagent to lack necessary information. This is a key building block for complex workflows – read this after understanding single-agent patterns and before designing multi-agent systems.

Supported Regions

Mon, 01 Jan 0001 00:00:00 +0000

Text Editor Tool

Mon, 01 Jan 0001 00:00:00 +0000

The text editor tool gives Claude the ability to view, create, and edit files through structured operations like insert, replace, and undo, making it central to coding agent implementations. Unlike having Claude output code in a message for you to copy, this tool enables autonomous multi-step file modifications within an agentic loop. Focus on understanding the exact replacement semantics, since the tool requires unique string matches for edits and will fail if the target string appears multiple times. This tool works best when combined with the bash tool for running tests after edits, forming the core edit-verify cycle that coding agents depend on.

Ticket Routing

Mon, 01 Jan 0001 00:00:00 +0000

Using Claude to automatically classify and route support tickets to the right team based on content analysis.

Todo Tracking

Mon, 01 Jan 0001 00:00:00 +0000

Token Counting

Mon, 01 Jan 0001 00:00:00 +0000

The token-counting endpoint matters for cost control because it lets you measure exactly how many input tokens a request will consume before you send it, which is essential for budgeting and for staying under context limits. Pay attention to the fact that counts include the system prompt, tools, and images, not just the visible message text — an easy-to-miss source of surprise spend. Use it to validate prompt-caching savings and to size batches safely. Unlike OpenAI’s client-side tiktoken approach, Anthropic exposes counting as an API call that reflects the exact tokenizer the model uses.

Tool Combinations

Mon, 01 Jan 0001 00:00:00 +0000

Tool Reference

Mon, 01 Jan 0001 00:00:00 +0000

Tool Runner

Mon, 01 Jan 0001 00:00:00 +0000

Tool Search

Mon, 01 Jan 0001 00:00:00 +0000

Tool Search Tool

Mon, 01 Jan 0001 00:00:00 +0000

The tool search tool enables deferred tool loading, allowing agents with large tool catalogs to discover and activate tools on demand rather than loading everything into context upfront. This is critical for agents that integrate many MCP servers or have hundreds of available tools, since stuffing all tool definitions into the system prompt degrades model performance and wastes tokens. Pay attention to the query semantics: keyword search returns ranked matches while direct selection loads a specific tool by name. Architect your agent so that commonly used tools are always loaded and niche tools are deferred behind search to keep context windows lean.

Tool Use With Prompt Caching

Mon, 01 Jan 0001 00:00:00 +0000

Troubleshooting Tool Use

Mon, 01 Jan 0001 00:00:00 +0000

Typescript

Mon, 01 Jan 0001 00:00:00 +0000

The TypeScript SDK mirrors the Python SDK’s architecture but leverages TypeScript’s type system to provide compile-time safety for agent configurations, tool definitions, and event handlers. If you are choosing between the two language SDKs, note that the Python SDK generally receives feature updates first, but the TypeScript SDK offers stronger typing guarantees that catch configuration errors before runtime. Pay attention to how generics are used for tool input/output types, as properly typing your tools will give you autocompletion and validation throughout your agent code. Read the quickstart guide first for the conceptual model, then use this reference for TypeScript-specific patterns and idioms.

Typescript V2 Preview

Mon, 01 Jan 0001 00:00:00 +0000

Usage Cost Api

Mon, 01 Jan 0001 00:00:00 +0000

User Input

Mon, 01 Jan 0001 00:00:00 +0000

Versioning

Mon, 01 Jan 0001 00:00:00 +0000

Web Fetch Tool

Mon, 01 Jan 0001 00:00:00 +0000

The web fetch tool is an Anthropic-provided built-in tool that lets Claude retrieve content from URLs during a conversation, converting HTML to markdown for processing. This is a key building block for agents that need to access live web data, documentation, or API responses without requiring you to build custom tool infrastructure. Note that authenticated URLs will fail since the tool operates without session cookies or tokens, so you need alternative approaches for private resources. Compare this with the web search tool, which discovers URLs, whereas web fetch retrieves content from known URLs you or the model already have.

Web Search Tool

Mon, 01 Jan 0001 00:00:00 +0000

The web search tool gives Claude the ability to query search engines and incorporate up-to-date information into its responses, directly addressing the knowledge cutoff limitation inherent to all LLMs. This is essential for agents that need to answer questions about current events, recent software releases, or rapidly changing documentation. Be mindful that search results are summaries, not full page content – pair this tool with the web fetch tool when you need to deeply read a specific result. Search queries constructed by the model can sometimes be overly broad, so providing domain filtering constraints improves relevance significantly.

Whats New Claude 4 6

Mon, 01 Jan 0001 00:00:00 +0000

Workspaces

Mon, 01 Jan 0001 00:00:00 +0000

Zero Data Retention

Mon, 01 Jan 0001 00:00:00 +0000