6 6
7> Construya agentes de IA en producción con Claude Code como una biblioteca7> Construya agentes de IA en producción con Claude Code como una biblioteca
8 8
9Construya agentes de IA que lean archivos de forma autónoma, ejecuten comandos, busquen en la web, editen código y mucho más. El Agent SDK le proporciona las mismas herramientas, bucle de agente y gestión de contexto que potencian Claude Code, programable en Python y TypeScript. Para conocer el razonamiento detrás del diseño del harness de agentes, consulte [A harness for every task: dynamic workflows in Claude Code](https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code) en el blog.9Un agente es una aplicación que completa una tarea planificando sus propios pasos y llamando a herramientas que leen archivos, ejecutan comandos o editan código. El Agent SDK le proporciona las mismas herramientas, [bucle de agente](/docs/es/agent-sdk/agent-loop), y gestión de contexto que potencian Claude Code, programable en Python y TypeScript.
10 10
11<CodeGroup>11<h2 id="compare-the-agent-sdk-to-other-claude-tools">
12 ```python Python theme={null}12 Comparar el Agent SDK con otras herramientas de Claude
13 import asyncio
14 from claude_agent_sdk import query, ClaudeAgentOptions
15
16
17 async def main():
18 async for message in query(
19 prompt="Find and fix the bug in auth.py",
20 options=ClaudeAgentOptions(allowed_tools=["Read", "Edit", "Bash"]),
21 ):
22 print(message) # Claude reads the file, finds the bug, edits it
23
24
25 asyncio.run(main())
26 ```
27
28 ```typescript TypeScript theme={null}
29 import { query } from "@anthropic-ai/claude-agent-sdk";
30
31 for await (const message of query({
32 prompt: "Find and fix the bug in auth.ts",
33 options: { allowedTools: ["Read", "Edit", "Bash"] }
34 })) {
35 console.log(message); // Claude reads the file, finds the bug, edits it
36 }
37 ```
38</CodeGroup>
39
40El Agent SDK incluye herramientas integradas para leer archivos, ejecutar comandos y editar código, por lo que su agente puede comenzar a trabajar inmediatamente sin que usted implemente la ejecución de herramientas. Sumérjase en el inicio rápido o explore agentes reales construidos con el SDK:
41
42<CardGroup cols={2}>
43 <Card title="Inicio rápido" icon="play" href="/es/agent-sdk/quickstart">
44 Construya un agente corrector de errores en minutos
45 </Card>
46
47 <Card title="Agentes de ejemplo" icon="star" href="https://github.com/anthropics/claude-agent-sdk-demos">
48 Asistente de correo electrónico, agente de investigación y más
49 </Card>
50</CardGroup>
51
52<h2 id="get-started">
53 Comenzar
54</h2>13</h2>
55 14
56<Steps>15El Agent SDK, la CLI, el Client SDK y los Managed Agents se adaptan a diferentes necesidades. Utilice la tabla para encontrar el que coincida con lo que está construyendo.
57 <Step title="Instale el SDK">
58 <Tabs>
59 <Tab title="TypeScript">
60 ```bash theme={null}
61 npm install @anthropic-ai/claude-agent-sdk
62 ```
63 </Tab>
64
65 <Tab title="Python (uv)">
66 [uv](https://docs.astral.sh/uv/) es un gestor de paquetes de Python rápido que maneja entornos virtuales automáticamente:
67
68 ```bash theme={null}
69 uv init
70 uv add claude-agent-sdk
71 ```
72 </Tab>
73
74 <Tab title="Python (pip)">
75 Cree y active un entorno virtual, luego instale el paquete. Instalar en un entorno virtual evita el error `error: externally-managed-environment` que devuelve Python del sistema en instalaciones recientes de Debian, Ubuntu y Homebrew para `pip install` fuera de un venv.
76
77 En macOS o Linux:
78
79 ```bash theme={null}
80 python3 -m venv .venv
81 source .venv/bin/activate
82 pip install claude-agent-sdk
83 ```
84
85 En Windows:
86
87 ```powershell theme={null}
88 py -m venv .venv
89 .venv\Scripts\Activate.ps1
90 pip install claude-agent-sdk
91 ```
92
93 Si PowerShell bloquea `Activate.ps1` con un error de política de ejecución, ejecute primero `Set-ExecutionPolicy -Scope Process RemoteSigned`.
94
95 El paquete de Python requiere Python 3.10 o posterior. Si pip reporta `No matching distribution found for claude-agent-sdk`, su intérprete es anterior a 3.10. Ejecute `python3 --version` en macOS o Linux, o `py --version` en Windows, para verificar.
96 </Tab>
97 </Tabs>
98
99 <Note>
100 El SDK de TypeScript agrupa un binario nativo de Claude Code para su plataforma como una dependencia opcional, por lo que no necesita instalar Claude Code por separado.
101 </Note>
102 </Step>
103
104 <Step title="Configure su clave de API">
105 Obtenga una clave de API de la [Consola](https://platform.claude.com/), luego configúrela como una variable de entorno.
106
107 En macOS o Linux:
108
109 ```bash theme={null}
110 export ANTHROPIC_API_KEY=sk-ant-xxxxx
111 ```
112
113 En Windows PowerShell:
114
115 ```powershell theme={null}
116 $env:ANTHROPIC_API_KEY = "sk-ant-xxxxx"
117 ```
118
119 El SDK también admite autenticación a través de proveedores de API de terceros:
120
121 * **Amazon Bedrock**: configure la variable de entorno `CLAUDE_CODE_USE_BEDROCK=1` y configure las credenciales de AWS
122 * **Claude Platform on AWS**: configure `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` y `ANTHROPIC_AWS_WORKSPACE_ID`, luego configure las credenciales de AWS
123 * **Google Cloud's Agent Platform**: configure la variable de entorno `CLAUDE_CODE_USE_VERTEX=1` y configure las credenciales de Google Cloud
124 * **Microsoft Azure**: configure la variable de entorno `CLAUDE_CODE_USE_FOUNDRY=1` y configure las credenciales de Azure
125
126 Consulte las guías de configuración para [Amazon Bedrock](/es/amazon-bedrock), [Claude Platform on AWS](/es/claude-platform-on-aws), [Google Cloud's Agent Platform](/es/google-vertex-ai) o [Microsoft Foundry](/es/microsoft-foundry) para obtener más detalles.
127
128 <Note>
129 A menos que haya sido aprobado previamente, Anthropic no permite que desarrolladores de terceros ofrezcan inicio de sesión en claude.ai o límites de velocidad para sus productos, incluidos los agentes construidos en el Claude Agent SDK. Por favor, utilice los métodos de autenticación de clave de API descritos en este documento en su lugar.
130 </Note>
131 </Step>
132 16
133 <Step title="Ejecute su primer agente">17| Si está... | Utilice | Por qué |
134 Este ejemplo crea un agente que enumera archivos en su directorio actual utilizando herramientas integradas.18| ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
19| Construyendo un agente sin implementar el bucle de herramientas usted mismo | **Agent SDK** | Una biblioteca que ejecuta el bucle del agente en su propio proceso, en Python o TypeScript. |
20| Realizando desarrollo interactivo o ejecutando tareas puntuales desde una terminal | [**Claude Code CLI**](/docs/es/overview) | La interfaz de terminal, construida para uso interactivo diario. |
21| Llamando a la API directamente e implementando el bucle de herramientas usted mismo | [**Client SDK**](https://platform.claude.com/docs/en/api/client-sdks) | Acceso directo a la API de Anthropic en lugar de a Claude Code. Usted implementa el bucle de herramientas. |
22| Ejecutando agentes de larga duración o asincronos sin gestionar su propia infraestructura de sandbox o sesión | [**Managed Agents**](https://platform.claude.com/docs/en/managed-agents/overview) | API REST alojada, un producto separado del Agent SDK. Anthropic ejecuta el agente y el sandbox. |
135 23
136 <CodeGroup>24El SDK está disponible como biblioteca solo para Python y TypeScript. Para impulsar el mismo bucle de agente desde otro idioma, [ejecute la CLI como un subproceso](/docs/es/headless) con la bandera `-p` y `--output-format json`.
137 ```python Python theme={null}
138 import asyncio
139 from claude_agent_sdk import query, ClaudeAgentOptions
140
141
142 async def main():
143 async for message in query(
144 prompt="What files are in this directory?",
145 options=ClaudeAgentOptions(allowed_tools=["Bash", "Glob"]),
146 ):
147 if hasattr(message, "result"):
148 print(message.result)
149
150
151 asyncio.run(main())
152 ```
153
154 ```typescript TypeScript theme={null}
155 import { query } from "@anthropic-ai/claude-agent-sdk";
156
157 for await (const message of query({
158 prompt: "What files are in this directory?",
159 options: { allowedTools: ["Bash", "Glob"] }
160 })) {
161 if ("result" in message) console.log(message.result);
162 }
163 ```
164 </CodeGroup>
165 </Step>
166</Steps>
167
168**¿Listo para construir?** Siga el [Inicio rápido](/es/agent-sdk/quickstart) para crear un agente que encuentre y corrija errores en minutos.
169 25
170<h2 id="capabilities">26<h2 id="capabilities">
171 Capacidades27 Capacidades
172</h2>28</h2>
173 29
174Todo lo que hace que Claude Code sea poderoso está disponible en el SDK:30Estas capacidades de Claude Code están disponibles en el SDK:
175
176<Tabs>
177 <Tab title="Herramientas integradas">
178 Su agente puede leer archivos, ejecutar comandos y buscar en bases de código de forma inmediata. Las herramientas clave incluyen:
179
180 | Herramienta | Qué hace |
181 | --------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
182 | **Read** | Leer cualquier archivo en el directorio de trabajo |
183 | **Write** | Crear nuevos archivos |
184 | **Edit** | Realizar ediciones precisas en archivos existentes |
185 | **Bash** | Ejecutar comandos de terminal, scripts, operaciones de git |
186 | **Monitor** | Observar un script de fondo y reaccionar a cada línea de salida como un evento |
187 | **Glob** | Encontrar archivos por patrón (`**/*.ts`, `src/**/*.py`) |
188 | **Grep** | Buscar contenido de archivos con expresiones regulares |
189 | **WebSearch** | Buscar en la web información actual |
190 | **WebFetch** | Obtener y analizar contenido de páginas web |
191 | **[AskUserQuestion](/es/agent-sdk/user-input#handle-clarifying-questions)** | Hacer preguntas aclaratorias al usuario con opciones de opción múltiple |
192
193 Este ejemplo crea un agente que busca comentarios TODO en su base de código:
194
195 <CodeGroup>
196 ```python Python theme={null}
197 import asyncio
198 from claude_agent_sdk import query, ClaudeAgentOptions
199
200
201 async def main():
202 async for message in query(
203 prompt="Find all TODO comments and create a summary",
204 options=ClaudeAgentOptions(allowed_tools=["Read", "Glob", "Grep"]),
205 ):
206 if hasattr(message, "result"):
207 print(message.result)
208
209
210 asyncio.run(main())
211 ```
212
213 ```typescript TypeScript theme={null}
214 import { query } from "@anthropic-ai/claude-agent-sdk";
215
216 for await (const message of query({
217 prompt: "Find all TODO comments and create a summary",
218 options: { allowedTools: ["Read", "Glob", "Grep"] }
219 })) {
220 if ("result" in message) console.log(message.result);
221 }
222 ```
223 </CodeGroup>
224 </Tab>
225
226 <Tab title="Hooks">
227 Ejecute código personalizado en puntos clave del ciclo de vida del agente. Los hooks del SDK utilizan funciones de devolución de llamada para validar, registrar, bloquear o transformar el comportamiento del agente.
228
229 **Hooks disponibles:** `PreToolUse`, `PostToolUse`, `Stop`, `SessionStart`, `SessionEnd`, `UserPromptSubmit` y más.
230
231 Este ejemplo registra todos los cambios de archivo en un archivo de auditoría:
232
233 <CodeGroup>
234 ```python Python theme={null}
235 import asyncio
236 from datetime import datetime
237 from claude_agent_sdk import query, ClaudeAgentOptions, HookMatcher
238
239
240 async def log_file_change(input_data, tool_use_id, context):
241 file_path = input_data.get("tool_input", {}).get("file_path", "unknown")
242 with open("./audit.log", "a") as f:
243 f.write(f"{datetime.now()}: modified {file_path}\n")
244 return {}
245
246
247 async def main():
248 async for message in query(
249 prompt="Refactor utils.py to improve readability",
250 options=ClaudeAgentOptions(
251 permission_mode="acceptEdits",
252 hooks={
253 "PostToolUse": [
254 HookMatcher(matcher="Edit|Write", hooks=[log_file_change])
255 ]
256 },
257 ),
258 ):
259 if hasattr(message, "result"):
260 print(message.result)
261
262
263 asyncio.run(main())
264 ```
265
266 ```typescript TypeScript theme={null}
267 import { query, HookCallback } from "@anthropic-ai/claude-agent-sdk";
268 import { appendFile } from "fs/promises";
269
270 const logFileChange: HookCallback = async (input) => {
271 const filePath = (input as any).tool_input?.file_path ?? "unknown";
272 await appendFile("./audit.log", `${new Date().toISOString()}: modified ${filePath}\n`);
273 return {};
274 };
275
276 for await (const message of query({
277 prompt: "Refactor utils.py to improve readability",
278 options: {
279 permissionMode: "acceptEdits",
280 hooks: {
281 PostToolUse: [{ matcher: "Edit|Write", hooks: [logFileChange] }]
282 }
283 }
284 })) {
285 if ("result" in message) console.log(message.result);
286 }
287 ```
288 </CodeGroup>
289
290 [Obtenga más información sobre hooks →](/es/agent-sdk/hooks)
291 </Tab>
292
293 <Tab title="Subagentes">
294 Genere agentes especializados para manejar subtareas enfocadas. Su agente principal delega trabajo y los subagentes informan con resultados.
295 31
296 Defina agentes personalizados con instrucciones especializadas. Los subagentes se invocan a través de la herramienta Agent, así que incluya `Agent` en `allowedTools` para aprobar automáticamente esas invocaciones:32| Capacidad | Qué hace | Más información |
33| -------------------------- | -------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
34| Herramientas integradas | Leer, escribir, editar archivos, ejecutar comandos y buscar en la web | [Referencia de herramientas](/docs/es/tools-reference) |
35| Hooks | Ejecutar código personalizado en puntos clave del ciclo de vida del agente | [Hooks](/docs/es/agent-sdk/hooks) |
36| Subagentes | Generar agentes especializados para subtareas enfocadas | [Subagentes](/docs/es/agent-sdk/subagents) |
37| MCP | Conectar herramientas y fuentes de datos externas a través del Protocolo de Contexto del Modelo | [MCP](/docs/es/agent-sdk/mcp) |
38| Permisos | Controlar qué herramientas se ejecutan automáticamente, cuáles necesitan aprobación | [Permisos](/docs/es/agent-sdk/permissions) |
39| Sesiones | Mantener contexto en múltiples intercambios, reanudar o dividir más tarde | [Sesiones](/docs/es/agent-sdk/sessions) |
40| Skills, comandos y memoria | Cargar automáticamente desde `.claude/` de su proyecto y desde `~/.claude/`, igual que Claude Code | [Skills](/docs/es/agent-sdk/skills), [Comandos](/docs/es/agent-sdk/skills#commands-in-agent-sdk-sessions), [Memoria](/docs/es/agent-sdk/modifying-system-prompts), [Carga de configuración](/docs/es/agent-sdk/claude-code-features) |
41| Plugins | Empaquetar skills, agentes, hooks y servidores MCP, y cargarlos por ruta local | [Plugins](/docs/es/agent-sdk/plugins) |
297 42
298 <CodeGroup>43<h2 id="get-started">
299 ```python Python theme={null}44 Comenzar
300 import asyncio
301 from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition
302
303
304 async def main():
305 async for message in query(
306 prompt="Use the code-reviewer agent to review this codebase",
307 options=ClaudeAgentOptions(
308 allowed_tools=["Read", "Glob", "Grep", "Agent"],
309 agents={
310 "code-reviewer": AgentDefinition(
311 description="Expert code reviewer for quality and security reviews.",
312 prompt="Analyze code quality and suggest improvements.",
313 tools=["Read", "Glob", "Grep"],
314 )
315 },
316 ),
317 ):
318 if hasattr(message, "result"):
319 print(message.result)
320
321
322 asyncio.run(main())
323 ```
324
325 ```typescript TypeScript theme={null}
326 import { query } from "@anthropic-ai/claude-agent-sdk";
327
328 for await (const message of query({
329 prompt: "Use the code-reviewer agent to review this codebase",
330 options: {
331 allowedTools: ["Read", "Glob", "Grep", "Agent"],
332 agents: {
333 "code-reviewer": {
334 description: "Expert code reviewer for quality and security reviews.",
335 prompt: "Analyze code quality and suggest improvements.",
336 tools: ["Read", "Glob", "Grep"]
337 }
338 }
339 }
340 })) {
341 if ("result" in message) console.log(message.result);
342 }
343 ```
344 </CodeGroup>
345
346 Los mensajes dentro del contexto de un subagente incluyen un campo `parent_tool_use_id`, lo que le permite rastrear qué mensajes pertenecen a qué ejecución de subagente.
347
348 [Obtenga más información sobre subagentes →](/es/agent-sdk/subagents)
349 </Tab>
350
351 <Tab title="MCP">
352 Conéctese a sistemas externos a través del Protocolo de Contexto del Modelo: bases de datos, navegadores, API y [cientos más](https://github.com/modelcontextprotocol/servers).
353
354 Este ejemplo conecta el [servidor Playwright MCP](https://github.com/microsoft/playwright-mcp) para dar a su agente capacidades de automatización del navegador:
355
356 <CodeGroup>
357 ```python Python theme={null}
358 import asyncio
359 from claude_agent_sdk import query, ClaudeAgentOptions
360
361
362 async def main():
363 async for message in query(
364 prompt="Open example.com and describe what you see",
365 options=ClaudeAgentOptions(
366 mcp_servers={
367 "playwright": {"command": "npx", "args": ["@playwright/mcp@latest"]}
368 }
369 ),
370 ):
371 if hasattr(message, "result"):
372 print(message.result)
373
374
375 asyncio.run(main())
376 ```
377
378 ```typescript TypeScript theme={null}
379 import { query } from "@anthropic-ai/claude-agent-sdk";
380
381 for await (const message of query({
382 prompt: "Open example.com and describe what you see",
383 options: {
384 mcpServers: {
385 playwright: { command: "npx", args: ["@playwright/mcp@latest"] }
386 }
387 }
388 })) {
389 if ("result" in message) console.log(message.result);
390 }
391 ```
392 </CodeGroup>
393
394 [Obtenga más información sobre MCP →](/es/agent-sdk/mcp)
395 </Tab>
396
397 <Tab title="Permisos">
398 Controle exactamente qué herramientas puede usar su agente. Permita operaciones seguras, bloquee las peligrosas o requiera aprobación para acciones sensibles.
399
400 <Note>
401 Para solicitudes de aprobación interactivas y la herramienta `AskUserQuestion`, consulte [Manejar aprobaciones e entrada del usuario](/es/agent-sdk/user-input).
402 </Note>
403
404 Este ejemplo crea un agente de solo lectura que puede analizar pero no modificar código. `allowed_tools` aprueba previamente `Read`, `Glob` y `Grep`.
405
406 <CodeGroup>
407 ```python Python theme={null}
408 import asyncio
409 from claude_agent_sdk import query, ClaudeAgentOptions
410
411
412 async def main():
413 async for message in query(
414 prompt="Review this code for best practices",
415 options=ClaudeAgentOptions(
416 allowed_tools=["Read", "Glob", "Grep"],
417 ),
418 ):
419 if hasattr(message, "result"):
420 print(message.result)
421
422
423 asyncio.run(main())
424 ```
425
426 ```typescript TypeScript theme={null}
427 import { query } from "@anthropic-ai/claude-agent-sdk";
428
429 for await (const message of query({
430 prompt: "Review this code for best practices",
431 options: {
432 allowedTools: ["Read", "Glob", "Grep"]
433 }
434 })) {
435 if ("result" in message) console.log(message.result);
436 }
437 ```
438 </CodeGroup>
439
440 [Obtenga más información sobre permisos →](/es/agent-sdk/permissions)
441 </Tab>
442
443 <Tab title="Sesiones">
444 Mantenga el contexto en múltiples intercambios. Claude recuerda archivos leídos, análisis realizados e historial de conversación. Reanude sesiones más tarde o divídalas para explorar diferentes enfoques.
445
446 Este ejemplo captura el ID de sesión de la primera consulta, luego reanuda para continuar con contexto completo:
447
448 <CodeGroup>
449 ```python Python theme={null}
450 import asyncio
451 from claude_agent_sdk import query, ClaudeAgentOptions, SystemMessage, ResultMessage
452
453
454 async def main():
455 session_id = None
456
457 # First query: capture the session ID
458 async for message in query(
459 prompt="Read the authentication module",
460 options=ClaudeAgentOptions(allowed_tools=["Read", "Glob"]),
461 ):
462 if isinstance(message, SystemMessage) and message.subtype == "init":
463 session_id = message.data["session_id"]
464
465 # Resume with full context from the first query
466 async for message in query(
467 prompt="Now find all places that call it", # "it" = auth module
468 options=ClaudeAgentOptions(resume=session_id),
469 ):
470 if isinstance(message, ResultMessage):
471 print(message.result)
472
473
474 asyncio.run(main())
475 ```
476
477 ```typescript TypeScript theme={null}
478 import { query } from "@anthropic-ai/claude-agent-sdk";
479
480 let sessionId: string | undefined;
481
482 // First query: capture the session ID
483 for await (const message of query({
484 prompt: "Read the authentication module",
485 options: { allowedTools: ["Read", "Glob"] }
486 })) {
487 if (message.type === "system" && message.subtype === "init") {
488 sessionId = message.session_id;
489 }
490 }
491
492 // Resume with full context from the first query
493 for await (const message of query({
494 prompt: "Now find all places that call it", // "it" = auth module
495 options: { resume: sessionId }
496 })) {
497 if ("result" in message) console.log(message.result);
498 }
499 ```
500 </CodeGroup>
501
502 [Obtenga más información sobre sesiones →](/es/agent-sdk/sessions)
503 </Tab>
504</Tabs>
505
506<h3 id="claude-code-features">
507 Características de Claude Code
508</h3>
509
510El SDK también admite la configuración basada en el sistema de archivos de Claude Code. Con opciones predeterminadas, el SDK carga estas desde `.claude/` en su directorio de trabajo y `~/.claude/`. Para restringir qué fuentes se cargan, configure `setting_sources` (Python) o `settingSources` (TypeScript) en sus opciones.
511
512| Característica | Descripción | Ubicación |
513| ------------------------------------------------ | -------------------------------------------------------------------------------------------------- | -------------------------------------------- |
514| [Skills](/es/agent-sdk/skills) | Capacidades especializadas que Claude utiliza automáticamente o que usted invoca con `/name` | `.claude/skills/*/SKILL.md` |
515| [Commands](/es/agent-sdk/slash-commands) | Comandos personalizados en el formato heredado. Utilice skills para nuevos comandos personalizados | `.claude/commands/*.md` |
516| [Memory](/es/agent-sdk/modifying-system-prompts) | Contexto e instrucciones del proyecto | `CLAUDE.md` o `.claude/CLAUDE.md` |
517| [Plugins](/es/agent-sdk/plugins) | Extienda con skills, agentes, hooks y servidores MCP | Programático a través de la opción `plugins` |
518
519<h2 id="compare-the-agent-sdk-to-other-claude-tools">
520 Compare el Agent SDK con otras herramientas de Claude
521</h2>45</h2>
522 46
523La Plataforma Claude ofrece múltiples formas de construir con Claude. Así es como se ajusta el Agent SDK:47Siga el [Quickstart](/docs/es/agent-sdk/quickstart) para instalar el SDK, establecer su clave de API y construir su primer agente, uno que encuentre y corrija errores en código existente.
524
525<Tabs>
526 <Tab title="Agent SDK vs Client SDK">
527 El [Anthropic Client SDK](https://platform.claude.com/docs/es/api/client-sdks) le proporciona acceso directo a la API: usted envía solicitudes e implementa la ejecución de herramientas usted mismo. El **Agent SDK** le proporciona Claude con ejecución de herramientas integrada.
528
529 Con el Client SDK, implementa un bucle de herramientas. Con el Agent SDK, Claude lo maneja:
530
531 <CodeGroup>
532 ```python Python theme={null}
533 # Client SDK: You implement the tool loop
534 response = client.messages.create(...)
535 while response.stop_reason == "tool_use":
536 result = your_tool_executor(response.tool_use)
537 response = client.messages.create(tool_result=result, **params)
538
539 # Agent SDK: Claude handles tools autonomously
540 async for message in query(prompt="Fix the bug in auth.py"):
541 print(message)
542 ```
543
544 ```typescript TypeScript theme={null}
545 // Client SDK: You implement the tool loop
546 let response = await client.messages.create({ ...params });
547 while (response.stop_reason === "tool_use") {
548 const result = yourToolExecutor(response.tool_use);
549 response = await client.messages.create({ tool_result: result, ...params });
550 }
551
552 // Agent SDK: Claude handles tools autonomously
553 for await (const message of query({ prompt: "Fix the bug in auth.ts" })) {
554 console.log(message);
555 }
556 ```
557 </CodeGroup>
558 </Tab>
559 48
560 <Tab title="Agent SDK vs Claude Code CLI">49<Note>
561 Mismas capacidades, interfaz diferente:50 A menos que haya sido previamente aprobado, Anthropic no permite que desarrolladores de terceros ofrezcan inicio de sesión en claude.ai o límites de velocidad para sus productos, incluidos los agentes construidos en el Agent SDK de Claude. En su lugar, utilice los métodos de autenticación de clave de API descritos en el [Quickstart](/docs/es/agent-sdk/quickstart).
562 51</Note>
563 | Caso de uso | Mejor opción |
564 | ---------------------------- | ------------ |
565 | Desarrollo interactivo | CLI |
566 | Canalizaciones CI/CD | SDK |
567 | Aplicaciones personalizadas | SDK |
568 | Tareas puntuales | CLI |
569 | Automatización en producción | SDK |
570
571 Muchos equipos usan ambos: CLI para desarrollo diario, SDK para producción. Los flujos de trabajo se traducen directamente entre ellos.
572 </Tab>
573
574 <Tab title="Agent SDK vs Managed Agents">
575 [Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview) es una API REST alojada: Anthropic ejecuta el agente y el sandbox, y su aplicación envía eventos y transmite resultados. El **Agent SDK** es una biblioteca que ejecuta el bucle del agente dentro de su propio proceso.
576
577 | | Agent SDK | Managed Agents |
578 | ------------------------------- | ------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
579 | **Se ejecuta en** | Su proceso, su infraestructura | Infraestructura administrada por Anthropic |
580 | **Interfaz** | Biblioteca de Python o TypeScript | API REST |
581 | **El agente trabaja en** | Archivos en su infraestructura | Un sandbox administrado por sesión |
582 | **Estado de la sesión** | JSONL en su sistema de archivos | Registro de eventos alojado por Anthropic |
583 | **Herramientas personalizadas** | Funciones de Python o TypeScript en proceso | Claude activa la herramienta; usted ejecuta y devuelve resultados |
584 | **Mejor para** | Prototipado local, agentes que trabajan directamente en su sistema de archivos y servicios | Agentes de producción sin operar infraestructura de sandbox o sesión, sesiones de larga duración y asincrónicas |
585
586 Una ruta común es crear prototipos con el Agent SDK localmente, luego pasar a Managed Agents para producción.
587 </Tab>
588</Tabs>
589 52
590<h2 id="changelog">53<h2 id="changelog">
591 Registro de cambios54 Registro de cambios
596* **TypeScript SDK**: [ver CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md)59* **TypeScript SDK**: [ver CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md)
597* **Python SDK**: [ver CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-python/blob/main/CHANGELOG.md)60* **Python SDK**: [ver CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-python/blob/main/CHANGELOG.md)
598 61
599<h2 id="reporting-bugs">62<h2 id="report-bugs">
600 Reportar errores63 Reportar errores
601</h2>64</h2>
602 65
613 76
614**Permitido:**77**Permitido:**
615 78
616* "Claude Agent" (preferido para menús desplegables)79* "Claude Agent", preferido para menús desplegables
617* "Claude" (cuando ya está dentro de un menú etiquetado como "Agents")80* "Claude", cuando ya está dentro de un menú etiquetado como "Agents"
618* "{YourAgentName} Powered by Claude" (si tiene un nombre de agente existente)81* "{YourAgentName} Powered by Claude", si tiene un nombre de agente existente
619 82
620**No permitido:**83**No permitido:**
621 84
634 Próximos pasos97 Próximos pasos
635</h2>98</h2>
636 99
637<CardGroup cols={2}>100Estos recursos cubren detalles técnicos más profundos y proyectos de ejemplo para construir con el Agent SDK.
638 <Card title="Inicio rápido" icon="play" href="/es/agent-sdk/quickstart">
639 Construya un agente que encuentre y corrija errores en minutos
640 </Card>
641
642 <Card title="Agentes de ejemplo" icon="star" href="https://github.com/anthropics/claude-agent-sdk-demos">
643 Asistente de correo electrónico, agente de investigación y más
644 </Card>
645
646 <Card title="TypeScript SDK" icon="code" href="/es/agent-sdk/typescript">
647 Referencia completa de API de TypeScript y ejemplos
648 </Card>
649 101
650 <Card title="Python SDK" icon="code" href="/es/agent-sdk/python">102* [Inicio rápido](/docs/es/agent-sdk/quickstart): construya su primer agente que encuentre y corrija errores
651 Referencia completa de API de Python y ejemplos103* [Guía de migración](/docs/es/agent-sdk/migration-guide): migre desde los paquetes del Claude Code SDK al Agent SDK
652 </Card>104* [Bucle de agente](/docs/es/agent-sdk/agent-loop): cómo Claude planifica, llama herramientas y decide cuándo se completa una tarea
653</CardGroup>105* [Agentes de ejemplo](https://github.com/anthropics/claude-agent-sdk-demos): aplicaciones de demostración para desarrollo local
106* [SDK de TypeScript](/docs/es/agent-sdk/typescript): referencia completa de API de TypeScript y ejemplos
107* [SDK de Python](/docs/es/agent-sdk/python): referencia completa de API de Python y ejemplos
108* [Diseño del arnés de agente](https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code): cómo el equipo de Claude Code utiliza flujos de trabajo dinámicos para orquestar muchos subagentes a la vez
