--- title: Presupuestos de sesión url: https://platform.claude.com/docs/es/managed-agents/budgets description: Limita el gasto de una sesión con un presupuesto fijo en dólares aplicado a las tarifas de lista públicas. featureMetadata: topic: title: Managed Agents url: https://platform.claude.com/docs/en/managed-agents/overview status: beta betaHeader: managed-agents-2026-04-01 --- Un "session budget" (presupuesto de sesión) es un techo de gasto fijo opcional que estableces cuando [creas una sesión](https://platform.claude.com/docs/es/managed-agents/sessions). La plataforma calcula continuamente el precio de todo lo que la sesión consume a las tarifas de lista públicas (el **costo de lista** de la sesión) y deja de emitir nuevas solicitudes al modelo una vez que ese costo alcanza el presupuesto. La solicitud en curso cuando se cruza el límite aún termina, por lo que el costo de lista final puede quedar [una fracción por encima del presupuesto](https://platform.claude.com/docs/es/managed-agents/budgets#when-a-session-reaches-its-budget). Una sesión que alcanza su presupuesto se pausa y pasa a estado [idle](https://platform.claude.com/docs/es/managed-agents/session-operations#session-statuses) en lugar de terminar; cambiar o eliminar el presupuesto reanuda el trabajo que el presupuesto pausó. Los despliegues aceptan el mismo presupuesto y lo aplican a cada sesión que inician; consulta [Presupuestos en despliegues](https://platform.claude.com/docs/es/managed-agents/budgets#budgets-on-deployments). ## Establecer un presupuesto al crear la sesión Pasa el campo opcional `budget` (csharp, go: `Budget`) cuando crees la sesión: ```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"'", "budget": { "type": "limit", "max_list_cost": {"amount": "125", "currency": "USD"} } }' ``` ```bash CLI # Mantén el monto entre comillas para que se envíe como cadena, no como número. ant beta:sessions create \ --agent "$AGENT_ID" \ --environment-id "$ENVIRONMENT_ID" \ --budget '{type: limit, max_list_cost: {amount: "125", currency: USD}}' ``` ```python Python session = client.beta.sessions.create( agent=agent.id, environment_id=environment.id, budget={ "type": "limit", "max_list_cost": {"amount": "125", "currency": "USD"}, }, ) print(session.id, session.budget.max_list_cost.amount) # sesn_01... 125 ``` ```typescript TypeScript const session = await client.beta.sessions.create({ agent: agent.id, environment_id: environment.id, budget: { type: "limit", max_list_cost: { amount: "125", currency: "USD" } } }); console.log(session.id, session.budget?.max_list_cost.amount); // sesn_01... 125 ``` ```csharp C# var session = await client.Beta.Sessions.Create(new() { Agent = agent.ID, EnvironmentID = environment.ID, Budget = new() { Type = BetaManagedAgentsBudgetLimitType.Limit, MaxListCost = new() { Amount = "125", Currency = BetaCurrency.Usd }, }, }); Console.WriteLine($"{session.ID} {session.Budget?.MaxListCost.Amount}"); // sesn_01... 125 ``` ```go Go session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{ Agent: anthropic.BetaSessionNewParamsAgentUnion{ OfString: anthropic.String(agent.ID), }, EnvironmentID: environment.ID, Budget: anthropic.BetaManagedAgentsBudgetLimitParam{ Type: anthropic.BetaManagedAgentsBudgetLimitTypeLimit, MaxListCost: anthropic.BetaMonetaryAmountParam{ Amount: "125", Currency: anthropic.BetaCurrencyUsd, }, }, }) if err != nil { panic(err) } fmt.Println(session.ID, session.Budget.MaxListCost.Amount) // sesn_01... 125 ``` ```java Java var session = client.beta().sessions().create(SessionCreateParams.builder() .agent(agent.id()) .environmentId(environment.id()) .budget(BetaManagedAgentsBudgetLimit.builder() .type(BetaManagedAgentsBudgetLimit.Type.LIMIT) .maxListCost(BetaMonetaryAmount.builder() .amount("125") .currency(BetaCurrency.USD) .build()) .build()) .build()); IO.println(session.id() + " " + session.budget().orElseThrow().maxListCost().amount()); // sesn_01... 125 ``` ```php PHP $session = $client->beta->sessions->create( agent: $agent->id, environmentID: $environment->id, budget: [ 'type' => 'limit', 'max_list_cost' => ['amount' => '125', 'currency' => 'USD'], ], ); echo "{$session->id} {$session->budget->maxListCost->amount}\n"; // sesn_01... 125 ``` ```ruby Ruby session = client.beta.sessions.create( agent: agent.id, environment_id: environment.id, budget: { type: "limit", max_list_cost: {amount: "125", currency: "USD"} } ) puts "#{session.id} #{session.budget.max_list_cost.amount}" # sesn_01... 125 ``` El objeto `budget` (csharp, go: `Budget`) tiene dos campos: * `type` (csharp, go: `Type`) siempre es `"limit"`. * `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) es el límite en sí: `amount` (csharp, go: `Amount`) es un número entero de centavos de dólar estadounidense escrito como cadena sin ceros a la izquierda (`"125"` es $1.25 y `"50"` es 50 centavos) y debe ser mayor que cero. Las formas decimales como `"25.00"` se rechazan. El monto es una cadena en lugar de un número para que nunca se le aplique redondeo de punto flotante. `currency` (csharp, go: `Currency`) es un código de moneda ISO-4217 en mayúsculas; `USD` es la única moneda admitida. Un presupuesto solo puede adjuntarse cuando se crea la sesión. Agregar un presupuesto a una sesión existente que no tiene uno se rechaza con un error 400. El límite de una sesión con presupuesto puede [cambiarse](https://platform.claude.com/docs/es/managed-agents/budgets#change-the-budget) o [eliminarse](https://platform.claude.com/docs/es/managed-agents/budgets#remove-the-budget) en cualquier momento. ## Cómo se mide el costo de lista La plataforma calcula el precio de lo que la sesión consume, de forma continua, a las tarifas de lista públicas: * **Tokens del modelo**, al precio de lista de cada modelo servido * **Búsquedas web**, a $10 USD por cada 1,000 búsquedas * **Tiempo de ejecución de la sesión**, a $0.08 USD por hora Este total acumulado en dólares es el **costo de lista** de la sesión, y es contra lo que se compara el presupuesto. El costo de lista no es tu precio contratado: si tu organización ha negociado descuentos, la sesión alcanza su límite cuando lo hace el total a precio de lista, y tu gasto facturado podría ser menor que el límite. La aplicación del límite usa el costo de lista exacto, sin redondear. Las cifras de `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) reportadas en la sesión y sus eventos son centavos enteros, redondeados al centavo más cercano, por lo que una cifra reportada puede diferir hasta medio centavo hacia arriba o hacia abajo del monto exacto que usa la aplicación del límite. ## Cuando una sesión alcanza su presupuesto El límite se aplica entre solicitudes al modelo, no a mitad de una solicitud. Antes de cada solicitud al modelo, la plataforma verifica el costo de lista consumido por la sesión, y una vez que ese total alcanza el límite, cada hilo se pausa antes de su siguiente solicitud. La solicitud que llevó el total por encima del límite fue admitida mientras la sesión aún estaba por debajo de él y se ejecuta hasta completarse, por lo que el `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) registrado de una sesión pausada es igual o una fracción mayor que `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`): una sesión limitada a `"50"` (50 centavos) puede pausarse con un `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) de `"53"`. Esto es lo esperado, no un error de facturación. El gasto del modelo por encima del límite es como máximo el costo de una solicitud al modelo por cada hilo. Las llamadas a herramientas en la respuesta de esa solicitud aún se ejecutan, y sus búsquedas web y tiempo de ejecución también cuentan para el costo de lista. Trata el presupuesto como un límite para el trabajo nuevo en lugar de un punto de detención exacto, y dimensiona el límite teniendo en cuenta ese margen. Una sesión que alcanza su presupuesto pasa a estado inactivo con un `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached`; no se termina, y su historial y sandbox se conservan como los de cualquier otra sesión inactiva. En el [flujo de eventos](https://platform.claude.com/docs/es/managed-agents/events-and-streaming) verás, en orden: 1. Un evento `session.thread_status_idle` con un `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached` a medida que cada hilo se pausa. 2. Un evento [`session.usage`](https://platform.claude.com/docs/es/managed-agents/budgets#monitor-spend) con el uso acumulado y el costo de lista de la sesión. 3. Un evento `session.status_idle` con un `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached`. El evento de uso siempre precede inmediatamente a este evento de inactividad. Si hay [ejecuciones de flujos de trabajo](https://platform.claude.com/docs/es/managed-agents/workflow-runs#budgets-and-limits) abiertas, cada una que no esté ya inactiva también recibe un evento `workflow_run.status_idle`. Un hilo cuya solicitud final cruza el límite y a la vez completa su turno reporta `end_turn` en su propio evento `session.thread_status_idle` mientras la sesión sigue reportando `budget_reached`; trata el `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) a nivel de sesión como la señal de que la sesión se pausó al alcanzar su presupuesto. ### Eventos aceptados en el límite Mientras la sesión está en su presupuesto o por encima de él, solo acepta eventos que resuelven trabajo ya en curso: * `user.tool_confirmation` * `user.tool_result` * `user.custom_tool_result` * `user.interrupt` Cualquier evento que iniciaría trabajo nuevo, como `user.message`, se rechaza con un error 400 que nombra esta lista. Los resultados resueltos se registran sin desencadenar una nueva solicitud al modelo; la sesión permanece pausada en su presupuesto. Un `user.interrupt` enviado mientras la sesión está pausada en su presupuesto (todos los hilos pausados en el límite) se acepta, y no aparece en la lista de eventos. No detiene ningún hilo, porque cada hilo ya está pausado. Cambia o elimina el presupuesto para continuar. Si la sesión tiene [ejecuciones de flujos de trabajo](https://platform.claude.com/docs/es/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) abiertas, la interrupción puede pausarlas, como puede hacerlo una interrupción en cualquier otro momento. Una ejecución que una interrupción pausó no se reanuda cuando cambias o eliminas el presupuesto. Para continuarla, cambia o elimina el presupuesto y luego envía un `user.message` pidiéndole al agente que continúe sus ejecuciones. ## Reanudar una sesión en su presupuesto Cambia o elimina el presupuesto con una actualización de la sesión. Una actualización aceptada reanuda automáticamente el trabajo que el presupuesto pausó; no se necesita ninguna otra acción del cliente. Cada [ejecución de flujo de trabajo](https://platform.claude.com/docs/es/managed-agents/workflow-runs#budgets-and-limits) que el presupuesto pausó también recibe un evento `workflow_run.status_running`. Una ejecución que una interrupción pausó, incluso una interrupción enviada mientras la sesión estaba en su presupuesto, permanece pausada y no recibe ningún evento `workflow_run.status_running` como resultado de la actualización. Para continuarla, envía un `user.message` pidiéndole al agente que continúe sus ejecuciones. Consulta [Interrumpir una sesión con ejecuciones abiertas](https://platform.claude.com/docs/es/managed-agents/workflow-runs#interrupt-a-session-with-runs-open). ### Cambiar el presupuesto Actualiza la sesión con un nuevo `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). El nuevo valor puede ser mayor o menor que el límite actual, pero debe ser estrictamente mayor que el costo de lista consumido por la sesión; de lo contrario, la actualización se rechaza con un error 400: `budget.max_list_cost must be greater than the session's consumed list cost`. Como el costo consumido suele quedar [una fracción por encima del límite anterior](https://platform.claude.com/docs/es/managed-agents/budgets#when-a-session-reaches-its-budget) cuando la sesión se pausa, basa el nuevo valor en el `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) reportado de la sesión, no en el `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) anterior. Establécelo un centavo o más por encima de esa cifra: el valor reportado está redondeado y puede quedar una fracción por debajo del costo consumido exacto que usa la verificación. ```bash cURL curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID" \ -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 '{ "budget": { "type": "limit", "max_list_cost": {"amount": "500", "currency": "USD"} } }' ``` ```bash CLI ant beta:sessions update \ --session-id "$SESSION_ID" \ --budget '{type: limit, max_list_cost: {amount: "500", currency: USD}}' ``` ```python Python updated_session = client.beta.sessions.update( session.id, budget={ "type": "limit", "max_list_cost": {"amount": "500", "currency": "USD"}, }, ) print(updated_session.budget.max_list_cost.amount) # 500 ``` ```typescript TypeScript const updatedSession = await client.beta.sessions.update(session.id, { budget: { type: "limit", max_list_cost: { amount: "500", currency: "USD" } } }); console.log(updatedSession.budget?.max_list_cost.amount); // 500 ``` ```csharp C# var updatedSession = await client.Beta.Sessions.Update(session.ID, new() { Budget = new() { Type = BetaManagedAgentsBudgetLimitType.Limit, MaxListCost = new() { Amount = "500", Currency = BetaCurrency.Usd }, }, }); Console.WriteLine(updatedSession.Budget?.MaxListCost.Amount); // 500 ``` ```go Go updatedSession, err := client.Beta.Sessions.Update(ctx, session.ID, anthropic.BetaSessionUpdateParams{ Budget: anthropic.BetaManagedAgentsBudgetLimitParam{ Type: anthropic.BetaManagedAgentsBudgetLimitTypeLimit, MaxListCost: anthropic.BetaMonetaryAmountParam{ Amount: "500", Currency: anthropic.BetaCurrencyUsd, }, }, }) if err != nil { panic(err) } fmt.Println(updatedSession.Budget.MaxListCost.Amount) // 500 ``` ```java Java var updatedSession = client.beta().sessions().update(session.id(), SessionUpdateParams.builder() .budget(BetaManagedAgentsBudgetLimit.builder() .type(BetaManagedAgentsBudgetLimit.Type.LIMIT) .maxListCost(BetaMonetaryAmount.builder() .amount("500") .currency(BetaCurrency.USD) .build()) .build()) .build()); IO.println(updatedSession.budget().orElseThrow().maxListCost().amount()); // 500 ``` ```php PHP $updatedSession = $client->beta->sessions->update( $session->id, budget: [ 'type' => 'limit', 'max_list_cost' => ['amount' => '500', 'currency' => 'USD'], ], ); echo "{$updatedSession->budget->maxListCost->amount}\n"; // 500 ``` ```ruby Ruby updated_session = client.beta.sessions.update( session.id, budget: { type: "limit", max_list_cost: {amount: "500", currency: "USD"} } ) puts updated_session.budget.max_list_cost.amount # 500 ``` ### Eliminar el presupuesto Pasa `"budget": null` (python: `budget=None`; typescript: `budget: null`; ruby: `budget: nil`; go: `Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam]()`; java: `.budget(Optional.empty())`; csharp: `Budget = null`; php: `requestOptions: ['extraBodyParams' => ['budget' => null]]`; cli: `--budget null`) para eliminar el límite por completo. El trabajo que el presupuesto pausó se reanuda, y el evento `session.updated` resultante incluye `budget` (csharp, go: `Budget`) establecido en `null`. ```bash cURL curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID" \ -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 '{"budget": null}' ``` ```bash CLI ant beta:sessions update --session-id "$SESSION_ID" --budget null ``` ```python Python unbudgeted_session = client.beta.sessions.update(session.id, budget=None) print(unbudgeted_session.budget) # None ``` ```typescript TypeScript const unbudgetedSession = await client.beta.sessions.update(session.id, { budget: null }); console.log(unbudgetedSession.budget); // null ``` ```csharp C# // Asignar null envía un null explícito; dejar Budget sin definir omitiría el campo. var unbudgetedSession = await client.Beta.Sessions.Update(session.ID, new() { Budget = null }); Console.WriteLine(unbudgetedSession.Budget is null); // True: the session no longer has a budget ``` ```go Go // Un Budget con valor cero se omite de la solicitud; param.NullStruct (de // github.com/anthropics/anthropic-sdk-go/packages/param) envía un null explícito. unbudgetedSession, err := client.Beta.Sessions.Update(ctx, session.ID, anthropic.BetaSessionUpdateParams{ Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam](), }) if err != nil { panic(err) } fmt.Println(unbudgetedSession.JSON.Budget.Valid()) // false: the session no longer has a budget ``` ```java Java // Un Optional vacío envía un null explícito; dejar budget sin definir omitiría el campo. var unbudgetedSession = client.beta().sessions().update(session.id(), SessionUpdateParams.builder() .budget(Optional.empty()) .build()); IO.println(unbudgetedSession.budget().isPresent()); // false: the session no longer has a budget ``` ```php PHP // update(budget: null) omite el campo, así que envía el null explícito como parámetro adicional del cuerpo. $unbudgetedSession = $client->beta->sessions->update( $session->id, requestOptions: ['extraBodyParams' => ['budget' => null]], ); echo json_encode($unbudgetedSession->budget), "\n"; // null ``` ```ruby Ruby unbudgeted_session = client.beta.sessions.update(session.id, budget: nil) p unbudgeted_session.budget # nil ``` Eliminar el presupuesto de una sesión es irreversible: a una sesión cuyo presupuesto ha sido eliminado no se le puede asignar uno nuevo. Para mantener un límite en la sesión, cambia el presupuesto en su lugar. ## Monitorear el gasto El objeto de sesión incluye su `budget` (csharp, go: `Budget`) y un objeto `usage` (csharp, go: `Usage`) con el gasto registrado: `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) es el costo de lista consumido por la sesión, y `usage.active_seconds` (java, php: `usage.activeSeconds`; csharp, go: `Usage.ActiveSeconds`) es el tiempo de ejecución sobre el que se calcula su costo de ejecución. En una sesión pausada con `budget_reached`, espera que `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) sea igual o una fracción mayor que `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`): la [solicitud que cruzó el límite](https://platform.claude.com/docs/es/managed-agents/budgets#when-a-session-reaches-its-budget) terminó antes de la pausa. El `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`) a nivel de sesión cuenta una sola vez la actividad superpuesta de hilos concurrentes. Las respuestas de recuperación de hilos incluyen los mismos dos campos en el propio `usage` (csharp, go: `Usage`) del hilo, con precio calculado por hilo. Las cifras por hilo se redondean de forma independiente y excluyen el costo de tiempo de ejecución de la sesión, por lo que no suman exactamente el `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) de la sesión; la cifra de la sesión es contra la que se aplica el presupuesto. El evento `session.usage` es una instantánea del uso acumulado y del costo de lista registrado de la sesión. Incluye los totales de tokens de la sesión, `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`), los recuentos de solicitudes de `server_tool_use` (java, php: `serverToolUse`; csharp, go: `ServerToolUse`) (`web_search_requests` (java, php: `webSearchRequests`; csharp, go: `WebSearchRequests`), cuyo precio se incluye en el costo de lista por solicitud, y `web_fetch_requests` (java, php: `webFetchRequests`; csharp, go: `WebFetchRequests`), que marca `0` porque las solicitudes de obtención web no tienen cargo por solicitud y no se miden), y el `budget` (csharp, go: `Budget`) de la sesión si la sesión tiene uno. Aparece en la lista de eventos y en el flujo de la sesión. La sesión emite uno inmediatamente antes de pasar a estado inactivo, sea cual sea el motivo de detención, por lo que una sesión que alcanza su presupuesto siempre emite uno inmediatamente antes del evento de inactividad por presupuesto alcanzado. Para leer el uso desde el flujo y el objeto de sesión, consulta [Hacer seguimiento del uso](https://platform.claude.com/docs/es/managed-agents/session-observability#track-usage). ## Presupuestos en sesiones multiagente Una sesión [multiagente](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration) tiene un único presupuesto compartido entre todos sus hilos; no hay límites por hilo. El consumo de cada hilo se calcula según su propio modelo servido, y los hilos se pausan de forma independiente a medida que se alcanza el límite compartido. Las consultas al [asesor](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration#give-the-session-an-advisor) cuentan contra el mismo presupuesto, calculadas a las tarifas del modelo asesor. Un hilo puede pausarse en `budget_reached` mientras otro termina su solicitud en curso. Una petición pendiente tiene prioridad sobre el límite: una sesión con un hilo esperando en `requires_action` y otro pausado en `budget_reached` reporta `requires_action` a nivel de sesión. La solicitud pendiente aún necesita una respuesta, y responderla es un [evento de resolución](https://platform.claude.com/docs/es/managed-agents/budgets#events-accepted-at-the-cap) que el presupuesto no bloquea. ## Presupuestos en despliegues Un [despliegue](https://platform.claude.com/docs/es/managed-agents/scheduled-deployments) acepta el mismo objeto `budget` cuando lo creas o actualizas: ```json { "budget": { "type": "limit", "max_list_cost": { "amount": "2000", "currency": "USD" } } } ``` El límite se copia en cada sesión que inicia el despliegue, por lo que limita cada ejecución por separado en lugar del gasto acumulado del despliegue. Cambiar el presupuesto del despliegue se aplica a las sesiones que el despliegue inicie después, no a las sesiones que ya están en ejecución. A diferencia de una sesión, el presupuesto de un despliegue se puede borrar con `"budget": null` (python: `budget=None`; typescript: `budget: null`; ruby: `budget: nil`; go: `Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam]()`; java: `.budget(Optional.empty())`; csharp: `Budget = null`; php: `requestOptions: ['extraBodyParams' => ['budget' => null]]`; cli: `--budget null`) y volver a establecerse más tarde. Consulta [Establecer un presupuesto en cada ejecución](https://platform.claude.com/docs/es/managed-agents/scheduled-deployments#set-a-budget-on-each-run). ## Modelos sin precio de lista Un presupuesto solo puede registrar el consumo al que la plataforma puede asignar un precio. Crear una sesión con presupuesto cuyo agente, o cualquier agente incluido en la lista `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) de `subagents` (csharp, go: `Subagents`) o `workflows` (csharp, go: `Workflows`), o el asesor establecido en su [configuración multiagente](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration), use un modelo sin precio de lista público se rechaza con un error 400 que indica que no hay precio de lista disponible para el modelo. Si el uso de una sesión con presupuesto llega a incluir un modelo sin precio de lista, el presupuesto ya no puede medir el gasto de la sesión: la sesión puede pausarse con un `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) de `budget_reached`, y cambiar el presupuesto se rechaza. Elimina el presupuesto para reanudar la sesión. ## Referencia de errores Las solicitudes relacionadas con presupuestos se rechazan en los siguientes casos: | Condición | Estado | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------ | | Se envía un evento que inicia trabajo (por ejemplo, `user.message`) mientras la sesión está en su presupuesto o por encima de él; el error nombra los [eventos de resolución aceptados](https://platform.claude.com/docs/es/managed-agents/budgets#events-accepted-at-the-cap) | 400 | | El presupuesto se establece en un valor igual o inferior al costo de lista consumido de la sesión | 400 | | Se agrega un presupuesto a una sesión creada sin uno, o se vuelve a agregar después de eliminarlo | 400 | | `amount` (csharp, go: `Amount`) no es un número entero de centavos (por ejemplo, `"25.00"`), es cero o negativo, o `currency` (csharp, go: `Currency`) no es `USD` | 400 | | Una creación con presupuesto hace referencia a un modelo [sin precio de lista público](https://platform.claude.com/docs/es/managed-agents/budgets#models-without-a-list-price) | 400 | Los presupuestos de sesión son límites fijos en dólares estadounidenses (escritos en centavos) sobre una única sesión, aplicados por la plataforma. Son distintos de los [presupuestos de tarea](https://platform.claude.com/docs/es/build-with-claude/task-budgets) de la Messages API, que son presupuestos orientativos, denominados en tokens, que el modelo usa para autorregularse dentro de un único bucle agéntico.