---
title: Konfigurationsreferenz
url: https://platform.claude.com/docs/de/managed-agents/self-hosted/configuration-reference
description: Sieh nach, wo die Einstellungen eines selbst gehosteten Claude Managed Agents-Servers stehen, und schlage Schlüssel, Umgebungsvariable, Standardwert und Zweck jeder Einstellung nach.
---
Um Zugriff auf selbst gehostetes Claude Managed Agents anzufordern, kontaktiere dein Anthropic-Account-Team.
Diese Seite zeigt, wo die Einstellungen eines selbst gehosteten Claude Managed Agents-Servers stehen, und listet sie auf. Wie du eine Funktion einrichtest, erfährst du unter [Single Sign-on](https://platform.claude.com/docs/de/managed-agents/self-hosted/configure), [Agent-Identität und Anmeldeinformationen](https://platform.claude.com/docs/de/managed-agents/self-hosted/agent-identity) und [Inferenz-Provider](https://platform.claude.com/docs/de/managed-agents/self-hosted/inference-provider).
## Wo die Einstellungen stehen
Der Server liest seine Einstellungen aus einer YAML-Datei und seine Anmeldedaten aus seiner Umgebung.
* **Docker Compose:** Die Datei ist `compose.config.yaml`, neben `docker-compose.yml` im entpackten Archiv. Bearbeite sie und führe dann `docker compose restart cma-server` in diesem Verzeichnis aus.
* **Kubernetes:** Die Datei ist der Wert `server.config` des Server-Helm-Charts. Bearbeite ihn in deiner Values-Datei, führe `helm upgrade` aus und starte die Server dann mit `kubectl -n cma-server rollout restart deployment -l anthropic.com/role=server` neu. Siehe [Auf Kubernetes bereitstellen](https://platform.claude.com/docs/de/managed-agents/self-hosted/kubernetes).
Wenn der Server eine Einstellung ablehnt, die die Seiten zum Self-Hosting zeigen, [aktualisiere den Server](https://platform.claude.com/docs/de/managed-agents/self-hosted/upgrade). `cma-server.example.yaml` auf der obersten Ebene des Archivs kommentiert die gängigen Schlüssel.
Anmeldedaten gehören nie in die Datei. Der Server liest sie aus Umgebungsvariablen oder aus der Identität, die deine Cloud dem Host zuordnet.
### Anmeldedaten an den Compose-Stack übergeben
Im Compose-Stack erhält der Server-Container nur die Variablen in der `environment:`-Liste des Dienstes `cma-server` in `docker-compose.yml`. So übergibst du eine weitere:
1. Füge ihren Namen zu dieser Liste hinzu und setze ihren Wert in `.env`.
2. Wenn die Anmeldedaten eine Datei sind, lege die Datei neben `docker-compose.yml` und füge eine Zeile wie `- ./gcp-key.json:/etc/cma-server/gcp-key.json:ro` zur Liste `x-server-mounts` in `docker-compose.yml` hinzu. Der Pfad nach dem ersten Doppelpunkt ist der Pfad der Datei im Container. Verwende diesen Pfad als Wert der Variable in `.env` oder als Wert der Einstellung, die die Datei benennt.
3. Führe `docker compose up -d` aus. Ein Neustart liest `.env` nicht erneut ein.
Ein Upgrade ersetzt `docker-compose.yml`, also wiederhole diese Änderungen in der Datei des neuen Releases, bevor du dessen Stack startest.
## So liest du die Tabellen
Jede Einstellung hat einen Schlüssel in der [Einstellungsdatei](https://platform.claude.com/docs/de/managed-agents/self-hosted/configuration-reference#where-settings-go), und die meisten Einstellungen haben zusätzlich eine Umgebungsvariable. Eine Variable überschreibt die Datei, und die Datei überschreibt den Standardwert. Der Server startet nicht, wenn seine Einstellungsdatei einen unbekannten Schlüssel enthält, und der Fehler gibt an, wo der Schlüssel steht.
* **Schlüssel:** Jeder Punkt in einem Schlüssel ist eine Verschachtelungsebene in der Datei. Zum Beispiel ist `server.addr` der Schlüssel `addr` im Abschnitt `server`.
* **Variablen:** Der Name einer Variable ist `CMA_`, gefolgt vom Schlüssel in Großbuchstaben, mit zwei Unterstrichen anstelle jedes Punkts.
* **Nur Datei:** Die Einstellung hat keine Variable.
* **Nur Umgebung:** Der Server startet nicht, wenn die Einstellung in der Datei steht.
* **Nur `bedrock` und ähnliche Bezeichnungen:** Die Einstellung funktioniert nur mit diesem Provider, Speicher oder Secret-Manager. Wenn du sie setzt, während du einen anderen verwendest, startet der Server nicht.
* **Listen:** Eine Liste ist in der Datei eine YAML-Liste und in einer Variable ein kommagetrennter String.
* **Dauern:** Eine Dauer ist eine Zahl mit einer Einheit, wie `30s`, `5m` oder `1h`.
* **Ganzzahlen:** Eine Ganzzahl besteht nur aus Ziffern, ohne Vorzeichen, führende Null oder Unterstrich.
Beim Start protokolliert der Server die Einstellungen, die du gesetzt hast, und die meisten Standardwerte, jeweils mit der Herkunft des Werts, etwa `server.addr=0.0.0.0:8400 (file)`. Anstelle eines Geheimnisses protokolliert er `***`, außer bei einem Server-API-Key, den er selbst generiert hat.
## Server und Logging
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| --------------------------------------------------------------------------------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `server.addr`
`CMA_SERVER__ADDR` | `127.0.0.1:8400` | Die Adresse, auf der der Server lauscht. |
| `server.api_key`
`CMA_SERVER__API_KEY` | Keiner | Der [Server-API-Key](https://platform.claude.com/docs/de/managed-agents/self-hosted#the-three-credentials). Erforderlich mit `store.backend: postgres`, es sei denn, `auth.refuse_server_api_key` ist `true`. Mit `memory` generiert der Server einen Key, wenn du keinen setzt, und protokolliert ihn beim Start. |
| `server.id_marker`
`CMA_SERVER__ID_MARKER` | `local` | Was in jeder vom Server erstellten ID auf das Präfix folgt. `local` ergibt `sesn_local_01…`, und `none` ergibt `sesn_01…`, wie beim gehosteten Dienst. |
| `server.shutdown_delay`
`CMA_SERVER__SHUTDOWN_DELAY` | `0s` | Wie lange der Server nach einem Stoppsignal weiter Anfragen bedient, während seine „readiness probe“ (Bereitschaftsprüfung) mit `not_ready` antwortet. Das Maximum ist `5m`. |
| `server.max_connections`
`CMA_SERVER__MAX_CONNECTIONS` | `0` | Die maximale Anzahl an Verbindungen, die der Server auf `server.addr` gleichzeitig offen hält. `0` bedeutet kein Limit. Am Limit wartet eine neue Verbindung, bis eine andere geschlossen wird oder ihr Client aufgibt. Event-Streams, Worker-Polls und Health-Probes zählen alle mit. Auf Kubernetes startet das Kubelet einen Pod neu, dessen Probes zu lange warten. |
| `logging.format`
`CMA_LOGGING__FORMAT` | `text` | Das Log-Format, `text` oder `json`. |
| `logging.level`
`CMA_LOGGING__LEVEL` | `info` | Die niedrigste Stufe, die der Server protokolliert. Die Werte sind `debug`, `info`, `warn` und `error`. |
| `logging.errors`
`CMA_LOGGING__ERRORS` | `false` | Ob das Log die Fehlermeldungen von `4xx`- und `5xx`-Antworten enthält. Eine Meldung kann einen Wert zitieren, den der Client gesendet hat. |
| `health.check_interval`
`CMA_HEALTH__CHECK_INTERVAL` | `60s` | Wie oft der Server seine Inferenz-Anmeldedaten für die Readiness Probe prüft. Das Minimum ist `5s`. |
| `health.upstream_affects_readiness`
`CMA_HEALTH__UPSTREAM_AFFECTS_READINESS` | `true` | Ob die Readiness Probe mit `503` antwortet, solange der Inferenz-Provider die Anmeldedaten des Servers ablehnt. |
## Datenbank
Jede Einstellung in dieser Tabelle außer `store.backend` gilt nur mit `store.backend: postgres`.
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| --------------------------------------------------------------------------------------------------------------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `store.backend`
`CMA_STORE__BACKEND` | `memory` | Wo der Server seine Daten speichert. Die Werte sind `memory`, das ein Neustart löscht, und `postgres`. |
| `store.database_url`
`CMA_STORE__DATABASE_URL` | Keiner | Der PostgreSQL-Verbindungsstring. Erforderlich mit `postgres`. |
| `store.control_database_url`
`CMA_STORE__CONTROL_DATABASE_URL` | Der Wert von `store.database_url` | Der Verbindungsstring für die eigenen Wartungsverbindungen des Servers, etwa seinen Heartbeat. |
| `store.listen_database_url`
`CMA_STORE__LISTEN_DATABASE_URL` | Der Wert von `store.database_url` | Der Verbindungsstring für die eine Verbindung, über die der Server auf Benachrichtigungen lauscht. Ein Connection-Pooler im Transaktionsmodus kann diese Verbindung nicht übertragen. |
| `store.migrate_database_url`
`CMA_STORE__MIGRATE_DATABASE_URL` | Der Wert von `store.database_url` | Der Verbindungsstring, den der `migrate`-Befehl des Servers verwendet. Ein Connection-Pooler im Transaktionsmodus kann diese Verbindung nicht übertragen. |
| `store.pool_max_conns`
`CMA_STORE__POOL_MAX_CONNS` | `24` | Die maximale Anzahl an Datenbankverbindungen, die der Pool eines Servers öffnet. Das Minimum ist `4`. |
| `store.event_poll_interval`
`CMA_STORE__EVENT_POLL_INTERVAL` | `25ms` | Wie oft jeder Server die Datenbank nach den neuesten Events in den Sessions abfragt, die seine Clients streamen. Ein Event, das ein anderer Server erfasst hat, wartet höchstens etwa so lange, bis es den Stream erreicht. |
| `store.credentials_encryption_key`
`CMA_STORE__CREDENTIALS_ENCRYPTION_KEY`
Nur Umgebung | Keiner | Der Schlüssel, der gespeicherte Anmeldedaten in der Datenbank verschlüsselt, als 32 zufällige Bytes in Base64. Die Docker Compose- und Kubernetes-Installationen setzen ihn. Der Server startet ohne ihn nicht, es sei denn, `store.allow_unencrypted_credentials` ist `true`. |
| `store.allow_unencrypted_credentials`
`CMA_STORE__ALLOW_UNENCRYPTED_CREDENTIALS` | `false` | Ob der Server ohne `store.credentials_encryption_key` starten kann. Ohne den Schlüssel speichert er Anmeldedaten im Klartext in der Datenbank. `true` hat keine Wirkung, wenn `git.allowed_hostnames` einen Host auflistet oder wenn du mit Docker Compose oder dem Server-Helm-Chart installierst. |
| `store.credentials_encryption_keys_retiring`
`CMA_STORE__CREDENTIALS_ENCRYPTION_KEYS_RETIRING`
Nur Umgebung | Keiner | Frühere Verschlüsselungsschlüssel, mit denen der Server während einer Schlüsselrotation weiterhin entschlüsseln kann. Diese Einstellung benötigt `store.credentials_encryption_key`. |
## Inferenz-Provider
Wie du einen Provider einrichtest, erfährst du unter [Inferenz-Provider](https://platform.claude.com/docs/de/managed-agents/self-hosted/inference-provider).
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| -------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `inference.provider`
`CMA_INFERENCE__PROVIDER` | `anthropic` | Wohin der Server Modellaufrufe sendet. Die Werte sind `anthropic`, `bedrock`, `vertex`, `foundry` und `gateway`. |
| `inference.headers`
Nur Datei | Keiner | Request-Header, die der Server jedem Modellaufruf hinzufügt, als Map von Header-Name zu Wert. Setze jeden Wert in Anführungszeichen. Der Server verweigert den Start bei einem Wert ohne Anführungszeichen, den YAML nicht als Text liest, etwa `true` oder `0042`. Mit `gateway` kann ein Wert auch `{ from: request_id }` oder `{ from: session_id }` sein. |
| `inference.model_fallback`
`CMA_INFERENCE__MODEL_FALLBACK` | `true` | Nur `anthropic`. Ob Modellaufrufe einen [serverseitigen Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback) anfordern. Diese Aufrufe enthalten ein `fallbacks`-Feld und den Header `anthropic-beta: server-side-fallback-2026-07-01`. Ein Proxy, den du in `ANTHROPIC_BASE_URL` angibst, lehnt das Feld oder den Header möglicherweise ab. Wenn er mit `400` oder `422` antwortet, sendet der Server den Aufruf erneut ohne sie. |
| `inference.metadata.user_id`
`CMA_INFERENCE__METADATA__USER_ID` | Keiner | Nur `anthropic` und `foundry` oder `gateway` mit `format: anthropic-messages`. Ein Bezeichner, den der Server mit jedem Modellaufruf als `metadata.user_id` sendet. Das Startprotokoll gibt ihn aus. Ohne diese Einstellung sendet der Server die Bezeichnung `cma-server`. Du kannst `metadata.user_id` nicht abschalten. Wenn der Provider oder ein Proxy ihn ablehnt, schlägt jeder Modellaufruf fehl. Siehe [Was dein Netzwerk verlässt](https://platform.claude.com/docs/de/managed-agents/self-hosted-data-and-access#what-leaves-your-network). |
### Cloud-Provider
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| -------------------------------------------------------------------- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `inference.region`
`CMA_INFERENCE__REGION` | Keiner | Nur `bedrock` und `vertex`. Die AWS-Region oder der Standort in Google Cloud’s Agent Platform. Erforderlich mit `vertex`. Ohne sie verwendet `bedrock` die Region, die die Standardkette des AWS SDK findet. |
| `inference.project_id`
`CMA_INFERENCE__PROJECT_ID` | Keiner | Nur `vertex`. Das Google Cloud-Projekt, in dem die Aufrufe erfolgen. Erforderlich, es sei denn, die Google-Anmeldedaten benennen ein Projekt. |
| `inference.api`
`CMA_INFERENCE__API` | `invoke_model` | Nur `bedrock`. Die Amazon Bedrock-API, die die Aufrufe überträgt, `invoke_model` oder `messages`. `messages` ist der Endpunkt, den [Claude in Amazon Bedrock (`bedrock-mantle`)](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) beschreibt. Damit benötigt die AWS-Rolle des Servers `bedrock-mantle:CreateInference` anstelle von `bedrock:InvokeModel` und `bedrock:InvokeModelWithResponseStream`. |
| `inference.list_models`
`CMA_INFERENCE__LIST_MODELS` | `true` | Nur `bedrock`. Ob der Server die Listen der Claude-Modelle von Amazon Bedrock liest. Mit diesen Listen können Agents ein Modell verwenden, das nach dem Release deines Servers erschienen ist. |
| `inference.model_id_prefix`
`CMA_INFERENCE__MODEL_ID_PREFIX` | `us.anthropic.` | Nur `bedrock`. Der Text, den der Server jeder Modell-ID voranstellt. Mit `inference.api: messages` ist der Standardwert `anthropic.`. |
| `inference.model_id_overrides`
Nur Datei | Keiner | Nur `bedrock`, `vertex` und `foundry`. Eine Map von Modell-ID zur exakten ID, die der Provider erwartet. Mit `foundry` ist diese ID ein Deployment-Name. |
| `inference.foundry.resource`
`CMA_INFERENCE__FOUNDRY__RESOURCE` | Keiner | Nur `foundry`. Der Name der Foundry-Ressource. Setze dies oder `inference.foundry.base_url`, nicht beides. |
| `inference.foundry.base_url`
`CMA_INFERENCE__FOUNDRY__BASE_URL` | Keiner | Nur `foundry`. Standardmäßig gehen Aufrufe an `https://.services.ai.azure.com/anthropic`. Um die Ressource unter einer anderen Adresse zu erreichen, etwa über einen Proxy, setze stattdessen hier diese URL. Sie endet auf `/anthropic`. |
### Modell-Gateway
Diese Einstellungen gelten nur mit `inference.provider: gateway`. Siehe [Modell-Gateway](https://platform.claude.com/docs/de/managed-agents/self-hosted/inference-provider#model-gateway).
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ----------------------------------------------------------------------------------------- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `inference.gateway.url`
`CMA_INFERENCE__GATEWAY__URL` | Keiner | Erforderlich. Die URL, die Modellaufrufe empfängt. Mit `bedrock-invoke` und `vertex-raw-predict` markiert `{model}`, wo die Modell-ID eingesetzt wird. Mit `vertex-raw-predict` muss die URL auf `/{model}:rawPredict` enden. |
| `inference.gateway.format`
`CMA_INFERENCE__GATEWAY__FORMAT` | Keiner | Erforderlich. Das Request-Format, das das Gateway akzeptiert: `bedrock-invoke`, `anthropic-messages` oder `vertex-raw-predict`. |
| `inference.gateway.model_map`
Nur Datei | Keiner | Erforderlich. Eine Map von jeder Modell-ID, die Agents benennen können, zur ID, die das Gateway erwartet. Setze jeden Wert in Anführungszeichen, wie bei `inference.headers`. |
| `inference.gateway.streaming`
`CMA_INFERENCE__GATEWAY__STREAMING` | `false` | Ob der Server den gestreamten Aufruf des Formats sendet, sodass Antworten eintreffen, während das Modell sie erzeugt. Mit `bedrock-invoke` geht dieser Aufruf an dieselbe URL mit angehängtem `-with-response-stream`. Mit `vertex-raw-predict` geht dieser Aufruf an dieselbe URL mit `:streamRawPredict` anstelle von `:rawPredict`. Lass `:rawPredict` in `inference.gateway.url` stehen. |
| `inference.credentials.supplier`
`CMA_INFERENCE__CREDENTIALS__SUPPLIER` | Keiner | Erforderlich. Woher die Anmeldedaten des Gateways stammen. `env` bedeutet einen langlebigen Key, `oauth_exchange` bedeutet kurzlebige Tokens, und `azure` bedeutet Microsoft Entra ID-Tokens, die für die eigene Azure-Identität des Servers ausgestellt werden. |
| `inference.credentials.env.var`
`CMA_INFERENCE__CREDENTIALS__ENV__VAR` | Keiner | Erforderlich mit `env`. Der Name der Umgebungsvariable, die den Key enthält. |
| `inference.credentials.azure.scope`
`CMA_INFERENCE__CREDENTIALS__AZURE__SCOPE` | Keiner | Erforderlich mit `azure`. Der Scope, für den der Server Tokens anfordert: der Anwendungs-ID-URI oder die Anwendungs-ID der App-Registrierung deines Gateways, gefolgt von `/.default`. |
| `inference.credentials.send_as.header`
`CMA_INFERENCE__CREDENTIALS__SEND_AS__HEADER` | `Authorization` | Der Request-Header, der die Anmeldedaten überträgt. |
| `inference.credentials.send_as.scheme`
`CMA_INFERENCE__CREDENTIALS__SEND_AS__SCHEME` | `Bearer` | Das Wort, das den Anmeldedaten im Header vorangestellt wird. Bei jedem anderen Header als `Authorization` ist der Standard kein Schema. |
| `inference.credentials.renew_before`
`CMA_INFERENCE__CREDENTIALS__RENEW_BEFORE` | `90s` | Mit `oauth_exchange`, wie früh der Server ein Token ersetzt. Er verwendet ein zwischengespeichertes Token ab dieser Zeitspanne vor dessen Ablauf nicht mehr und holt sich für den nächsten Modellaufruf ein neues. Halte den Wert unter der Lebensdauer deiner Tokens. Der Server lehnt jedes Token ab, das kürzer als dieser Wert gültig ist. |
### Kurzlebige Gateway-Tokens
Diese Einstellungen gelten nur mit `inference.credentials.supplier: oauth_exchange`. Siehe [Kurzlebige Tokens](https://platform.claude.com/docs/de/managed-agents/self-hosted/inference-provider#short-lived-tokens). Die `exchange`-Einstellungen sind als Gruppe optional. Ohne sie sendet der Server dem Gateway, was der Callback zurückgibt.
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ----------------------------------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `inference.credentials.assertion.url`
`CMA_INFERENCE__CREDENTIALS__ASSERTION__URL` | Keiner | Erforderlich. Die URL des HTTP-Callbacks, der eine signierte Assertion zurückgibt. |
| `inference.credentials.assertion.auth.type`
`CMA_INFERENCE__CREDENTIALS__ASSERTION__AUTH__TYPE` | Keiner | Erforderlich. Wie sich der Server beim Callback authentifiziert, `mtls` oder `bearer_file`. |
| `inference.credentials.assertion.auth.cert_file`
`CMA_INFERENCE__CREDENTIALS__ASSERTION__AUTH__CERT_FILE` | Keiner | Erforderlich mit `mtls`. Der Pfad des Client-Zertifikats des Servers. |
| `inference.credentials.assertion.auth.key_file`
`CMA_INFERENCE__CREDENTIALS__ASSERTION__AUTH__KEY_FILE` | Keiner | Erforderlich mit `mtls`. Der Pfad des privaten Schlüssels des Client-Zertifikats. |
| `inference.credentials.assertion.auth.token_file`
`CMA_INFERENCE__CREDENTIALS__ASSERTION__AUTH__TOKEN_FILE` | Keiner | Erforderlich mit `bearer_file`. Der Pfad einer Datei, die das Bearer-Token enthält. |
| `inference.credentials.assertion.auth.ca_file`
`CMA_INFERENCE__CREDENTIALS__ASSERTION__AUTH__CA_FILE` | Keiner | Der Pfad einer PEM-Datei mit den Zertifizierungsstellen, denen der Server für den Callback vertraut. |
| `inference.credentials.assertion.forward_metadata`
`CMA_INFERENCE__CREDENTIALS__ASSERTION__FORWARD_METADATA` | Keiner | Die Session-Metadatenschlüssel, deren Werte der Server an den Callback sendet. Sie kommen als `session.metadata` im Request-Body an. Die Werte sind das, was der API-Aufrufer geschrieben hat, also prüfe sie anhand deiner eigenen Datensätze. |
| `inference.credentials.exchange.token_url`
`CMA_INFERENCE__CREDENTIALS__EXCHANGE__TOKEN_URL` | Keiner | Erforderlich für einen Austausch. Der OAuth-Token-Endpunkt, an dem der Server die Assertion gegen ein Token austauscht. |
| `inference.credentials.exchange.grant_type`
`CMA_INFERENCE__CREDENTIALS__EXCHANGE__GRANT_TYPE` | Keiner | Erforderlich für einen Austausch. Der `grant_type`, den der Server sendet, etwa `urn:ietf:params:oauth:grant-type:jwt-bearer`. |
| `inference.credentials.exchange.encoding`
`CMA_INFERENCE__CREDENTIALS__EXCHANGE__ENCODING` | `form` | Wie der Server die Austauschanfrage kodiert, `form` oder `multipart`. |
| `inference.credentials.exchange.expiry`
`CMA_INFERENCE__CREDENTIALS__EXCHANGE__EXPIRY` | `expires_in` | Woher der Server die Lebensdauer des Tokens liest. `expires_in` bedeutet den früheren Zeitpunkt aus `expires_in` der Antwort und dem `exp`-Claim des Tokens. `jwt_exp` bedeutet ausschließlich den `exp`-Claim. |
| `inference.credentials.exchange.headers`
Nur Datei | Keiner | Zusätzliche Request-Header für den Token-Endpunkt, als Map von Header-Name zu Wert. Setze jeden Wert in Anführungszeichen, wie bei `inference.headers`. |
| `inference.credentials.exchange.ca_file`
`CMA_INFERENCE__CREDENTIALS__EXCHANGE__CA_FILE` | Keiner | Der Pfad einer PEM-Datei mit den Zertifizierungsstellen, denen der Server für den Token-Endpunkt vertraut. |
## Single Sign-on
Wie du die Anmeldung einrichtest, erfährst du unter [Single Sign-on](https://platform.claude.com/docs/de/managed-agents/self-hosted/configure).
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ------------------------------------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `auth.issuers`
Nur Datei | Keiner | Die OpenID Connect-Issuer, deren Tokens der Server akzeptiert. Siehe [Issuer-Einträge](https://platform.claude.com/docs/de/managed-agents/self-hosted/configuration-reference#issuer-entries). |
| `auth.refuse_server_api_key`
Nur Datei | `false` | Ob der Server den Server-API-Key auf jeder Route ablehnt. `true` benötigt mindestens einen Issuer. Jeder Admin-CLI-Befehl, der den Key verwendet, schlägt dann fehl. |
### Issuer-Einträge
Jeder Eintrag von `auth.issuers` nimmt diese Felder an:
| Feld | Standardwert | Beschreibung |
| ----------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name` | Keiner | Erforderlich. Eine Bezeichnung für den Issuer in Log-Zeilen. Der Server erfasst sie außerdem als Teil des Erstellers jeder Ressource. |
| `issuer_url` | Keiner | Erforderlich. Die URL des Issuers, genau wie im `iss`-Claim seiner Tokens. Der Server ruft Signaturschlüssel von diesem Host und vom `jwks_uri`-Host ab, den das Discovery-Dokument des Issuers benennt. Wenn dein Netzwerk ausgehende Verbindungen einschränkt, lass beide Hosts zu. |
| `audiences` | Keiner | Erforderlich. Die Werte, die der `aud`-Claim eines Tokens enthalten kann. Wenn Anwendungen Tokens weiterleiten, die sie bereits besitzen, liste die Client-ID jeder Anwendung auf. |
| `roles` | Keiner | Eine Liste von `group`- und `role`-Paaren. Eine Gruppe passt exakt oder als Muster, in dem `*` für eine beliebige Zeichenfolge und `?` für ein Zeichen steht. Eine Rolle ist `admin`, `developer` oder `user`. Die höchste passende Rolle gewinnt. Setze `roles`, `default_role` oder beides. |
| `default_role` | Keiner | Die Rolle eines Aufrufers, dessen Gruppen zu keinem `roles`-Eintrag passen. Setze sie nur, wenn jeder, der ein Token für diese Audience erhalten kann, Zugriff haben soll. |
| `subject_claim` | `sub` | Der Claim, der den Aufrufer identifiziert. Ein Name, der mit `/` beginnt, ist ein JSON Pointer in verschachtelte Claims. |
| `stable_subject` | `false` | Gilt nur, wenn `subject_claim` einen anderen Claim als `sub` oder `oid` benennt. Setze `true`, um zu bestätigen, dass dein Provider den Wert dieses Claims einer Person nie ändert und ihn nie jemand anderem gibt. Der Server prüft das nicht. Mit `false` lassen [Agent-Tokens](https://platform.claude.com/docs/de/managed-agents/self-hosted/configuration-reference#agent-identity) die Claims `actor_sub` und `actor_iss` weg. |
| `groups_claim` | `groups` | Der Claim, der die Gruppen des Aufrufers auflistet. Ein Name, der mit `/` beginnt, ist ein JSON Pointer in verschachtelte Claims. |
| `jwks_file` | Keiner | Der Pfad einer JSON Web Key Set-Datei. Der Server liest Signaturschlüssel daraus und kontaktiert den Issuer nie. |
| `login_client_id` | Keiner | Die Client-ID der Anwendung, die der [Terminal-Login](https://platform.claude.com/docs/de/managed-agents/self-hosted/configure#let-developers-log-in-from-a-terminal) verwendet. Nur ein Issuer kann sie setzen. |
| `login_scopes` | `[openid]` | Die Scopes, die der Login anfordert. Dieses Feld benötigt `login_client_id`. |
## Secret-Manager
Wie du einen Speicher einrichtest, erfährst du unter [Secret-Manager](https://platform.claude.com/docs/de/managed-agents/self-hosted/agent-identity#secret-manager).
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ----------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `secret_store.type`
`CMA_SECRET_STORE__TYPE` | Keiner | Der Secret-Manager, der Vault-Anmeldedaten enthält. Die Werte sind `aws_secrets_manager`, `gcp_secret_manager`, `azure_key_vault` und `hashicorp_vault`. Ohne ihn bleiben Vault-Anmeldedaten in der Datenbank. |
| `secret_store.prefix`
`CMA_SECRET_STORE__PREFIX` | Keiner | Erforderlich mit `secret_store.type`. Der Anfang des Namens jedes Secrets, das der Server erstellt. Er muss bei `aws_secrets_manager` und `hashicorp_vault` auf `/` enden, bei `gcp_secret_manager` auf `-` oder `_` und bei `azure_key_vault` auf `-`. |
| `secret_store.region`
`CMA_SECRET_STORE__REGION` | Keiner | Nur `aws_secrets_manager` und dort erforderlich. Die AWS-Region, die die Secrets enthält. |
| `secret_store.project`
`CMA_SECRET_STORE__PROJECT` | Keiner | Nur `gcp_secret_manager` und dort erforderlich. Die ID des Google Cloud-Projekts, das die Secrets enthält. |
| `secret_store.vault_url`
`CMA_SECRET_STORE__VAULT_URL` | Keiner | Nur `azure_key_vault` und dort erforderlich. Die URL des Key Vault, etwa `https://my-vault.vault.azure.net`. |
### HashiCorp Vault
Diese Einstellungen gelten nur mit `secret_store.type: hashicorp_vault`. Setze genau eine Login-Methode: `token_file`, `kubernetes` oder `approle`.
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| -------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `secret_store.address`
`CMA_SECRET_STORE__ADDRESS` | Keiner | Erforderlich. Die `https://`-URL des Vault-Servers. |
| `secret_store.namespace`
`CMA_SECRET_STORE__NAMESPACE` | Keiner | Der Vault Enterprise-Namespace, der den Mount und die Login-Methode enthält. |
| `secret_store.mount`
`CMA_SECRET_STORE__MOUNT` | `secret` | Der Pfad der KV-Secrets-Engine Version 2. |
| `secret_store.ca_cert_file`
`CMA_SECRET_STORE__CA_CERT_FILE` | Keiner | Der Pfad einer PEM-Datei mit der Zertifizierungsstelle, die das Zertifikat von Vault signiert hat. |
| `secret_store.token_file`
`CMA_SECRET_STORE__TOKEN_FILE` | Keiner | Der Pfad einer Datei mit einem Vault-Token, das ein anderer Prozess, etwa Vault Agent, aktuell hält. |
| `secret_store.kubernetes.role`
`CMA_SECRET_STORE__KUBERNETES__ROLE` | Keiner | Erforderlich mit `kubernetes`. Die Vault-Rolle, mit der sich der Server anmeldet. Binde sie an den Service-Account des Servers. |
| `secret_store.kubernetes.mount_path`
`CMA_SECRET_STORE__KUBERNETES__MOUNT_PATH` | `kubernetes` | Wo Vault die Kubernetes-Login-Methode einbindet. |
| `secret_store.kubernetes.service_account_token_file`
`CMA_SECRET_STORE__KUBERNETES__SERVICE_ACCOUNT_TOKEN_FILE` | `/var/run/secrets/kubernetes.io/serviceaccount/token` | Der Pfad des Service-Account-Tokens, das der Server bei jedem Login vorlegt. |
| `secret_store.approle.role_id`
`CMA_SECRET_STORE__APPROLE__ROLE_ID` | Keiner | Erforderlich mit `approle`. Die ID der AppRole-Rolle, mit der sich der Server anmeldet. |
| `secret_store.approle.secret_id_file`
`CMA_SECRET_STORE__APPROLE__SECRET_ID_FILE` | Keiner | Erforderlich mit `approle`. Der Pfad einer Datei mit der `secret_id` der Rolle. |
| `secret_store.approle.mount_path`
`CMA_SECRET_STORE__APPROLE__MOUNT_PATH` | `approle` | Wo Vault die AppRole-Login-Methode einbindet. |
## Agent-Identität
Wie du Agent-Tokens einrichtest, erfährst du unter [Agent-Identität](https://platform.claude.com/docs/de/managed-agents/self-hosted/agent-identity#agent-identity). Jede Einstellung in dieser Tabelle aktiviert die Funktion. Der Server benötigt dann `agent_identity.issuer` und genau einen Ort für den Signaturschlüssel: `key_file`, `key_secret` oder `kms_key`.
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ----------------------------------------------------------------------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `agent_identity.issuer`
`CMA_AGENT_IDENTITY__ISSUER` | Keiner | Die `https://`-URL, die Agent-Tokens als ihren `iss`-Claim tragen. |
| `agent_identity.key_file`
`CMA_AGENT_IDENTITY__KEY_FILE` | Keiner | Der Pfad des privaten PEM-Schlüssels, der die Tokens signiert. |
| `agent_identity.key_secret`
`CMA_AGENT_IDENTITY__KEY_SECRET` | Keiner | Der Name des Secrets, das den privaten PEM-Schlüssel in deinem Secret-Manager enthält, ohne `secret_store.prefix`. |
| `agent_identity.kms_key.provider`
`CMA_AGENT_IDENTITY__KMS_KEY__PROVIDER` | Keiner | Der Schlüsselverwaltungsdienst, der den Signaturschlüssel enthält, `aws_kms` oder `gcp_kms`. |
| `agent_identity.kms_key.key`
`CMA_AGENT_IDENTITY__KMS_KEY__KEY` | Keiner | Erforderlich mit `kms_key.provider`. Die ARN des Schlüssels für `aws_kms` oder der Ressourcenname einer Schlüsselversion für `gcp_kms`. |
| `agent_identity.published_key_files`
`CMA_AGENT_IDENTITY__PUBLISHED_KEY_FILES` | Keiner | Die Pfade zusätzlicher öffentlicher PEM-Schlüssel für das Schlüssel-Set. Der Server veröffentlicht diese Schlüssel, signiert aber nie damit. Verwende diese Einstellung, wenn du den Signaturschlüssel rotierst. |
| `agent_identity.token_lifetime`
`CMA_AGENT_IDENTITY__TOKEN_LIFETIME` | `5m` | Die Zeit vom `iat`-Claim eines Tokens bis zu seinem `exp`-Claim. Ein bereits gesendetes Token bleibt bis zu seinem `exp` gültig. Das Minimum ist `limits.mcp_call_timeout` plus `1m`, und das Maximum ist `15m`. |
| `agent_identity.jwks_uri`
`CMA_AGENT_IDENTITY__JWKS_URI` | `/.well-known/jwks.json` | Die URL, die das Discovery-Dokument des Issuers für das Schlüssel-Set angibt. Setze sie nur, wenn du das Schlüssel-Set an einem anderen Ort als unter der Issuer-URL hostest. |
| `agent_identity.direct.audiences`
Nur Datei | Keiner | Die Empfänger, die ein Token erhalten können. Jeder Eintrag hat eine `audience`-URL und `urls`, die URL-Präfixe der MCP-Server dieses Empfängers. |
| `agent_identity.actor.enabled`
`CMA_AGENT_IDENTITY__ACTOR__ENABLED` | `true` | Ob der Server dem Token eines Tool-Aufrufs die Claims `actor_sub` und `actor_iss` hinzufügt. `actor_sub` ist das Subject des Aufrufers, der die Session erstellt hat. `actor_iss` ist die `issuer_url` des `auth.issuers`-Eintrags, über den sich der Aufrufer angemeldet hat. Keiner der beiden Claims bedeutet, dass der Aufrufer den Aufruf genehmigt hat. |
## Egress-Gateway
Wie du das Gateway einrichtest, erfährst du unter [Anmeldedaten als Umgebungsvariablen](https://platform.claude.com/docs/de/managed-agents/self-hosted/agent-identity#environment-variable-credentials). Setze die anderen Einstellungen in dieser Tabelle nur mit `egress.gateway_enabled: true`. Ohne diese Einstellung startet der Server nicht, wenn eine von ihnen gesetzt ist.
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ----------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `egress.gateway_enabled`
`CMA_EGRESS__GATEWAY_ENABLED` | `false` | Ob der Server mit dem Egress-Gateway zusammenarbeitet und `environment_variable`-Vault-Anmeldedaten akzeptiert. |
| `egress.allowed_hostnames`
`CMA_EGRESS__ALLOWED_HOSTNAMES` | Keiner | Die exakten öffentlichen Hostnamen, die Sandboxes über das Gateway erreichen können. Ein Eintrag ohne Port, etwa `api.example.com`, erlaubt Port 443 für `https`-URLs und Port 80 für `http`-URLs. Ein Eintrag mit Port, etwa `api.example.com:8443`, erlaubt nur diesen Port. |
| `egress.swap_header_names`
`CMA_EGRESS__SWAP_HEADER_NAMES` | `Authorization` | Die Request-Header, in die das Gateway den Wert von Anmeldedaten einsetzen kann. Eine eigene Liste ersetzt den Standardwert, also nimm `Authorization` darin auf. |
| `egress.gateway_listen`
`CMA_EGRESS__GATEWAY_LISTEN` | `:8410` | Die Adresse des zweiten Listeners des Servers, der nur das Gateway bedient. Der Standard lauscht auf jeder Schnittstelle. |
| `egress.gateway_key_file`
`CMA_EGRESS__GATEWAY_KEY_FILE` | Keiner | Erforderlich. Der Pfad einer Datei mit dem Key, den das Gateway dem Server vorlegt. |
| `egress.ca_cert_file`
`CMA_EGRESS__CA_CERT_FILE` | Keiner | Erforderlich. Der Pfad des PEM-Zertifikats der Zertifizierungsstelle des Gateways. |
| `egress.gateway_proxy_address`
`CMA_EGRESS__GATEWAY_PROXY_ADDRESS` | Keiner | Erforderlich. Der `host:port`, unter dem Sandboxes den Proxy-Port des Gateways erreichen. |
## MCP-Server
Siehe [MCP-Server benötigen einen Allowlist-Eintrag](https://platform.claude.com/docs/de/managed-agents/self-hosted/differences#mcp-servers-need-an-allowlist-entry).
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| --------------------------------------------------------- | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `mcp.allowed_hostnames`
`CMA_MCP__ALLOWED_HOSTNAMES` | Keiner | Die exakten Hostnamen der MCP-Server, mit denen sich der Server verbinden kann. Ohne diese Einstellung verbindet sich der Server mit keinem. |
| `mcp.private_hostnames`
Nur Datei | Keiner | Die Hostnamen aus `mcp.allowed_hostnames`, die zu einer privaten Adresse aufgelöst werden können. |
| `mcp.max_result_bytes`
`CMA_MCP__MAX_RESULT_BYTES` | `102400` (100 KiB) | Die maximale Anzahl an Bytes eines MCP-Tool-Ergebnisses, die das Modell sieht. Das Minimum ist `1024`. |
## Git-Repositories
Siehe [Git-Repositories benötigen einen Allowlist-Eintrag](https://platform.claude.com/docs/de/managed-agents/self-hosted/differences#git-repositories-need-an-allowlist-entry).
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| --------------------------------------------------------------------------- | ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `git.allowed_hostnames`
`CMA_GIT__ALLOWED_HOSTNAMES` | Keiner | Die Git-Hosts, auf denen die Repositories einer Session liegen können. Hostnamen müssen exakt übereinstimmen, ohne Wildcards, und ein Eintrag umfasst nicht seine Subdomains. Ein Eintrag erlaubt Port 443 oder den einen Port, den er benennt, wie in `git.example.com:8443`. Ohne diese Einstellung akzeptiert der Server keine Repositories. |
| `git.private_hostnames`
Nur Datei | Keiner | Die Hostnamen aus `git.allowed_hostnames`, die zu einer privaten Adresse aufgelöst werden, ohne Port geschrieben. Bei jedem anderen Hostnamen verbindet sich der Server nur mit dessen öffentlichen Adressen. |
| `git.allowed_push_refs`
`CMA_GIT__ALLOWED_PUSH_REFS` | Keiner | Die Branches, auf die Agents pushen können, jeweils unter `refs/heads/`. Ein Eintrag, der auf `/` endet, erlaubt jeden Branch darunter. Jeder andere Eintrag erlaubt genau diesen einen Branch. Ohne diese Einstellung können Agents nicht pushen. |
| `git.commit_author_name`
`CMA_GIT__COMMIT_AUTHOR_NAME` | `Claude` | Der Autorenname in den Commits des Agents. Setze ihn zusammen mit `git.commit_author_email`. |
| `git.commit_author_email`
`CMA_GIT__COMMIT_AUTHOR_EMAIL` | `noreply@anthropic.com` | Die Autoren-E-Mail-Adresse in den Commits des Agents. Setze sie zusammen mit `git.commit_author_name`. |
| `git.max_concurrent_transfers`
`CMA_GIT__MAX_CONCURRENT_TRANSFERS` | `32` | Die maximale Anzahl an Git-Anfragen, die ein Server gleichzeitig überträgt. Das Minimum ist `1`. |
| `git.max_session_transfer_bytes`
`CMA_GIT__MAX_SESSION_TRANSFER_BYTES` | `8589934592` (8 GiB) | Die maximale Menge an Git-Traffic in Bytes, die ein Server für eine Session überträgt, Uploads und Downloads zusammen. Die Zählung beginnt jedes Mal bei null, wenn eine Sandbox die Session übernimmt. Am Limit lehnt der Server die nächsten Git-Anfragen der Session mit `403` ab. `0` bedeutet kein Limit. Andernfalls ist das Minimum `1048576`. |
| `git.max_push_bytes`
`CMA_GIT__MAX_PUSH_BYTES` | `2147483648` (2 GiB) | Die maximale Anzahl an Bytes, die ein Push senden kann. Das Minimum ist `1048576`. |
Für Git-Repositories gelten diese Einschränkungen:
* **Protokolle:** Der Server unterstützt weder SSH noch Git LFS und lehnt Weiterleitungen ab, etwa die für ein umbenanntes Repository.
* **Tokens:** Der Git-Host muss das Token als Passwort der HTTP-Basic-Authentifizierung unter dem Benutzernamen `x-access-token` akzeptieren.
* **URLs:** Eine Repository-URL hat genau einen Eigentümer und einen Repository-Namen, daher kannst du kein Repository in einer GitLab-Untergruppe verwenden.
* **Hosts:** Für eine URL auf einem Host, den `git.allowed_hostnames` nicht auflistet, gibt der Server `400` zurück. Die Fehlermeldung besagt, dass die URL auf `github.com` liegen muss, auch wenn du andere Hosts auflistest.
* **Pushes:** Der Server lehnt immer einen Push ab, der einen Branch löscht oder etwas anderes als einen Branch ändert, etwa ein Tag.
## Web-Tools und Skills
Siehe [Web-Tools benötigen eine Server-Einstellung](https://platform.claude.com/docs/de/managed-agents/self-hosted/differences#web-tools-need-a-server-setting).
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ----------------------------------------------------------------------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `web_tools.enabled`
`CMA_WEB_TOOLS__ENABLED` | `false` | Ob Agents die Tools `web_search` und `web_fetch` verwenden können. Wenn du eine andere `web_tools`-Einstellung setzt, ist der Standardwert `true`. |
| `web_tools.allowed_domains`
`CMA_WEB_TOOLS__ALLOWED_DOMAINS` | Keiner | Die einzigen Domains, die Agents über die Web-Tools lesen können. Ein Eintrag umfasst seine Subdomains. |
| `web_tools.blocked_domains`
`CMA_WEB_TOOLS__BLOCKED_DOMAINS` | Keiner | Domains, die kein Agent über die Web-Tools lesen kann. Setze dies oder `web_tools.allowed_domains`, nicht beides. |
| `web_tools.max_content_tokens`
`CMA_WEB_TOOLS__MAX_CONTENT_TOKENS` | Keiner | Die maximale Anzahl an Tokens einer abgerufenen Seite, die `web_fetch` an das Modell zurückgibt. |
| `skills.max_name_chars`
`CMA_SKILLS__MAX_NAME_CHARS` | `64` | Der längste `name`, den eine `SKILL.md`-Datei haben kann. Das Maximum ist `255`. |
| `skills.max_description_chars`
`CMA_SKILLS__MAX_DESCRIPTION_CHARS` | `1024` | Die längste `description`, die eine `SKILL.md`-Datei haben kann. |
## Limits, Timeouts und Scheduling
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `limits.max_active_sessions`
`CMA_LIMITS__MAX_ACTIVE_SESSIONS` | `64` | Nur `store.backend: memory`. Die maximale Anzahl an Sessions, die gleichzeitig einen Turn ausführen. `0` bedeutet kein Limit. |
| `limits.max_live_subagent_threads`
`CMA_LIMITS__MAX_LIVE_SUBAGENT_THREADS` | `25` | Die maximale Anzahl an Subagent-Threads, die eine Session gleichzeitig halten kann. Ein Thread zählt, bis er archiviert oder beendet wird, daher zählt auch ein inaktiver Thread. Am Limit kann der Agent keinen weiteren Subagent starten. Das Minimum ist `1`, und das Maximum ist `4000`. |
| `scheduler.max_concurrent_turns`
`CMA_SCHEDULER__MAX_CONCURRENT_TURNS` | `64` | Nur `store.backend: postgres`. Die maximale Anzahl an Turns, die ein Server gleichzeitig ausführt. Das Minimum ist `1`. Der Server hält zusätzliche Slots ausschließlich für Subagent-Turns vor. Ihre Anzahl beträgt ein Viertel dieses Werts, mindestens aber `4`. Mit dem Standardwert kann ein Server 64 Turns plus 16 Subagent-Turns ausführen. |
| `scheduler.claim_poll_interval`
`CMA_SCHEDULER__CLAIM_POLL_INTERVAL` | `1s` | Nur `store.backend: postgres`. Wie oft ein Server mit einem freien Turn-Slot in der Datenbank nach wartender Arbeit sucht. Das Minimum ist `50ms`. |
| `scheduler.sandbox_claim`
`CMA_SCHEDULER__SANDBOX_CLAIM` | `immediate` | Wann ein Worker die Sandbox einer Session starten kann. `immediate` bedeutet, sobald die Session erstellt wird, sodass der erste Tool-Aufruf am kürzesten wartet. `tool_call` bedeutet beim ersten Tool-Aufruf der Session, der die Sandbox benötigt, sodass eine Session, die keinen solchen Aufruf macht, keine Sandbox verwendet. |
| `limits.model_call_timeout`
`CMA_LIMITS__MODEL_CALL_TIMEOUT` | `20m` | Wie lange ein Modellaufruf einschließlich Wiederholungen laufen kann, bevor der Server ihn abbricht. |
| `limits.stream_idle_timeout`
`CMA_LIMITS__STREAM_IDLE_TIMEOUT` | `5m` | Wie lange die Antwort eines Modellaufrufs nichts liefern kann, bevor der Server diesen Versuch aufgibt. |
| `limits.mcp_call_timeout`
`CMA_LIMITS__MCP_CALL_TIMEOUT` | `4m` | Wie lange ein MCP-Tool-Aufruf laufen kann, bevor der Server ihn aufgibt. |
## Modelle und Compaction
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ------------------------------------ | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `models.settings`
Nur Datei | Keiner | Änderungen am integrierten Modellkatalog des Servers, nach Modell-ID geschlüsselt. Siehe [Modelleinträge](https://platform.claude.com/docs/de/managed-agents/self-hosted/configuration-reference#model-entries). |
| `compaction.triggers`
Nur Datei | Etwa 90 % des „context window“ (Kontextfenster) jedes Modells | Die Kontextgröße in Tokens, bei der ein Turn auf einem Modell seinen Verlauf komprimiert, nach Modell-ID geschlüsselt. Das Minimum ist `50000`. Jedes Modell muss Compaction unterstützen. |
### Modelleinträge
Jeder Eintrag von `models.settings` ändert ein Modell im Katalog oder fügt eines hinzu. Bei einem Modell im Katalog behält ein Feld, das du weglässt, seinen integrierten Wert.
| Feld | Beschreibung |
| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fast_supported` | Ob das Modell `speed: "fast"` akzeptiert. Erforderlich für ein Modell, das du hinzufügst. |
| `inference_geo_supported` | Ob das Modell `inference_geo` akzeptiert. |
| `forced_tool_choice_supported` | Ob das Modell eine Anfrage akzeptiert, die es zwingt, ein bestimmtes Tool aufzurufen. Der Server sendet eine solche Anfrage nur, um einen genehmigten `web_search`- oder `web_fetch`-Aufruf auszuführen. Mit `false` erzwingt er bei diesem Modell nie ein Tool. |
| `effort_supported` | Ob das Modell eine Effort-Stufe akzeptiert. |
| `effort_levels` | Die Effort-Stufen, die das Modell akzeptiert, aus `low`, `medium`, `high`, `xhigh` und `max`. Erforderlich mit `effort_supported: true` bei einem Modell ohne integrierte Stufen. |
| `effort_default` | Die Effort-Stufe einer Session, deren Agent keine benennt. Sie muss eine der `effort_levels` sein. Erforderlich mit `effort_supported: true` bei einem Modell ohne integrierten Standardwert. |
| `thinking` | Der Nachdenken-Modus, den der Server anfordert, `enabled` oder `adaptive`. |
| `thinking_budget` | Das Nachdenken-Budget in Tokens, das der Server mit `thinking: enabled` sendet. |
| `max_tokens` | Der `max_tokens`-Wert jedes Modellaufrufs. |
## Console auf deinem Server
| Einstellung
Umgebungsvariable | Standardwert | Beschreibung |
| ----------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| `console.serve`
`CMA_CONSOLE__SERVE` | `true` | Ob die [Console auf deinem Server](https://platform.claude.com/docs/de/managed-agents/self-hosted/console) bereitgestellt werden. |