> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokios.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Tokios exposes private local models through https://api.tokios.com using an outbound-only connector tunnel.
> Use 'connector' for the local tokios-connector process.
> Use 'deployment' for the public model name in the API model field.
> Use 'upstream model id' for the model served by Ollama, llama.cpp, vLLM, LM Studio, or another local backend.
> API keys use the prefix sk-tok-. Connector tokens use the prefix ct-tok-.

# Tokios von einem Coding-Agenten einrichten lassen

> Übergeben Sie Claude Code, Codex oder einem beliebigen Coding-Agenten einen Automation-Token und diese Seite. Der Agent führt das Pairing des Connectors durch, veröffentlicht Ihr Modell, erstellt einen API-Schlüssel und überprüft den Pfad unbeaufsichtigt.

Diese Seite hat 2 Leser. Der erste Abschnitt richtet sich an Sie. Alles ab [Anweisungen für den Agenten](#instructions-for-the-agent) ist für den Agenten geschrieben, damit er es liest und ausführt.

> [!NOTE]
>
> **Wenn Sie ein Agent sind:** Rufen Sie das Raw-Markdown dieser Seite mit Ihrer Shell ab, nicht mit einem Browser-Tool, damit Befehle und JSON-Strukturen unverändert bei Ihnen ankommen:
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> curl -fsSL https://docs.tokios.com/guides/agent-setup.md
> ```
>
> Folgen Sie dann den [Anweisungen für den Agenten](#instructions-for-the-agent). Jede Seite auf dieser Site ist als Markdown verfügbar, indem Sie `.md` an die URL anhängen, und die gesamte Site steht in `https://docs.tokios.com/llms-full.txt`.

## Bevor Sie beginnen

**1. Automation-Token erstellen**

Öffnen Sie in der Konsole **[Settings](https://tokios.com/console/settings)**, dann **Automation tokens**, dann **Create token**. Verwenden Sie die Voreinstellung **Setup** und eine Gültigkeit von **1 hour**. Kopieren Sie den Token einmal. Siehe [Automation-Tokens](/de/setup/automation-tokens.md).

**2. Führen Sie den Agenten auf dem Rechner aus, der Ihr Modell bereitstellt**

Der Agent muss den Connector-Installationsbefehl auf diesem Rechner ausführen. Stellen Sie sicher, dass Ollama, LM Studio, llama.cpp oder vLLM dort bereits auf dem Standardport läuft.

**3. Legen Sie den Token in einer Shell-Variablen ab**

Setzen Sie die Variable und starten Sie den Agenten aus derselben Shell, damit das Geheimnis niemals in die Konversation gelangt.

**Windows PowerShell**

```powershell theme={"theme":{"light":"github-light","dark":"css-variables"}}
$env:TOKIOS_CONSOLE="https://tokios.com"
$env:TOKIOS_TOKEN="at-tok-YOUR_TOKEN"
claude
```

**Windows CMD**

```cmd theme={"theme":{"light":"github-light","dark":"css-variables"}}
set TOKIOS_CONSOLE=https://tokios.com
set TOKIOS_TOKEN=at-tok-YOUR_TOKEN
claude
```

**macOS & Linux**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
export TOKIOS_CONSOLE=https://tokios.com
export TOKIOS_TOKEN=at-tok-YOUR_TOKEN
claude
```

**4. Senden Sie dem Agenten 1 Nachricht**

```text theme={"theme":{"light":"github-light","dark":"css-variables"}}
Read https://docs.tokios.com/guides/agent-setup and follow it. The console base URL is in the TOKIOS_CONSOLE variable and the automation token is in TOKIOS_TOKEN. Never print the token. My model server is Ollama on this machine. When you are done, give me the final report described on that page.
```

Ersetzen Sie `Ollama` durch Ihr Backend. Für Codex funktioniert dieselbe Nachricht. Fügen Sie „Make the connector start at boot.“ hinzu, wenn der Agent einen Dienst installieren soll; andernfalls weist er Sie nur darauf hin, dass der Connector einen Neustart nicht überlebt.

Während der Agent läuft, beobachten Sie den Tab **Connectors**: Ein ausstehendes Gerät erscheint und wird dann mit den angekündigten Modellen aktiv. Zeilen, die der Agent erstellt, tragen ein Badge **via token**. Wenn der Agent berichtet, widerrufen Sie den Token in **Settings**.

> [!NOTE]
>
> Coding-Agenten verweigern das Piping eines heruntergeladenen Skripts in eine Shell, daher verwendet der Agent nicht den Einzeiler für die Installation. Er lädt das Connector-Binary über das Gateway herunter, überprüft die Prüfsumme und startet es selbst. Wenn Ihr Agent stehen bleibt und nach einem blockierten Installer-Befehl fragt, verweisen Sie ihn auf diese Seite zurück.

## Anweisungen für den Agenten

Sie richten einen Tokios-Workspace ohne Aufsicht ein: Paaren Sie den Connector auf diesem Rechner, veröffentlichen Sie das lokale Modell, erstellen Sie einen API-Schlüssel für Coding-Clients und überprüfen Sie den gesamten Pfad. Sie agieren über die Management-API des Workspace mit 1 Credential, einem Automation-Token.

### Was Sie haben

* `TOKIOS_CONSOLE`: die Basis-URL der Konsole, normalerweise `https://tokios.com`. Jeder Aufruf unten ist `TOKIOS_CONSOLE` + `/account/...`.
* `TOKIOS_TOKEN`: das Automation-Token, `at-tok-…`. Senden Sie es als `Authorization: Bearer <token>` bei jedem Aufruf. Es hat die Setup-Scopes und läuft bald ab.
* Ein Modellserver, der bereits auf diesem Rechner auf Loopback läuft: Ollama auf Port 11434, LM Studio auf 1234, llama.cpp auf 8080 oder vLLM auf 8000. Der Connector erkennt diese automatisch.

### Regeln

1. **Geben Sie den Token niemals aus, protokollieren Sie ihn nicht und schreiben Sie ihn nirgendwohin** außer in den `Authorization`-Header. Lesen Sie ihn jedes Mal aus der Shell-Variablen: `$TOKIOS_TOKEN` in Bash, `$env:TOKIOS_TOKEN` in PowerShell, `%TOKIOS_TOKEN%` in CMD. Der API-Schlüssel, den Sie in Schritt 5 erstellen, ist etwas anderes: Übergeben Sie diesen dem Menschen in Ihrem Abschlussbericht.
2. Der Token funktioniert nur auf `TOKIOS_CONSOLE/account/*`. Versuchen Sie nicht `/admin`, `/auth`, `/v1` oder `/portal` damit.
3. **Erst auflisten, dann erstellen.** Verwenden Sie einen ausstehenden Connector mit demselben Namen und ein Deployment mit demselben öffentlichen Namen wieder. Erstellen Sie niemals einen zweiten API-Schlüssel, weil ein Retry fehlgeschlagen ist. Erstellungen sind einfache POSTs und nicht idempotent.
4. Fehler sind JSON: `{"error":{"message":"…","type":"…","scope":"…"}}`.
   * `401`: Der Token ist ungültig, abgelaufen oder widerrufen. Stoppen Sie und berichten Sie.
   * `403` mit `scope`: Dem Token fehlt dieser Scope. Stoppen Sie und berichten Sie, welcher Scope fehlt.
   * `403` „only available from the console“: Die Aktion ist einem angemeldeten Menschen vorbehalten. Umgehen Sie das nicht.
   * `409` bei Approve: Lesen Sie die Connector-Zeile erneut und versuchen Sie es wie in Schritt 3 beschrieben.
   * `429`: Warten Sie 60 Sekunden und versuchen Sie es erneut.
5. Ändern Sie keine Passwörter, legen Sie keine Schlüssel offen und teilen Sie keine, rühren Sie das Request-Logging nicht an und erstellen Sie keine anderen Tokens. Sie können es nicht, und Sie dürfen es nicht versuchen.
6. Berichten Sie das Ergebnis jedes Schritts. Wenn ein Schritt fehlschlägt oder übersprungen wird, sagen Sie es klar.

Die Beispiele verwenden Bash. In Windows CMD setzen Sie die URL und das JSON in doppelte Anführungszeichen und escapen die inneren Anführungszeichen, zum Beispiel `-d "{\"name\":\"gpu-box\"}"`.

### Schritt 1: Pairing starten

Listen Sie zuerst die bestehenden Connectors auf:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s "$TOKIOS_CONSOLE/account/connectors" -H "Authorization: Bearer $TOKIOS_TOKEN"
```

Wenn eine Zeile mit dem vorgesehenen Namen bereits `"status":"pending_pair"` hat, verwenden Sie sie mit einem frischen Pairing-Code wieder:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s -X POST "$TOKIOS_CONSOLE/account/connectors/CONNECTOR_ID/claim-code" -H "Authorization: Bearer $TOKIOS_TOKEN"
```

Andernfalls erstellen Sie einen:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s -X POST "$TOKIOS_CONSOLE/account/connectors" \
  -H "Authorization: Bearer $TOKIOS_TOKEN" -H "Content-Type: application/json" \
  -d '{"name":"gpu-box"}'
```

Beide geben zurück:

```json theme={"theme":{"light":"github-light","dark":"css-variables"}}
{
  "connector_id": "con_…",
  "claim_code": "TKS-XXXX-XXXX",
  "claim_code_expires_at": "2026-…",
  "server_url": "wss://…/connector/connect",
  "install_oneliner": {
    "macos": "curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --code TKS-XXXX-XXXX",
    "linux": "curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX",
    "windows": "irm https://tokios.com/downloads/install/windows | iex; tokios-install -Code 'TKS-XXXX-XXXX'"
  }
}
```

Der Pairing-Code ist 15 Minuten gültig. Behalten Sie `claim_code` und `server_url`; ignorieren Sie `install_oneliner` (es leitet ein Skript per Pipe an eine Shell weiter, was Sie nicht tun dürfen — siehe Schritt 2). Es gibt keinen Connector-Token in dieser Antwort, und es wird ihn nie geben: Der Connector erhält sein eigenes Credential über den Tunnel nach der Genehmigung.

### Schritt 2: Connector auf diesem Rechner installieren und starten, losgelöst

Die Sicherheitsregeln des Agenten verweigern das Piping eines heruntergeladenen Skripts in eine Shell (`curl … | sh`, `irm … | iex`), und das Speichern des Skripts und dessen Ausführung ist dasselbe in Verkleidung. Tun Sie keines von beidem, und bitten Sie den Menschen nicht, es zu genehmigen.
Verwenden Sie Pfad A. Er führt kein heruntergeladenes Skript aus: Sie laden das Connector-Binary selbst über das Gateway-Redirect herunter, überprüfen es gegen die `SHA256SUMS` des Releases und starten es im Hintergrund mit dem Pairing-Code und `server_url` aus Schritt 1.

**Pfad A (verwenden Sie diesen): Binary herunterladen, überprüfen, ausführen.**

Wählen Sie das Asset für diesen Rechner: `linux/x64` → `tokios-connector-linux-x64`, `linux/arm64` →
`tokios-connector-linux-arm64`, `macos/arm64` → `tokios-connector-osx-arm64`, `windows/x64` →
`tokios-connector-win-x64.exe`, `windows/arm64` → `tokios-connector-win-arm64.exe`.

Linux und macOS (gezeigt für `linux/x64`; auf macOS verwenden Sie `shasum -a 256` statt `sha256sum`):

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
mkdir -p ~/.tokios/connector && cd ~/.tokios/connector
curl -fsSL -o tokios-connector "$TOKIOS_CONSOLE/downloads/connector/linux/x64"
curl -fsSL -o SHA256SUMS https://github.com/tokiosAI/tokios-connector/releases/latest/download/SHA256SUMS
expected=$(grep -E '\*?tokios-connector-linux-x64$' SHA256SUMS | awk '{print $1}')
actual=$(sha256sum tokios-connector | awk '{print $1}')
[ -n "$expected" ] && [ "$expected" = "$actual" ] || { echo "checksum mismatch"; exit 1; }
chmod +x tokios-connector
nohup ./tokios-connector TKS-XXXX-XXXX --Connector:ServerUrl "SERVER_URL" > tokios-connector-stdout.log 2>&1 < /dev/null &
echo $! > tokios-connector.pid
```

Windows in PowerShell (gezeigt für `windows/x64`):

```powershell theme={"theme":{"light":"github-light","dark":"css-variables"}}
$dir = Join-Path $env:LOCALAPPDATA 'Tokios\connector'
New-Item -ItemType Directory -Force -Path $dir | Out-Null
Set-Location $dir
Invoke-WebRequest "$env:TOKIOS_CONSOLE/downloads/connector/windows/x64" -OutFile tokios-connector.exe
Invoke-WebRequest https://github.com/tokiosAI/tokios-connector/releases/latest/download/SHA256SUMS -OutFile SHA256SUMS
$expected = (((Get-Content SHA256SUMS) -match 'tokios-connector-win-x64\.exe$') -split '\s+')[0].ToLower()
$actual = (Get-FileHash tokios-connector.exe -Algorithm SHA256).Hash.ToLower()
if (-not $expected -or $expected -ne $actual) { throw "checksum mismatch" }
$p = Start-Process -FilePath .\tokios-connector.exe -ArgumentList 'TKS-XXXX-XXXX','--Connector:ServerUrl','SERVER_URL' -WorkingDirectory $dir -WindowStyle Hidden -RedirectStandardOutput tokios-connector-stdout.log -RedirectStandardError tokios-connector-stderr.log -PassThru
Set-Content tokios-connector.pid $p.Id
```

Ersetzen Sie `TKS-XXXX-XXXX` durch `claim_code` und `SERVER_URL` durch `server_url` aus Schritt 1. Der Connector baut eine ausgehende Verbindung auf, legt den Code vor, wartet auf die Genehmigung und schreibt dann seine eigene Konfiguration neben das Binary. Wenn auf dem Rechner bereits `tokios-connector` installiert ist, überspringen Sie den Download und starten Sie das bestehende Binary auf dieselbe Weise.

**Pfad B (nur wenn der Mensch den Installer verlangt):** Der Installer führt dieselben Download- und Prüfsummenschritte aus und fügt das Flag `--detach` hinzu. Er ist dafür gedacht, dass ein Mensch ihn einfügt. Wenn Sie aufgefordert werden, ihn zu verwenden, laden Sie ihn in eine Datei herunter und lesen Sie ihn, bevor Sie die gespeicherte Datei ausführen, und sagen Sie das in Ihrem Bericht. Leiten Sie ihn niemals per Pipe weiter.

Die Ausgabe des Connectors steht in `tokios-connector-stdout.log` und seine PID in `tokios-connector.pid`, im oben genannten Verzeichnis. Stoppen Sie ihn später mit `kill $(cat tokios-connector.pid)` oder `Stop-Process -Id (Get-Content tokios-connector.pid)`.

**Persistenz.** Ein losgelöster Prozess überlebt keinen Neustart. Installieren Sie keinen Dienst, es sei denn, die Nachricht des Menschen hat Sie aufgefordert, den Connector beim Booten zu starten; andernfalls sagen Sie das in Ihrem Abschlussbericht und bieten Sie es an. Wenn Sie dazu aufgefordert wurden: Schließen Sie zuerst die Schritte 3 bis 6 ab, dann stoppen Sie den losgelösten Prozess (`kill $(cat tokios-connector.pid)`; der Connector erlaubt 1 Instanz pro Verzeichnis) und folgen Sie [Den Connector beim Booten starten](/de/setup/connector-install.md#run-the-connector-at-boot) für diese Plattform. Unter Linux ist das eine systemd-User-Unit, deren `ExecStart`
`%h/.tokios/connector/tokios-connector --config %h/.tokios/connector/tokios-connector.json` ist, aktiviert mit
`systemctl --user enable --now tokios-connector`, plus `loginctl enable-linger "$USER"`, damit sie ohne Anmeldung startet.
Das Pairing steht in `tokios-connector.json`, sodass der Dienst sich ohne neuen Pairing-Code wiederverbindet.

### Schritt 3: Auf das Gerät warten, dann genehmigen

Fragen Sie alle 3 Sekunden für bis zu 2 Minuten ab:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s "$TOKIOS_CONSOLE/account/connectors" -H "Authorization: Bearer $TOKIOS_TOKEN"
```

Finden Sie Ihre `connector_id`. Wenn die Zeile `"claimPending": true` zeigt, trägt sie auch `"sessionId": "sess_…"` und `"machineName"`. Überprüfen Sie, dass der Maschinenname diesem Rechner entspricht, und genehmigen Sie dann mit genau dieser Session-ID:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s -X POST "$TOKIOS_CONSOLE/account/connectors/CONNECTOR_ID/approve" \
  -H "Authorization: Bearer $TOKIOS_TOKEN" -H "Content-Type: application/json" \
  -d '{"session_id":"sess_…"}'
```

Erfolg ist `{"status":"approved"}`.

Bei `409` hat sich das Gerät mit einer neuen Session-ID erneut verbunden, ist noch nicht verbunden, oder der Pairing-Code ist abgelaufen. Lesen Sie die Zeile erneut. Wenn der Code abgelaufen ist, fordern Sie einen neuen an wie in Schritt 1 und starten Sie den Connector damit neu. Andernfalls genehmigen Sie erneut mit der aktuellen `sessionId`.

Fragen Sie weiter ab, bis die Zeile `"status":"active"`, `"online":true` und ein nicht-leeres `"announcedModels"` zeigt. Lassen Sie bis zu 60 Sekunden zu: Der Connector erkennt lokale Modelle nach der Genehmigung. Wenn `announcedModels` leer bleibt, läuft kein Modellserver auf einem erkannten Loopback-Port. Berichten Sie das und stoppen Sie.

### Schritt 4: Modell veröffentlichen

Überprüfen Sie die Workspace-Richtlinie:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s "$TOKIOS_CONSOLE/account/auto-publish" -H "Authorization: Bearer $TOKIOS_TOKEN"
```

* Wenn es `{"auto_publish": true}` zurückgibt, wird jedes angekündigte Modell automatisch veröffentlicht. Fragen Sie `GET $TOKIOS_CONSOLE/account/models` ab, bis die angekündigten Namen als `id`-Werte erscheinen.

  Seien Sie präzise, was das bedeutet, wenn Sie es berichten. „Veröffentlicht“ bedeutet, dass das Modell ein Deployment in diesem Workspace hat: Es ist über den API-Host für jeden aufrufbar, der einen API-Schlüssel dieses Workspace besitzt, dessen Modell-Scope es abdeckt, und für niemanden sonst. Ohne Schlüssel ist nichts erreichbar. Es geschieht in dem Moment, in dem der Connector seine Modelle nach der Genehmigung ankündigt, einige Sekunden danach, und der öffentliche Name ist die Upstream-Modell-ID (zum Beispiel `gemma4:e4b`). Auto-publish veröffentlicht auch ein Modell erneut, das Sie gelöscht haben, wenn der Connector es wieder ankündigt. Wenn der Mensch daher nur einige der erkannten Modelle verfügbar machen möchte, pausieren Sie die anderen mit `POST $TOKIOS_CONSOLE/account/deployments/DEPLOYMENT_ID/disable` und erwähnen Sie, dass Auto-publish eingeschaltet ist. Ein pausiertes Modell bleibt pausiert. Löschen Sie sie nicht: Das Löschen erfordert den Scope `models:reroute`, den das Preset Setup nicht enthält, und Auto-publish würde ein gelöschtes Modell erneut veröffentlichen.
* Wenn es `false` zurückgibt, listen Sie zuerst `GET $TOKIOS_CONSOLE/account/deployments` auf und erstellen Sie dann 1 Deployment pro Modell, das aufrufbar sein soll:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s -X POST "$TOKIOS_CONSOLE/account/deployments" \
  -H "Authorization: Bearer $TOKIOS_TOKEN" -H "Content-Type: application/json" \
  -d '{"public_name":"gemma4:e4b","upstream_model":"gemma4:e4b","connector_id":"con_…"}'
```

`public_name` ist, was Clients im `model`-Feld senden. `upstream_model` muss 1 der `announcedModels` sein. Ein `409` bedeutet, dass der Name bereits existiert; lassen Sie ihn wie er ist.

### Schritt 5: API-Schlüssel erstellen

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s -X POST "$TOKIOS_CONSOLE/account/keys" \
  -H "Authorization: Bearer $TOKIOS_TOKEN" -H "Content-Type: application/json" \
  -d '{"display_name":"laptop 2026-10-16","model_patterns":["gemma4:e4b"]}'
```

Antwort: `{"id":"key_…","secret":"sk-tok-…","retrievable":true}`. Das `secret` wird einmal angezeigt. Behalten Sie es für den Bericht. Beschränken Sie `model_patterns` auf die Modelle, die Sie veröffentlicht haben; lassen Sie es nur weg, wenn der Mensch alle Modelle wollte.

### Schritt 6: Überprüfen

Führen Sie den Health-Check aus, einen 1-Token-Ping über den Tunnel:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s -X POST "$TOKIOS_CONSOLE/account/models/healthcheck" \
  -H "Authorization: Bearer $TOKIOS_TOKEN" -H "Content-Type: application/json" \
  -d '{"model":"gemma4:e4b"}'
```

Erwarten Sie `"status":"ok"` mit einer `latency_ms`. Dann machen Sie 1 echten Aufruf mit dem **API-Schlüssel**, nicht mit dem Token. Die Client-Basis-URL ist `https://api.tokios.com`; bestätigen Sie sie mit `GET $TOKIOS_CONSOLE/account/connection`, das `base_url` zurückgibt.

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -s -X POST "https://api.tokios.com/v1/chat/completions" \
  -H "Authorization: Bearer sk-tok-…" -H "Content-Type: application/json" \
  -d '{"model":"gemma4:e4b","messages":[{"role":"user","content":"Say hello in five words."}],"max_tokens":32}'
```

### Schritt 7: Abschlussbericht

Geben Sie dem Menschen:

* Connector: Name, ID, Status, Maschinenname.
* Veröffentlichte Modelle: die öffentlichen Namen und ob Auto-publish sie erstellt hat oder Sie. Erinnern Sie den Menschen daran, dass diese von Inhabern der API-Schlüssel des Workspace aufrufbar sind, nicht von der Öffentlichkeit.
* Ob der Connector einen Neustart überlebt: „Nein, er läuft losgelöst“, es sei denn, Sie haben einen Dienst installiert, in welchem Fall Sie sagen, welchen.
* API-Schlüssel: seine ID **und das `sk-tok-`-Secret**. Dies ist das 1 Geheimnis, das Sie übergeben sollen.
* Client-Konfiguration, von `GET $TOKIOS_CONSOLE/account/connection`:
  * Claude Code: `ANTHROPIC_BASE_URL=<base_url>`, `ANTHROPIC_API_KEY=<sk-tok-…>`, und der Modellname, der mit `--model` übergeben wird.
  * Codex: `OPENAI_BASE_URL=<base_url>/v1`, `wire_api=responses`, `disable_response_storage=true`.
* Das Überprüfungsergebnis: den Health-Check-Status und die Chat-Antwort.
* Alles, was Sie übersprungen oder nicht tun konnten, und warum.

> **[Automation-Tokens](/de/setup/automation-tokens.md)**
>
> Scopes, Voreinstellungen, Gültigkeit und wie man einen Token widerruft oder regeneriert.

> **[Claude Code](/de/guides/claude-code.md)**
>
> Richten Sie Claude Code auf den Schlüssel und das Modell aus, das der Agent gerade erstellt hat.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.