--- title: Sitzungsbudgets url: https://platform.claude.com/docs/de/managed-agents/budgets description: Begrenze die Ausgaben einer Sitzung mit einem harten Dollar-Budget, das zu öffentlichen Listenpreisen durchgesetzt wird. featureMetadata: topic: title: Managed Agents url: https://platform.claude.com/docs/en/managed-agents/overview status: beta betaHeader: managed-agents-2026-04-01 --- Ein „session budget“ (Sitzungsbudget) ist eine optionale harte Ausgabenobergrenze, die du festlegst, wenn du [eine Sitzung erstellst](https://platform.claude.com/docs/de/managed-agents/sessions). Die Plattform bepreist fortlaufend alles, was die Sitzung verbraucht, zu öffentlichen Listenpreisen (die **Listenkosten** bzw. „list cost“ der Sitzung) und stellt keine neuen Modellanfragen mehr aus, sobald diese Kosten das Budget erreichen. Die Anfrage, die gerade läuft, wenn die Obergrenze überschritten wird, wird noch abgeschlossen, sodass die endgültigen Listenkosten [einen Bruchteil über dem Budget](https://platform.claude.com/docs/de/managed-agents/budgets#when-a-session-reaches-its-budget) landen können. Eine Sitzung, die ihr Budget erreicht hat, pausiert und wird [idle](https://platform.claude.com/docs/de/managed-agents/session-operations#session-statuses), anstatt beendet zu werden; das Ändern oder Entfernen des Budgets setzt die Arbeit fort, die das Budget pausiert hat. Deployments akzeptieren dasselbe Budget und wenden es auf jede Sitzung an, die sie starten; siehe [Budgets bei Deployments](https://platform.claude.com/docs/de/managed-agents/budgets#budgets-on-deployments). ## Ein Budget bei der Sitzungserstellung festlegen Übergib das optionale Feld `budget` (csharp, go: `Budget`), wenn du die Sitzung erstellst: ```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 # Lass den Betrag in Anführungszeichen, damit er als String und nicht als Zahl gesendet wird. 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 ``` Das Objekt `budget` (csharp, go: `Budget`) hat zwei Felder: * `type` (csharp, go: `Type`) ist immer `"limit"`. * `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) ist die Obergrenze selbst: `amount` (csharp, go: `Amount`) ist eine ganze Zahl von US-Cent, geschrieben als String ohne führende Nullen (`"125"` entspricht 1,25 $ und `"50"` entspricht 50 Cent), und muss größer als null sein. Dezimalformen wie `"25.00"` werden abgelehnt. Der Betrag ist ein String statt einer Zahl, damit niemals eine Gleitkomma-Rundung darauf angewendet wird. `currency` (csharp, go: `Currency`) ist ein ISO-4217-Währungscode in Großbuchstaben; `USD` ist die einzige unterstützte Währung. Ein Budget kann nur beim Erstellen der Sitzung angehängt werden. Das Hinzufügen eines Budgets zu einer bestehenden Sitzung, die keines hat, wird mit einem 400-Fehler abgelehnt. Die Obergrenze einer budgetierten Sitzung kann jederzeit [geändert](https://platform.claude.com/docs/de/managed-agents/budgets#change-the-budget) oder [entfernt](https://platform.claude.com/docs/de/managed-agents/budgets#remove-the-budget) werden. ## Wie Listenkosten gemessen werden Die Plattform bepreist fortlaufend, was die Sitzung verbraucht, zu öffentlichen Listenpreisen: * **Modell-Token**, zum Listenpreis des jeweils bereitgestellten Modells * **Websuchen**, zu 10 USD pro 1.000 Suchen * **Sitzungslaufzeit**, zu 0,08 USD pro Stunde Diese laufende Dollar-Gesamtsumme sind die **Listenkosten** der Sitzung, und mit ihnen wird das Budget verglichen. Listenkosten sind nicht dein vertraglich vereinbarter Preis: Wenn deine Organisation Rabatte ausgehandelt hat, erreicht die Sitzung ihre Obergrenze, wenn die Listenpreis-Gesamtsumme sie erreicht, und deine abgerechneten Ausgaben können niedriger als die Obergrenze sein. Die Durchsetzung verwendet die exakten, ungerundeten Listenkosten. Die Werte für `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), die für die Sitzung und ihre Events gemeldet werden, sind ganze Cent, auf den nächsten Cent gerundet, sodass ein gemeldeter Wert bis zu einem halben Cent über oder unter dem exakten Betrag liegen kann, den die Durchsetzung verwendet. ## Wenn eine Sitzung ihr Budget erreicht Die Obergrenze wird zwischen Modellanfragen durchgesetzt, nicht mitten in einer Anfrage. Vor jeder Modellanfrage prüft die Plattform die verbrauchten Listenkosten der Sitzung, und sobald diese Summe die Obergrenze erreicht, pausiert jeder Thread vor seiner nächsten Anfrage. Die Anfrage, die die Summe über die Obergrenze gebracht hat, wurde zugelassen, als die Sitzung noch darunter lag, und läuft bis zum Ende, sodass der erfasste Wert `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) einer pausierten Sitzung bei oder geringfügig über `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) liegt: Eine Sitzung mit einer Obergrenze von `"50"` (50 Cent) kann mit einem `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) von `"53"` pausieren. Das ist erwartet und kein Abrechnungsfehler. Die Modellkosten über die Obergrenze hinaus betragen höchstens die Kosten einer Modellanfrage pro Thread. Die Tool-Aufrufe in der Antwort dieser Anfrage werden trotzdem ausgeführt, und ihre Websuchen und Laufzeit zählen ebenfalls zu den Listenkosten. Betrachte das Budget als Grenze für neue Arbeit statt als exakten Haltepunkt, und bemiss die Obergrenze mit diesem Spielraum im Hinterkopf. Eine Sitzung, die ihr Budget erreicht, wechselt in den Status idle mit einem `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) von `budget_reached`; sie wird nicht beendet, und ihr Verlauf und ihre Sandbox bleiben wie bei jeder anderen inaktiven Sitzung erhalten. Im [Event-Stream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming) siehst du der Reihe nach: 1. Ein `session.thread_status_idle`-Event mit einem `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) von `budget_reached`, wenn jeder Thread pausiert. 2. Ein [`session.usage`](https://platform.claude.com/docs/de/managed-agents/budgets#monitor-spend)-Event mit der kumulierten Nutzung und den Listenkosten der Sitzung. 3. Ein `session.status_idle`-Event mit einem `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) von `budget_reached`. Das Nutzungs-Event geht diesem Idle-Event immer unmittelbar voraus. Wenn [Workflow-Runs](https://platform.claude.com/docs/de/managed-agents/workflow-runs#budgets-and-limits) offen sind, erhält jeder, der nicht bereits inaktiv ist, außerdem ein `workflow_run.status_idle`-Event. Ein Thread, dessen letzte Anfrage sowohl die Obergrenze überschreitet als auch seinen Turn abschließt, meldet `end_turn` in seinem eigenen `session.thread_status_idle`-Event, während die Sitzung weiterhin `budget_reached` meldet; betrachte den `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) auf Sitzungsebene als das Signal, dass die Sitzung bei ihrem Budget pausiert hat. ### An der Obergrenze akzeptierte Events Solange die Sitzung bei oder über ihrem Budget liegt, akzeptiert sie nur Events, die bereits laufende Arbeit abschließen: * `user.tool_confirmation` * `user.tool_result` * `user.custom_tool_result` * `user.interrupt` Jedes Event, das neue Arbeit starten würde, wie `user.message`, wird mit einem 400-Fehler abgelehnt, der diese Liste nennt. Abgeschlossene Ergebnisse werden aufgezeichnet, ohne eine neue Modellanfrage auszulösen; die Sitzung bleibt an ihrem Budget pausiert. Ein `user.interrupt`, das gesendet wird, während die Sitzung an ihrem Budget pausiert ist (alle Threads an der Obergrenze pausiert), wird akzeptiert, und es erscheint nicht in der Event-Liste. Es stoppt keinen Thread, weil jeder Thread bereits pausiert ist. Ändere oder entferne das Budget, um fortzufahren. Wenn die Sitzung offene [Workflow-Runs](https://platform.claude.com/docs/de/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) hat, kann die Unterbrechung sie pausieren, wie es eine Unterbrechung zu jedem anderen Zeitpunkt auch kann. Ein Run, den eine Unterbrechung pausiert hat, wird nicht fortgesetzt, wenn du das Budget änderst oder entfernst. Um ihn fortzusetzen, ändere oder entferne das Budget und sende dann eine `user.message`, die den Agenten bittet, seine Runs fortzusetzen. ## Eine Sitzung an ihrem Budget fortsetzen Ändere oder entferne das Budget mit einem Sitzungs-Update. Ein akzeptiertes Update setzt die Arbeit, die das Budget pausiert hat, automatisch fort; es ist keine weitere Aktion des Clients erforderlich. Jeder [Workflow-Run](https://platform.claude.com/docs/de/managed-agents/workflow-runs#budgets-and-limits), den das Budget pausiert hat, erhält außerdem ein `workflow_run.status_running`-Event. Ein Run, den eine Unterbrechung pausiert hat, bleibt pausiert und erhält durch das Update kein `workflow_run.status_running`-Event, selbst wenn die Unterbrechung gesendet wurde, während die Sitzung an ihrem Budget war. Um ihn fortzusetzen, sende eine `user.message`, die den Agenten bittet, seine Runs fortzusetzen. Siehe [Eine Session mit offenen Runs unterbrechen](https://platform.claude.com/docs/de/managed-agents/workflow-runs#interrupt-a-session-with-runs-open). ### Das Budget ändern Aktualisiere die Sitzung mit einem neuen `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Der neue Wert kann höher oder niedriger als die aktuelle Obergrenze sein, muss aber strikt größer als die verbrauchten Listenkosten der Sitzung sein; andernfalls wird das Update mit einem 400-Fehler abgelehnt: `budget.max_list_cost must be greater than the session's consumed list cost`. Da die verbrauchten Kosten beim Pausieren der Sitzung meist [geringfügig über der alten Obergrenze](https://platform.claude.com/docs/de/managed-agents/budgets#when-a-session-reaches-its-budget) liegen, orientiere den neuen Wert am gemeldeten `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) der Sitzung, nicht am alten `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`). Setze ihn einen Cent oder mehr über diesen Wert: Der gemeldete Wert ist gerundet und kann geringfügig unter den exakten verbrauchten Kosten liegen, die die Prüfung verwendet. ```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 ``` ### Das Budget entfernen Übergib `"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`), um die Obergrenze vollständig zu entfernen. Die Arbeit, die das Budget pausiert hat, wird fortgesetzt, und das resultierende `session.updated`-Event enthält `budget` (csharp, go: `Budget`) mit dem Wert `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# // Die Zuweisung von null sendet ein explizites null; bleibt Budget ungesetzt, wird das Feld weggelassen. 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 // Ein Budget mit Nullwert wird in der Anfrage weggelassen; param.NullStruct (aus // github.com/anthropics/anthropic-sdk-go/packages/param) sendet ein explizites null. 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 // Ein leeres Optional sendet ein explizites null; budget ungesetzt zu lassen würde das Feld weglassen. 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) lässt das Feld weg, also sende das explizite null als zusätzlichen Body-Parameter. $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 ``` Das Entfernen des Budgets einer Sitzung ist unumkehrbar: Einer Sitzung, deren Budget entfernt wurde, kann kein neues gegeben werden. Um eine Obergrenze für die Sitzung beizubehalten, ändere stattdessen das Budget. ## Ausgaben überwachen Das Sitzungsobjekt enthält sein `budget` (csharp, go: `Budget`) und ein `usage` (csharp, go: `Usage`)-Objekt mit den erfassten Ausgaben: `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) sind die verbrauchten Listenkosten der Sitzung, und `usage.active_seconds` (java, php: `usage.activeSeconds`; csharp, go: `Usage.ActiveSeconds`) ist die Laufzeit, auf deren Basis die Laufzeitkosten berechnet werden. Bei einer Sitzung, die mit `budget_reached` pausiert ist, ist zu erwarten, dass `usage.list_cost` (java, php: `usage.listCost`; csharp, go: `Usage.ListCost`) bei oder geringfügig über `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) liegt: Die [Anfrage, die die Obergrenze überschritten hat](https://platform.claude.com/docs/de/managed-agents/budgets#when-a-session-reaches-its-budget), wurde vor der Pause abgeschlossen. `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`) auf Sitzungsebene zählt überlappende Aktivität gleichzeitiger Threads nur einmal. Antworten beim Abrufen von Threads enthalten dieselben zwei Felder im eigenen `usage` (csharp, go: `Usage`) des Threads, pro Thread bepreist. Werte pro Thread werden unabhängig gerundet und schließen die Laufzeitkosten der Sitzung aus, sodass sie sich nicht exakt zum `list_cost` (java, php: `listCost`; csharp, go: `ListCost`) der Sitzung summieren; der Sitzungswert ist derjenige, gegen den das Budget durchgesetzt wird. Das `session.usage`-Event ist eine Momentaufnahme der kumulierten Nutzung und der erfassten Listenkosten der Sitzung. Es enthält die Token-Summen der Sitzung, `list_cost` (java, php: `listCost`; csharp, go: `ListCost`), `active_seconds` (java, php: `activeSeconds`; csharp, go: `ActiveSeconds`), die Anfragezahlen in `server_tool_use` (java, php: `serverToolUse`; csharp, go: `ServerToolUse`) (`web_search_requests` (java, php: `webSearchRequests`; csharp, go: `WebSearchRequests`), pro Anfrage in die Listenkosten eingerechnet, und `web_fetch_requests` (java, php: `webFetchRequests`; csharp, go: `WebFetchRequests`), das `0` anzeigt, weil Web-Fetch-Anfragen keine Gebühr pro Anfrage haben und nicht gemessen werden) sowie das `budget` (csharp, go: `Budget`) der Sitzung, falls die Sitzung eines hat. Es erscheint in der Event-Liste und im Sitzungs-Stream. Die Sitzung sendet eines unmittelbar bevor sie in den Status idle wechselt, unabhängig vom Stop-Grund, sodass eine Sitzung, die ihr Budget erreicht, immer eines unmittelbar vor dem Idle-Event für das erreichte Budget sendet. Wie du die Nutzung aus dem Stream und dem Sitzungsobjekt ausliest, erfährst du unter [Nutzung verfolgen](https://platform.claude.com/docs/de/managed-agents/session-observability#track-usage). ## Budgets in Multiagent-Sitzungen Eine [Multiagent](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration)-Sitzung hat ein einziges Budget, das über alle ihre Threads geteilt wird; es gibt keine Obergrenzen pro Thread. Der Verbrauch jedes Threads wird zu seinem eigenen bereitgestellten Modell bepreist, und Threads pausieren unabhängig voneinander, wenn die gemeinsame Obergrenze erreicht wird. [Advisor](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration#give-the-session-an-advisor)-Konsultationen zählen gegen dasselbe Budget, bepreist zu den Preisen des Advisor-Modells. Ein Thread kann bei `budget_reached` pausieren, während ein anderer seine laufende Anfrage abschließt. Eine ausstehende Rückfrage hat Vorrang vor der Obergrenze: Eine Sitzung mit einem Thread, der auf `requires_action` wartet, und einem anderen, der bei `budget_reached` pausiert ist, meldet `requires_action` auf Sitzungsebene. Die ausstehende Anfrage braucht weiterhin eine Antwort, und sie zu beantworten ist ein [Abschluss-Event](https://platform.claude.com/docs/de/managed-agents/budgets#events-accepted-at-the-cap), das das Budget nicht blockiert. ## Budgets bei Deployments Ein [Deployment](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments) akzeptiert dasselbe `budget`-Objekt, wenn du es erstellst oder aktualisierst: ```json { "budget": { "type": "limit", "max_list_cost": { "amount": "2000", "currency": "USD" } } } ``` Die Obergrenze wird auf jede Sitzung kopiert, die das Deployment startet, sodass sie jede Ausführung einzeln begrenzt und nicht die kumulierten Ausgaben des Deployments. Eine Änderung des Budgets des Deployments gilt für Sitzungen, die das Deployment danach startet, nicht für bereits laufende Sitzungen. Anders als bei einer Sitzung kann das Budget eines Deployments mit `"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`) gelöscht und später erneut festgelegt werden. Siehe [Ein Budget für jede Ausführung festlegen](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments#set-a-budget-on-each-run). ## Modelle ohne Listenpreis Ein Budget kann nur Verbrauch erfassen, den die Plattform bepreisen kann. Das Erstellen einer Sitzung mit Budget, deren Agent oder ein beliebiger Agent in der Liste `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) von `subagents` (csharp, go: `Subagents`) oder `workflows` (csharp, go: `Workflows`) oder der in ihrer [Multiagent-Konfiguration](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration) festgelegte Advisor ein Modell ohne öffentlichen Listenpreis verwendet, wird mit einem 400-Fehler abgelehnt, der angibt, dass für das Modell kein Listenpreis verfügbar ist. Wenn die Nutzung einer Sitzung mit Budget ein Modell ohne Listenpreis einschließt, kann das Budget die Ausgaben der Sitzung nicht mehr messen: Die Sitzung kann mit einem `stop_reason` (java, php: `stopReason`; csharp, go: `StopReason`) von `budget_reached` pausieren, und das Ändern des Budgets wird abgelehnt. Entferne das Budget, um die Sitzung fortzusetzen. ## Fehlerreferenz Budgetbezogene Anfragen werden in den folgenden Fällen abgelehnt: | Bedingung | Status | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | | Ein Arbeit startendes Event (zum Beispiel `user.message`) wird gesendet, während die Sitzung bei oder über ihrem Budget liegt; der Fehler nennt die [akzeptierten Abschluss-Events](https://platform.claude.com/docs/de/managed-agents/budgets#events-accepted-at-the-cap) | 400 | | Das Budget wird auf einen Wert bei oder unter den verbrauchten Listenkosten der Sitzung gesetzt | 400 | | Ein Budget wird einer ohne Budget erstellten Sitzung hinzugefügt oder nach dem Entfernen erneut hinzugefügt | 400 | | `amount` (csharp, go: `Amount`) ist keine ganze Zahl von Cent (zum Beispiel `"25.00"`), ist null oder negativ, oder `currency` (csharp, go: `Currency`) ist nicht `USD` | 400 | | Eine budgetierte Erstellung referenziert ein Modell [ohne öffentlichen Listenpreis](https://platform.claude.com/docs/de/managed-agents/budgets#models-without-a-list-price) | 400 | Sitzungsbudgets sind harte Obergrenzen in US-Dollar (in Cent geschrieben) für eine einzelne Sitzung, die von der Plattform durchgesetzt werden. Sie unterscheiden sich von den [Task-Budgets](https://platform.claude.com/docs/de/build-with-claude/task-budgets) der Messages API, die beratende, in Token bemessene Budgets sind, die das Modell zur Selbstregulierung innerhalb einer agentischen Schleife verwendet.