---
title: Comienza con Claude Managed Agents
url: https://platform.claude.com/docs/es/managed-agents/quickstart
description: Crea tu primer agente autónomo.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Esta guía te lleva paso a paso por la creación de un agente, la configuración de un entorno, el inicio de una sesión y el streaming de las respuestas del agente.
**¿Prefieres un recorrido interactivo?** Ejecuta `/claude-api managed-agents-onboard` en la versión más reciente de [Claude Code](https://claude.com/product/claude-code) para obtener una configuración guiada y respuestas interactivas a tus preguntas.
## Conceptos principales
| Concepto | Descripción |
| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Agente** | El modelo, la indicación del sistema, las herramientas, los servidores MCP y las skills |
| **Entorno** | Configuración de dónde se ejecutan las sesiones: un sandbox en la nube administrado por Anthropic, o un sandbox autoalojado en tu propia infraestructura |
| **Sesión** | Una instancia de agente en ejecución dentro de un entorno, que realiza una tarea específica y genera salidas |
| **Eventos** | Mensajes intercambiados entre tu aplicación y el agente (turnos del usuario, resultados de herramientas, actualizaciones de estado) |
## Requisitos previos
* Una [cuenta de Claude Console](https://platform.claude.com)
* Una [clave de API](https://platform.claude.com/settings/keys)
## Instala la CLI
```bash
brew install anthropics/tap/ant
```
Para entornos Linux, descarga directamente el binario de la versión.
```bash
VERSION=1.42.0
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
case $(uname -m) in
x86_64) ARCH=amd64 ;;
aarch64) ARCH=arm64 ;;
esac
curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
| sudo tar -xz -C /usr/local/bin ant
```
Puedes encontrar todas las versiones en la [página de versiones de GitHub](https://github.com/anthropics/anthropic-cli/releases).
También puedes instalar la CLI desde el código fuente usando `go install`. Requiere Go 1.25 o posterior.
```bash
go install github.com/anthropics/anthropic-cli/cmd/ant@latest
```
El binario se coloca en `$(go env GOPATH)/bin`. Agrégalo a tu `PATH` si aún no está:
```bash
export PATH="$PATH:$(go env GOPATH)/bin"
```
Verifica la instalación:
```bash
ant --version
```
## Instala el SDK
```bash
pip install anthropic
```
```bash
npm install @anthropic-ai/sdk
```
```groovy Gradle
implementation("com.anthropic:anthropic-java:2.73.0")
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```bash
dotnet add package Anthropic
```
```bash
bundle add anthropic
```
```bash
composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"
```
Configura tu clave de API como variable de entorno:
```bash
export ANTHROPIC_API_KEY="your-api-key-here"
```
## Crea tu primera sesión
Crea un agente que defina el modelo, la "system prompt" (indicación del sistema) y las herramientas disponibles.
```bash cURL
curl -sS --fail-with-body https://api.anthropic.com/v1/agents \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "Coding Assistant",
"model": "claude-opus-5-5",
"system": "You are a helpful coding assistant. Write clean, well-documented code.",
"tools": [
{"type": "agent_toolset_20260401"}
]
}'
```
Guarda el `agent.id` devuelto. Lo referenciarás en cada sesión que crees.
```bash CLI
ant apply coding-assistant.md
```
```markdown
---
name: Coding Assistant
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
---
You are a helpful coding assistant. Write clean, well-documented code.
```
[`ant apply`](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/apply) imprime el ID del agente y lo registra en `claude-lock.json`. Lo referenciarás en cada sesión que crees.
```python Python
from anthropic import Anthropic
client = Anthropic()
agent = client.beta.agents.create(
name="Coding Assistant",
model="claude-opus-5-5",
system="You are a helpful coding assistant. Write clean, well-documented code.",
tools=[
{"type": "agent_toolset_20260401"},
],
)
print(f"Agent ID: {agent.id}, version: {agent.version}")
```
Guarda el `agent.id` devuelto. Lo referenciarás en cada sesión que crees.
```typescript TypeScript
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const agent = await client.beta.agents.create({
name: "Coding Assistant",
model: "claude-opus-5-5",
system: "You are a helpful coding assistant. Write clean, well-documented code.",
tools: [
{ type: "agent_toolset_20260401" },
],
});
console.log(`Agent ID: ${agent.id}, version: ${agent.version}`);
```
Guarda el `agent.id` devuelto. Lo referenciarás en cada sesión que crees.
```csharp C#
using Anthropic;
using Anthropic.Models.Beta.Agents;
using Anthropic.Models.Beta.Environments;
using Anthropic.Models.Beta.Sessions;
using Anthropic.Models.Beta.Sessions.Events;
var client = new AnthropicClient();
var agent = await client.Beta.Agents.Create(new()
{
Name = "Coding Assistant",
Model = BetaManagedAgentsModel.ClaudeOpus5_5,
System = "You are a helpful coding assistant. Write clean, well-documented code.",
Tools =
[
new BetaManagedAgentsAgentToolset20260401Params
{
Type = "agent_toolset_20260401",
},
],
});
Console.WriteLine($"Agent ID: {agent.ID}, version: {agent.Version}");
```
Guarda el `agent.id` devuelto. Lo referenciarás en cada sesión que crees.
```go Go
package main
import (
"context"
"fmt"
"github.com/anthropics/anthropic-sdk-go"
)
func main() {
client := anthropic.NewClient()
ctx := context.Background()
agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
Name: "Coding Assistant",
Model: anthropic.BetaManagedAgentsModelConfigParams{
ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
},
System: anthropic.String("You are a helpful coding assistant. Write clean, well-documented code."),
Tools: []anthropic.BetaAgentNewParamsToolUnion{{
OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
},
}},
})
if err != nil {
panic(err)
}
fmt.Printf("Agent ID: %s, version: %d\n", agent.ID, agent.Version)
```
Guarda el `agent.id` devuelto. Lo referenciarás en cada sesión que crees.
```java Java
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.beta.agents.AgentCreateParams;
import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
import com.anthropic.models.beta.agents.BetaManagedAgentsModel;
import com.anthropic.models.beta.environments.BetaCloudConfigParams;
import com.anthropic.models.beta.environments.BetaLimitedNetworkParams;
import com.anthropic.models.beta.environments.EnvironmentCreateParams;
import com.anthropic.models.beta.sessions.SessionCreateParams;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsStreamSessionEvents;
import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserMessageEventParams;
import com.anthropic.models.beta.sessions.events.EventSendParams;
void main() {
var client = AnthropicOkHttpClient.fromEnv();
var agent = client.beta().agents().create(AgentCreateParams.builder()
.name("Coding Assistant")
.model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
.system("You are a helpful coding assistant. Write clean, well-documented code.")
.addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
.type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
.build())
.build());
IO.println("Agent ID: " + agent.id() + ", version: " + agent.version());
```
Guarda el `agent.id` devuelto. Lo referenciarás en cada sesión que crees.
```php PHP
use Anthropic\Client;
$client = new Client();
$agent = $client->beta->agents->create(
name: 'Coding Assistant',
model: 'claude-opus-5-5',
system: 'You are a helpful coding assistant. Write clean, well-documented code.',
tools: [
['type' => 'agent_toolset_20260401'],
],
);
echo "Agent ID: {$agent->id}, version: {$agent->version}\n";
```
Guarda el `agent.id` devuelto. Lo referenciarás en cada sesión que crees.
```ruby Ruby
require "anthropic"
client = Anthropic::Client.new
agent = client.beta.agents.create(
name: "Coding Assistant",
model: "claude-opus-5-5",
system_: "You are a helpful coding assistant. Write clean, well-documented code.",
tools: [{type: "agent_toolset_20260401"}]
)
puts "Agent ID: #{agent.id}, version: #{agent.version}"
```
Guarda el `agent.id` devuelto. Lo referenciarás en cada sesión que crees.
El tipo de herramienta `agent_toolset_20260401` habilita el conjunto completo de herramientas de agente predefinidas (bash, operaciones de archivos, búsqueda web y más). Consulta [Herramientas](https://platform.claude.com/docs/es/managed-agents/tools) para ver la lista completa y las opciones de configuración de cada herramienta.
Un entorno define el "sandbox" (entorno aislado) donde se ejecuta tu agente. Este usa [redes](https://platform.claude.com/docs/es/managed-agents/environments#networking) `limited` con los gestores de paquetes permitidos, de modo que el código que se ejecuta en el sandbox puede acceder a [registros de paquetes y servicios de alojamiento de código](https://platform.claude.com/docs/es/managed-agents/environments#package-manager-hosts) públicos. La búsqueda web y la obtención web se ejecutan fuera del sandbox, y este inicio rápido no las necesita. Con redes `limited`, la [lista `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`)](https://platform.claude.com/docs/es/managed-agents/environments#networking) también se aplica a ellas. No devuelven páginas ni resultados de búsqueda en este entorno, porque no incluye ningún host. Para tu propio agente, incluye los hosts que necesita en `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).
```bash cURL
curl -sS --fail-with-body https://api.anthropic.com/v1/environments \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "quickstart-env",
"config": {
"type": "cloud",
"networking": {"type": "limited", "allow_package_managers": true}
}
}'
```
Guarda también el `environment.id` devuelto.
```bash CLI
ant apply environment.yaml
```
```yaml
# yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
name: quickstart-env
config:
type: cloud
networking:
type: limited
allow_package_managers: true
```
[`ant apply`](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/apply) también registra el ID del entorno en `claude-lock.json`. Para crear el agente y el entorno con un solo comando, pasa ambos archivos: `ant apply coding-assistant.md environment.yaml`.
```python Python
environment = client.beta.environments.create(
name="quickstart-env",
config={
"type": "cloud",
"networking": {"type": "limited", "allow_package_managers": True},
},
)
print(f"Environment ID: {environment.id}")
```
Guarda también el `environment.id` devuelto.
```typescript TypeScript
const environment = await client.beta.environments.create({
name: "quickstart-env",
config: {
type: "cloud",
networking: { type: "limited", allow_package_managers: true },
},
});
console.log(`Environment ID: ${environment.id}`);
```
Guarda también el `environment.id` devuelto.
```csharp C#
var environment = await client.Beta.Environments.Create(new()
{
Name = "quickstart-env",
Config = new BetaCloudConfigParams
{
Networking = new BetaLimitedNetworkParams { AllowPackageManagers = true },
},
});
Console.WriteLine($"Environment ID: {environment.ID}");
```
Guarda también el `environment.id` devuelto.
```go Go
environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
Name: "quickstart-env",
Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
OfCloud: &anthropic.BetaCloudConfigParams{
Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
OfLimited: &anthropic.BetaLimitedNetworkParams{
AllowPackageManagers: anthropic.Bool(true),
},
},
},
},
})
if err != nil {
panic(err)
}
fmt.Printf("Environment ID: %s\n", environment.ID)
```
Guarda también el `environment.id` devuelto.
```java Java
var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
.name("quickstart-env")
.config(BetaCloudConfigParams.builder()
.networking(BetaLimitedNetworkParams.builder()
.allowPackageManagers(true)
.build())
.build())
.build());
IO.println("Environment ID: " + environment.id());
```
Guarda también el `environment.id` devuelto.
```php PHP
$environment = $client->beta->environments->create(
name: 'quickstart-env',
config: [
'type' => 'cloud',
'networking' => ['type' => 'limited', 'allow_package_managers' => true],
],
);
echo "Environment ID: {$environment->id}\n";
```
Guarda también el `environment.id` devuelto.
```ruby Ruby
environment = client.beta.environments.create(
name: "quickstart-env",
config: {type: "cloud", networking: {type: "limited", allow_package_managers: true}}
)
puts "Environment ID: #{environment.id}"
```
Guarda también el `environment.id` devuelto.
Este inicio rápido usa un entorno en la nube. Para decidir si, en cambio, te conviene ejecutar las herramientas en tu propia infraestructura con un
[sandbox autoalojado](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes)
, consulta
[Elegir un entorno para el agente](https://platform.claude.com/docs/es/managed-agents/choosing-an-environment)
.
Crea una sesión que haga referencia a tu agente y a tu entorno.
```bash cURL
curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"agent": "'"$AGENT_ID"'",
"environment_id": "'"$ENVIRONMENT_ID"'",
"title": "Quickstart session"
}'
```
```bash CLI
ant beta:sessions create \
--agent "$AGENT_ID" \
--environment-id "$ENVIRONMENT_ID" \
--title "Quickstart session"
```
```python Python
session = client.beta.sessions.create(
agent=agent.id,
environment_id=environment.id,
title="Quickstart session",
)
print(f"Session ID: {session.id}")
```
```typescript TypeScript
const session = await client.beta.sessions.create({
agent: agent.id,
environment_id: environment.id,
title: "Quickstart session",
});
console.log(`Session ID: ${session.id}`);
```
```csharp C#
var session = await client.Beta.Sessions.Create(new()
{
Agent = agent.ID,
EnvironmentID = environment.ID,
Title = "Quickstart session",
});
Console.WriteLine($"Session ID: {session.ID}");
```
```go Go
session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
Agent: anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agent.ID)},
EnvironmentID: environment.ID,
Title: anthropic.String("Quickstart session"),
})
if err != nil {
panic(err)
}
fmt.Printf("Session ID: %s\n", session.ID)
```
```java Java
var session = client.beta().sessions().create(SessionCreateParams.builder()
.agent(agent.id())
.environmentId(environment.id())
.title("Quickstart session")
.build());
IO.println("Session ID: " + session.id());
```
```php PHP
$session = $client->beta->sessions->create(
agent: $agent->id,
environmentID: $environment->id,
title: 'Quickstart session',
);
echo "Session ID: {$session->id}\n";
```
```ruby Ruby
session = client.beta.sessions.create(
agent: agent.id,
environment_id: environment.id,
title: "Quickstart session"
)
puts "Session ID: #{session.id}"
```
Abre un stream, envía un evento de usuario y luego procesa los eventos a medida que llegan:
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [SDK de Claude](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [SDK de Claude](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
```python Python
with client.beta.sessions.events.stream(session.id) as stream:
# Envía el mensaje del usuario después de que se abra el stream
client.beta.sessions.events.send(
session.id,
events=[
{
"type": "user.message",
"content": [
{
"type": "text",
"text": "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
},
],
},
],
)
# Procesa los eventos de streaming
for event in stream:
match event.type:
case "agent.message":
for block in event.content:
if block.type == "text":
print(block.text, end="")
case "agent.tool_use":
print(f"\n[Using tool: {event.name}]")
case "session.status_idle":
print("\n\nAgent finished.")
break
```
```typescript TypeScript
const stream = await client.beta.sessions.events.stream(session.id);
// Envía el mensaje del usuario después de que se abra el stream
await client.beta.sessions.events.send(session.id, {
events: [
{
type: "user.message",
content: [
{
type: "text",
text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
},
],
},
],
});
// Procesa los eventos de streaming
loop: for await (const event of stream) {
switch (event.type) {
case "agent.message":
for (const block of event.content) {
if (block.type === "text") {
process.stdout.write(block.text);
}
}
break;
case "agent.tool_use":
console.log(`\n[Using tool: ${event.name}]`);
break;
case "session.status_idle":
console.log("\n\nAgent finished.");
break loop;
}
}
```
```csharp C#
var stream = client.Beta.Sessions.Events.StreamStreaming(session.ID);
// Envía el mensaje del usuario después de que se abra el stream
await client.Beta.Sessions.Events.Send(session.ID, new()
{
Events =
[
new BetaManagedAgentsUserMessageEventParams
{
Type = "user.message",
Content =
[
new BetaManagedAgentsTextBlock
{
Type = "text",
Text = "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
},
],
},
],
});
// Procesa los eventos de streaming
await foreach (var ev in stream)
{
if (ev.Value is BetaManagedAgentsAgentMessageEvent message)
{
foreach (var block in message.Content)
{
if (block.Value is BetaManagedAgentsTextBlock textBlock)
{
Console.Write(textBlock.Text);
}
}
}
else if (ev.Value is BetaManagedAgentsAgentToolUseEvent toolUse)
{
Console.WriteLine($"\n[Using tool: {toolUse.Name}]");
}
else if (ev.Value is BetaManagedAgentsSessionStatusIdleEvent)
{
Console.WriteLine("\n\nAgent finished.");
break;
}
}
```
```go Go
stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, anthropic.BetaSessionEventStreamParams{})
defer stream.Close()
// Envía el mensaje del usuario después de que se abra el stream
_, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
OfText: &anthropic.BetaManagedAgentsTextBlockParam{
Type: anthropic.BetaManagedAgentsTextBlockTypeText,
Text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
},
}},
},
}},
})
if err != nil {
panic(err)
}
// Procesa los eventos de streaming
loop:
for stream.Next() {
switch event := stream.Current().AsAny().(type) {
case anthropic.BetaManagedAgentsAgentMessageEvent:
for _, block := range event.Content {
if block.Type == "text" {
fmt.Print(block.Text)
}
}
case anthropic.BetaManagedAgentsAgentToolUseEvent:
fmt.Printf("\n[Using tool: %s]\n", event.Name)
case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
fmt.Print("\n\nAgent finished.\n")
break loop
}
}
if err := stream.Err(); err != nil {
panic(err)
}
```
```java Java
try (var stream = client.beta().sessions().events().streamStreaming(session.id())) {
// Envía el mensaje del usuario después de que se abra el stream
client.beta().sessions().events().send(session.id(), EventSendParams.builder()
.addEvent(BetaManagedAgentsUserMessageEventParams.builder()
.type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
.addTextContent("Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt")
.build())
.build());
// Procesa los eventos de streaming
loop:
for (var event : (Iterable) stream.stream()::iterator) {
switch (event.type().value()) {
case AGENT_MESSAGE -> event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text())));
case AGENT_TOOL_USE -> IO.println("\n[Using tool: " + event.asAgentToolUse().name() + "]");
case SESSION_STATUS_IDLE -> {
IO.println("\n\nAgent finished.");
break loop;
}
}
}
}
```
```php PHP
$stream = $client->beta->sessions->events->streamStream($session->id);
// Envía el mensaje del usuario después de que se abra el stream
$client->beta->sessions->events->send(
$session->id,
events: [
[
'type' => 'user.message',
'content' => [
['type' => 'text', 'text' => 'Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt'],
],
],
],
);
// Procesa los eventos de streaming
foreach ($stream as $event) {
match (true) {
$event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsAgentMessageEvent => array_walk(
$event->content,
static fn ($block) => $block instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsTextBlock ? print($block->text) : null,
),
$event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsAgentToolUseEvent => print("\n[Using tool: {$event->name}]\n"),
$event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionStatusIdleEvent => print("\n\nAgent finished.\n"),
default => null,
};
if ($event->type === 'session.status_idle') {
break;
}
}
```
```ruby Ruby
stream = client.beta.sessions.events.stream_events(session.id)
# Envía el mensaje del usuario después de que se abra el stream
client.beta.sessions.events.send_(
session.id,
events: [{
type: "user.message",
content: [{type: "text", text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt"}]
}]
)
# Procesa los eventos de streaming
stream.each do |event|
case event
when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent
event.content.each { print it.text if it.is_a?(Anthropic::Beta::Sessions::BetaManagedAgentsTextBlock) }
when Anthropic::Beta::Sessions::BetaManagedAgentsAgentToolUseEvent
puts "\n[Using tool: #{event.name}]"
when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
puts "\n\nAgent finished."
break
else
# ignora otros tipos de eventos
end
end
```
El agente escribe un script de Python, lo ejecuta en el sandbox y verifica que se haya creado el archivo de salida. Tu salida se verá similar a esta:
```text wrap
I'll create a Python script that generates the first 20 Fibonacci numbers and saves them to a file.
[Using tool: write]
[Using tool: bash]
The script ran successfully. Let me verify the output file.
[Using tool: bash]
fibonacci.txt contains the first 20 Fibonacci numbers (0 through 4181).
Agent finished.
```
## Qué está sucediendo
Cuando envías un evento de usuario, Claude Managed Agents:
1. **Aprovisiona un sandbox:** La configuración de tu entorno determina cómo se construye.
2. **Ejecuta el bucle del agente:** Claude determina qué herramientas usar según tu mensaje.
3. **Ejecuta herramientas:** Las escrituras de archivos, los comandos bash y otras llamadas a herramientas se ejecutan dentro del sandbox.
4. **Transmite eventos por streaming:** Recibes actualizaciones en tiempo real mientras el agente trabaja.
5. **Queda inactivo:** El agente emite un evento `session.status_idle` cuando no tiene nada más que hacer.
## Construye una aplicación completa
Cada uno de estos quickstarts combina Claude Managed Agents con un framework de chat popular para crear una aplicación completa y ejecutable. En cada uno, el framework renderiza la interfaz de chat mientras una sesión administrada ejecuta el bucle del agente del lado del servidor: la sesión mantiene la transcripción, ejecuta herramientas en un sandbox y transmite por streaming los eventos que el front end renderiza.
Un analista de investigación en un chat de navegador construido con el Chat SDK de Vercel. Cada conversación es una sesión persistente que transmite su respuesta por streaming mientras un feed en vivo muestra las llamadas a herramientas. Cambiar el adaptador del Chat SDK traslada el mismo handler a Slack, Teams, Discord o WhatsApp.
Un analista de hojas de cálculo en un chat construido a partir de primitivas de assistant-ui. Las sesiones son la lista de hilos, un reducer convierte el registro de eventos de la sesión en mensajes y tarjetas de herramientas, y cada comando bash renderiza una compuerta Allow/Deny en línea antes de ejecutarse.
Un asistente de finanzas personales en un chat de CopilotKit. El adaptador AG-UI para Claude Managed Agents asigna cada hilo de chat a una sesión administrada y transmite las respuestas token por token, y las herramientas personalizadas renderizan gráficos interactivos en línea dentro de la conversación.
## Próximos pasos
Crea configuraciones de agente reutilizables y versionadas
Personaliza la configuración de red y del sandbox
Habilita herramientas específicas para tu agente
Maneja eventos y dirige al agente en plena ejecución
Ejecuta tu agente con una programación cron recurrente
Destila un corpus de documentos una sola vez en una wiki de conocimiento y luego responde preguntas repetidas a partir de ella por una fracción del costo