Zurück zu den Updates
New releaseJul 28, 2026

ironclaw ironclaw-v1.0.0

Sicheres, privates KI-Agenten-Betriebssystem mit lokalem verschlüsseltem Speicher, OAuth/SSO-Authentifizierung, richtlinienbasierter Zugriffskontrolle und einem erweiterbaren Tool-Building-Framework für persönliche und Produktionsbereitstellungen.

Teilen

IronClaw

IronClaw

Ihr sicherer persönlicher KI-Assistent, immer an Ihrer Seite

License: MIT OR Apache-2.0 Telegram: @ironclawAI Reddit: r/ironclawAI gitcgr

English | 简体中文 | Русский | 日本語 | 한국어

Reborn-SchnellstartPhilosophieFunktionenInstallationKonfigurationSicherheitArchitektur


IronClaw Reborn Schnellstart

IronClaw Reborn ist die eigenständige Laufzeit auf dem Branch reborn-integration. Es verwendet das separate ironclaw-reborn-Binary aus dem Paket ironclaw_reborn_cli und ein separates Reborn-Zustandsverzeichnis. Es verwendet nicht das alte ironclaw-Zustandsverzeichnis als Konfigurationsstammverzeichnis.

Für das ältere ironclaw-Binary siehe Installation und Legacy IronClaw Verwendung.

Binary erstellen oder ausführen

Vom Repository-Stammverzeichnis aus:```bash cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- --help

Oder baue es zuerst:```bash
cargo build -p ironclaw_reborn_cli --bin ironclaw-reborn
./target/debug/ironclaw-reborn --help

Das standardmäßige Reborn-Verzeichnis ist $HOME/.ironclaw/reborn. Überschreiben Sie es mit einem absoluten Pfad, wenn Sie einen isolierten Zustand wünschen:```bash export IRONCLAW_REBORN_HOME="$PWD/.reborn-home" cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- config path

`config path` und `doctor` sind sichere Diagnosebefehle; sie geben das ermittelte Home, Profil, `config.toml`, `providers.json` und `v1_state: not-used` aus.
Sie erstellen keinen Reborn-Status und keine Seed-Konfigurationsdateien.

### Modellroute konfigurieren

Der CLI-native Weg, um Reborns Standard-Modellroute zu konfigurieren, ist:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- models set-provider openai --model gpt-5-mini

Das schreibt $IRONCLAW_REBORN_HOME/config.toml mit [llm.default] und dem Namen der Umgebungsvariable für die Anmeldeinformationen des Anbieters. Überprüfen Sie es mit:```bash cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- models status cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- models list openai

Für OpenAI setzen Sie den geheimen Wert in der Umgebungsvariable, bevor Sie starten:```bash
export OPENAI_API_KEY="sk-..."
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- run --message "hello"

Lassen Sie --message weg oder verwenden Sie repl für eine interaktive stdin-Sitzung:```bash cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- repl

### `config.toml` Form

`config init` erstellt bearbeitbare Startdateien:```bash
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- config init

Es schreibt:

  • $IRONCLAW_REBORN_HOME/config.toml
  • $IRONCLAW_REBORN_HOME/providers.json

Eine minimal konfigurierte Modellroute sieht wie folgt aus:```toml [llm.default] provider_id = "openai" model = "gpt-5-mini" api_key_env = "OPENAI_API_KEY"

`config.toml` kann auch optionale Abschnitte wie `[boot]`,
`[identity]`, `[runner]` und `[skills]` enthalten; `config init` schreibt kommentierte
Anleitungen für die unterstützten Felder.

Fehlt `config.toml`, erstellt der erste zustandsbehaftete Laufzeitstart mittels `run`,
`repl` oder `serve` eine dünnbesetzte Datei mit `api_version` und dem sicheren
`local-dev` Boot-Profil. Schreibgeschützte Befehle und `run --dry-run` bleiben
nebenwirkungsfrei. Einmalige Umgebungsauswahlen wie
`IRONCLAW_REBORN_PROFILE=local-dev-yolo` werden nicht in die erstellte Datei übernommen.

Wichtig: `api_key_env` ist der Name einer Umgebungsvariablen, nicht das Geheimnis
selbst. Reborn lehnt Inline-Geheimniswerte in `config.toml` und
`providers.json` ab.

Der Produktionsspeicher verwendet das gleiche reine-Umgebungsvariablen-Muster. Eine Produktions-Reborn-Konfiguration
kann die PostgreSQL-URL-Variable benennen, darf aber die rohe URL nicht enthalten:```toml
[storage]
backend = "postgres"
url_env = "IRONCLAW_REBORN_POSTGRES_URL"
secret_master_key_env = "IRONCLAW_REBORN_SECRET_MASTER_KEY"
# Optional; defaults to 2. Keep below the PostgreSQL server or managed
# session-pool cap after reserving capacity for restarts and operator sessions.
pool_max_size = 2

[policy]
deployment_mode = "hosted_multi_tenant"
default_profile = "secure_default"

Setzen Sie IRONCLAW_REBORN_POSTGRES_URL in der Prozessumgebung und setzen Sie IRONCLAW_REBORN_SECRET_MASTER_KEY auf unabhängiges kryptografisches Schlüsselmaterial. Verwaltete entfernte PostgreSQL-Anbieter müssen TLS verwenden, beispielsweise durch Anhängen von sslmode=require. Der Produktions-run erfordert auch einen expliziten [policy]-Abschnitt. Der erste Produktionsstart-Slice unterstützt Laufzeitrichtlinien, die keine Tenant-Sandbox-Prozessbindung erfordern.

Sobald [llm.default] existiert, wählt diese Konfiguration den Anbieter aus. LLM_BACKEND ist nur ein Umgebungs-Fallback, wenn kein standardmäßiger LLM-Slot konfiguriert ist. Um nach dem Schreiben der Konfiguration den Anbieter zu wechseln, verwenden Sie models set-provider <provider> oder bearbeiten Sie [llm.default].provider_id.

Nur-Umgebungs-Modellauswahl

Wenn $IRONCLAW_REBORN_HOME/config.toml fehlt oder kein [llm.default] enthält, kann Reborn das LLM aus Umgebungsvariablen auflösen. Eine spärliche, beim ersten Start bereitgestellte Konfiguration enthält kein [llm.default], sodass die Nur-Umgebungs-Modellauswahl weiterhin funktioniert:```bash export IRONCLAW_REBORN_HOME="$PWD/.reborn-env-only" export LLM_BACKEND=openai export OPENAI_API_KEY="sk-..." cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- run --message "hello"

Gemeinsame Anbieter-Umgebungsvariablen:

| Anbieter | Selektor | Erforderliche Umgebungsvariable |
| --- | --- | --- |
| OpenAI | `LLM_BACKEND=openai` | `OPENAI_API_KEY`; optional `OPENAI_MODEL`, `OPENAI_BASE_URL` |
| Anthropic | `LLM_BACKEND=anthropic` | `ANTHROPIC_API_KEY`; optional `ANTHROPIC_MODEL`, `ANTHROPIC_BASE_URL` |
| OpenAI-kompatibel | `LLM_BACKEND=openai_compatible` | `LLM_BASE_URL`; optional `LLM_API_KEY`, `LLM_MODEL` |
| OpenRouter | `LLM_BACKEND=openrouter` | `OPENROUTER_API_KEY`; optional `OPENROUTER_MODEL` |
| Ollama | `LLM_BACKEND=ollama` | kein Schlüssel; optional `OLLAMA_BASE_URL`, `OLLAMA_MODEL` |
| Codex-Auth | `LLM_BACKEND=openai_codex` | `LLM_USE_CODEX_AUTH=true` oder `CODEX_AUTH_PATH`; optional `OPENAI_CODEX_MODEL` |

Verwende `models list <anbieter>`, um die genauen in den aktuellen Branch kompilierten Anbieter-Metadaten zu sehen.

### Startvariablen

| Variable | Zweck |
| --- | --- |
| `IRONCLAW_REBORN_HOME` | Absolutes Reborn-Status-Wurzelverzeichnis. Standardmäßig `$HOME/.ironclaw/reborn`. Der Resolver lehnt unsichere Pfade und v1-Status-Wurzel-Aliase wie `$HOME/.ironclaw` ab. |
| `IRONCLAW_REBORN_PROFILE` | Boot-Profil-Auswahl. Unterstützte Werte: `local-dev`, `local-dev-yolo`, `hosted-single-tenant`, `hosted-single-tenant-volume`, `production`, `migration-dry-run`. |
| `IRONCLAW_REBORN_POSTGRES_URL` | Produktive PostgreSQL-Speicher-URL, wenn `[storage].backend = "postgres"` und `[storage].url_env` diese Variable benennt. Halte sie aus `config.toml` heraus; entfernte Anbieter müssen TLS verwenden. |
| `IRONCLAW_REBORN_POSTGRES_POOL_MAX_SIZE` | Optionale Überschreibung der PostgreSQL-Client-Pool-Größe für Reborn. Verwende dies, wenn ein verwalteter Anbieter eine kleine Sitzungspool-Obergrenze erzwingt. |
| `IRONCLAW_FILESYSTEM_POSTGRES_MIGRATION_CONNECT_MAX_WAIT_SECS` | Optionales Wartezeitfenster beim Start für Wiederholungsversuche der Postgres-Dateisystem-Migrationsverbindung. Standardmäßig 300 Sekunden. |
| `IRONCLAW_REBORN_SECRET_MASTER_KEY` | Produktiver Reborn-Geheim-Hauptschlüssel, wenn `[storage].secret_master_key_env` diese Variable benennt. Halte ihn unabhängig von der Datenbank-URL und außerhalb von `config.toml`. |
| `IRONCLAW_REBORN_LOG` | Tracing-Filter für die Reborn-Binärdatei, zum Beispiel `debug,ironclaw_runner=trace`. |

`run` und `repl` unterstützen derzeit lokale Laufzeit-Komposition über `local-dev`, `local-dev-yolo` und `hosted-single-tenant-volume`.  
`hosted-single-tenant-volume` verwendet das lokale libSQL-Substrat unter `$IRONCLAW_REBORN_HOME/hosted-single-tenant-volume`, löst die gehostete sichere Standard-Laufzeitrichtlinie auf und deaktiviert prozessgestützte Werkzeuge wie Shell. Es ist für Preview-Bereitstellungen mit einem einzelnen Mandanten auf einem persistenten Volume gedacht, nicht als vollständige PostgreSQL-Produktionskomposition.

`local-dev-yolo` gewährt vertrauenswürdigen Laptop-Host-Zugriff und muss explizit bestätigt werden:```bash
export IRONCLAW_REBORN_PROFILE=local-dev-yolo
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- repl --confirm-host-access

WebUI-Dienst

Der Reborn WebUI wird mit dem Cargo-Feature webui-v2-beta kompiliert. Builds mit diesem Feature erfordern Node.js 22 mit Corepack/pnpm, damit Cargo das SPA-Bundle generieren und einbetten kann. Erstellen oder führen Sie die Binärdatei mit diesem Feature aus, um den Befehl serve zu aktivieren:```bash cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve --help cargo build -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn

Der WebUI-Listener hört standardmäßig auf `127.0.0.1:3000`. Der Dienst benötigt beim Start einen env-bearer Token und eine Benutzer-ID. Er benötigt außerdem die Modell-Route aus dem vorherigen Abschnitt, einschließlich der Credential-Umgebungsvariable dieses Anbieters:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider
export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)"
export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli"

cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve

Äquivalente config.toml-Listener-Konfiguration:```toml [webui] listen_host = "127.0.0.1" listen_port = 3000 env_token_var = "IRONCLAW_REBORN_WEBUI_TOKEN" env_user_id_var = "IRONCLAW_REBORN_WEBUI_USER_ID" allowed_origins = ["http://127.0.0.1:3000", "http://localhost:3000"] canonical_host = "127.0.0.1:3000"

`env_token_var` und `env_user_id_var` sind Umgebungsvariablen-Namen. Bewahren Sie das eigentliche Token und die Benutzer-ID in der Umgebung.

Erforderliche WebUI-Umgebungsvariablen:

| Variable | Zweck |
| --- | --- |
| `IRONCLAW_REBORN_WEBUI_TOKEN` | Bearer-Token für WebUI-Anfragen. Wenn SSO aktiviert ist, signiert dies auch Sitzungen und muss mindestens 32 Bytes lang sein. |
| `IRONCLAW_REBORN_WEBUI_USER_ID` | Reborn-Besitzer-/Benutzer-ID für Env-Bearer-Anfragen. Wenn `[identity].default_owner` konfiguriert ist, muss es mit diesem Wert übereinstimmen. |

Optionale WebUI-OAuth-Umgebungsvariablen:

| Variable | Zweck |
| --- | --- |
| `IRONCLAW_REBORN_WEBUI_BASE_URL` | Öffentliche Basis-URL, die für WebUI-Login und Produkt-Auth-OAuth-Callbacks verwendet wird. Nicht-Loopback-Bereitstellungen müssen `https://` verwenden. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_ID` | Aktiviert Google SSO, wenn gesetzt. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_SECRET` | Erforderlich, wenn Google SSO aktiviert ist. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_ALLOWED_HD` | Optionale Google-gehostete-Domain-Einschränkung. |
| `IRONCLAW_REBORN_WEBUI_GITHUB_CLIENT_ID` | Aktiviert GitHub SSO, wenn gesetzt. |
| `IRONCLAW_REBORN_WEBUI_GITHUB_CLIENT_SECRET` | Erforderlich, wenn GitHub SSO aktiviert ist. |
| `IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS` | Erforderlich, wenn ein SSO-Anbieter aktiviert ist. Kommagetrennte verifizierte E-Mail-Domains. |
| `IRONCLAW_REBORN_WEBUI_OAUTH_HTTP_TIMEOUT_SECS` | Optionaler OAuth-HTTP-Timeout-Override. |

Für Google SSO erstellen Sie einen Google OAuth-Web-Client und registrieren Sie die Reborn WebUI-Weiterleitungs-URI als:```text
{IRONCLAW_REBORN_WEBUI_BASE_URL}/auth/callback/google

Zum Beispiel mit IRONCLAW_REBORN_WEBUI_BASE_URL=https://ironclaw.example.com ist die autorisierte Weiterleitungs-URI in Google Cloud:```text https://ironclaw.example.com/auth/callback/google

Notion MCP und andere Produkt-Auth OAuth-Setup-Flows verwenden dieselbe öffentliche WebUI-Basis-URL, wenn sie Anbieter-Callback-URLs registrieren. Fügen Sie keinen abschließenden Schrägstrich in `IRONCLAW_REBORN_WEBUI_BASE_URL` ein; Reborn entfernt ihn vor dem Aufbau der Callback-URLs. Wenn die Basis-URL weggelassen wird, verwendet Reborn die tatsächliche Listener-Adresse, wie `http://127.0.0.1:3000`, die nur für Loopback/lokale OAuth-Tests geeignet ist. Öffentliche oder nicht-Loopback-OAuth-Bereitstellungen müssen eine `https://`-Basis-URL festlegen.

Vollständige Google SSO-Startup-Umgebung:```bash
export IRONCLAW_REBORN_HOME="/var/lib/ironclaw-reborn"
export IRONCLAW_REBORN_PROFILE=local-dev
export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider
export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)"
export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli"
export IRONCLAW_REBORN_WEBUI_BASE_URL="https://ironclaw.example.com"
export IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS="example.com,team.example.com"
export IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_ID="..."
export IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_SECRET="..."

cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve --host 0.0.0.0 --port 3000

IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS ist die eigentliche Zulassungsliste. Google hd ist nur ein optionaler, anbieterseitiger Hinweis auf die gehostete Domäne; verlassen Sie sich nicht darauf anstelle der Reborn-Liste der erlaubten Domänen. IRONCLAW_REBORN_HOME wählt das Status-/Konfigurationsstammverzeichnis für diesen Dienst. IRONCLAW_REBORN_PROFILE hat den Standardwert local-dev; local-dev-yolo gewährt vertrauenswürdigen Laptop-Hostzugriff und kann nicht auf einem Nicht-Loopback-Host bereitgestellt werden.

Verwenden Sie serve --host <ip> --port <port>, um den Listener von der CLI aus zu überschreiben. Das Binden an einen Nicht-Loopback-Host ist produktionssensitiv. Der Serve-Modus local-dev-yolo erfordert außerdem --confirm-host-access und lehnt Nicht-Loopback-Hosts ab.

Slack-Dienst

Die Slack-Unterstützung ist hinter dem Cargo-Feature slack-v2-host-beta kompiliert. Dieses Feature enthält webui-v2-beta, sodass Slack mit demselben Befehl serve ausgeführt wird:```bash export IRONCLAW_REBORN_HOME="$PWD/.reborn-home" export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)" export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli" export IRONCLAW_REBORN_SLACK_ENABLED="true"

cargo run -q -p ironclaw_reborn_cli --features slack-v2-host-beta --bin ironclaw-reborn -- serve

Aktivieren Sie Slack, indem Sie `IRONCLAW_REBORN_SLACK_ENABLED=true` setzen oder einen `[slack]`-Abschnitt zu `config.toml` hinzufügen:```toml
[slack]
enabled = true

Die Umgebungsvariable überschreibt nur das Slack-Routen-Aktivierungsgate: true/1 montiert Slack, während false/0 als Bereitstellungs-Kill-Switch fungiert. Nach dem Serverstart konfigurieren Sie die Slack-App-IDs, Bot-Token, Signing-Secret und Channel-Zuordnungen über die WebUI-Channel-Einrichtung.

Erforderliche Slack-Einstellungen:

NameZweck
[slack].enabled = true oder IRONCLAW_REBORN_SLACK_ENABLED=trueMontiert die Slack-Route während serve.
WebUI Slack Workspace-EinrichtungSpeichert Slack-Installations-IDs, Channel-Zuordnungen sowie Slack-Bot-/Signing-Secrets.

Ausführlichere Hinweise zur Slack-Einrichtung finden Sie in docs/reborn/setup-slack-for-reborn-binary.md.

Philosophie

IronClaw basiert auf einem einfachen Prinzip: Ihr KI-Assistent sollte für Sie arbeiten, nicht gegen Sie.

In einer Welt, in der KI-Systeme zunehmend undurchsichtig in der Datenverarbeitung sind und an Unternehmensinteressen ausgerichtet werden, verfolgt IronClaw einen anderen Ansatz:

  • Ihre Daten gehören Ihnen – Alle Informationen werden lokal gespeichert, verschlüsselt und verlassen niemals Ihre Kontrolle
  • Transparenz von Grund auf – Open Source, überprüfbar, keine versteckte Telemetrie oder Datensammlung
  • Sich selbst erweiternde Fähigkeiten – Neue Tools spontan erstellen, ohne auf Updates des Anbieters warten zu müssen
  • Mehrschichtige Verteidigung – Mehrere Sicherheitsebenen schützen vor Prompt-Injection und Datenexfiltration

IronClaw ist der KI-Assistent, dem Sie Ihr privates und berufliches Leben tatsächlich anvertrauen können.

Funktionen

Sicherheit steht an erster Stelle

  • WASM-Sandbox – Nicht vertrauenswürdige Tools laufen in isolierten WebAssembly-Containern mit berechtigungsbasierten Berechtigungen
  • Credential-Schutz – Geheimnisse werden niemals Tools ausgesetzt; werden an der Host-Grenze mit Erkennung von Lecks injiziert
  • Prompt-Injection-Abwehr – Mustererkennung, Inhaltsbereinigung und Richtliniendurchsetzung
  • Endpoint-Allowlisting – HTTP-Anfragen nur an explizit genehmigte Hosts und Pfade

Immer verfügbar

  • Mehrkanal – REPL, HTTP-Webhooks, WASM-Kanäle (Telegram, Slack) und Web-Gateway
  • Docker-Sandbox – Isolierte Container-Ausführung mit tokens pro Auftrag und Orchestrator/Worker-Muster
  • Web-Gateway – Browser-UI mit Echtzeit-SSE/WebSocket-Streaming
  • Routinen – Cron-Zeitpläne, Ereignis-Trigger, Webhook-Handler für Hintergrundautomatisierung
  • Herzschlag-System – Proaktive Hintergrundausführung für Überwachungs- und Wartungsaufgaben
  • Parallele Aufträge – Gleichzeitige Bearbeitung mehrerer Anfragen mit isolierten Kontexten
  • Selbstreparatur – Automatische Erkennung und Wiederherstellung hängengebliebener Vorgänge

Selbstexpandierend

  • Dynamisches Tool-Building – Beschreiben Sie, was Sie brauchen, und IronClaw erstellt es als WASM-Tool
  • MCP-Protokoll – Verbindung zu Model Context Protocol-Servern für zusätzliche Fähigkeiten
  • Plugin-Architektur – Neue WASM-Tools und Kanäle ohne Neustart einbinden

Beständiger Speicher

  • Hybride Suche – Volltext- + Vektorsuche mit Reciprocal Rank Fusion
  • Workspace-Dateisystem – Flexibler pfadbasierter Speicher für Notizen, Logs und Kontext
  • Identitätsdateien – Konsistente Persönlichkeit und Präferenzen über Sitzungen hinweg beibehalten

Installation

Voraussetzungen

  • Rust 1.96+
  • PostgreSQL 15+ mit pgvector-Erweiterung
  • Node.js 22+ mit Corepack/pnpm für Quellcode-Builds, die das webui-v2-beta-Feature aktivieren
  • NEAR AI-Konto (Authentifizierung erfolgt über den Setup-Assistenten)
  • libclang und eine funktionierende C-Toolchain, wenn Sie den WeChat-Voice-/SILK-Pfad aus dem Quellcode erstellen

Herunterladen oder Erstellen

Besuchen Sie die Releases-Seite, um die neuesten Aktualisierungen zu sehen.

Installieren über Windows Installer (Windows)

Laden Sie den Windows Installer herunter und führen Sie ihn aus.

Installieren über PowerShell-Skript (Windows)```sh irm https://github.com/nearai/ironclaw/releases/latest/download/ironclaw-installer.ps1 | iex ```
Installation per Shell-Skript (macOS, Linux, Windows/WSL)```sh curl --proto '=https' --tlsv1.2 -LsSf https://github.com/nearai/ironclaw/releases/latest/download/ironclaw-installer.sh | sh ```
Installation via Homebrew (macOS/Linux)```sh brew install ironclaw ```
Kompilieren Sie den Quellcode (Cargo unter Windows, Linux, macOS)

Installieren Sie es mit cargo; stellen Sie sicher, dass Sie Rust auf Ihrem Computer installiert haben.```bash

Clone the repository

git clone https://github.com/nearai/ironclaw.git cd ironclaw

Build

cargo build --release

Run tests

cargo test

Für **vollständige Version** (nach Änderung der Kanalquellen) führen Sie `./scripts/build-all.sh` aus, um die Kanäle zuerst neu zu erstellen.

> **Optional:** WeChat-Sprachnotizen (`audio/silk`) benötigen das eigenständige
> `ironclaw-silk-decoder`-Hilfsprogramm, um transkribierbar zu sein. Es ist vom
> Standard-Workspace-Build ausgeschlossen, da `silk-codec` `bindgen`/`libclang`
> erfordert. Erstellen Sie es separat mit `./crates/ironclaw_silk_decoder/build.sh`
> (benötigt libclang + eine C-Toolchain) und legen Sie die resultierende
> Binärdatei in `$PATH`, neben der `ironclaw`-Binärdatei, oder verweisen Sie
> darauf mit `IRONCLAW_SILK_DECODER`. Ohne sie werden Sprachnachrichten weiterhin
> zugestellt — jedoch als rohe `audio/silk`-Blobs.

</details>

### Datenbank-Setup```bash
# Create database
createdb ironclaw

# Enable pgvector
psql ironclaw -c "CREATE EXTENSION IF NOT EXISTS vector;"

Konfiguration

Führen Sie den Setup-Assistenten aus, um IronClaw zu konfigurieren:```bash ironclaw onboard

Der Assistent kümmert sich um die Datenbankverbindung, die NEAR AI-Authentifizierung (über Browser-OAuth) und die Verschlüsselung von Geheimnissen (mithilfe Ihrer Systemsicherung). Einstellungen werden in der verbundenen Datenbank gespeichert; Bootstrap-Variablen (z. B. `DATABASE_URL`, `LLM_BACKEND`) werden in `~/.ironclaw/.env` geschrieben, sodass sie verfügbar sind, bevor die Datenbank verbunden wird.

### Alternative LLM-Anbieter

IronClaw standardmäßig NEAR AI, unterstützt aber viele LLM-Anbieter sofort. Zu den integrierten Anbietern gehören **Anthropic**, **OpenAI**, **GitHub Copilot**, **Google Gemini**, **MiniMax**, **Mistral** und **Ollama** (lokal). OpenAI-kompatible Dienste wie **OpenRouter** (300+ Modelle), **Together AI**, **Fireworks AI** und selbst gehostete Server (**vLLM**, **LiteLLM**) werden ebenfalls unterstützt.

Wählen Sie Ihren Anbieter im Assistenten aus oder setzen Sie Umgebungsvariablen direkt:```env
# Example: MiniMax (built-in, 204K context)
LLM_BACKEND=minimax
MINIMAX_API_KEY=...

# Example: OpenAI-compatible endpoint
LLM_BACKEND=openai_compatible
LLM_BASE_URL=https://openrouter.ai/api/v1
LLM_API_KEY=sk-or-...
LLM_MODEL=anthropic/claude-sonnet-4

Siehe docs/capabilities/llm-providers.md für eine vollständige Anleitung zu den Anbietern.

Sicherheit

IronClaw setzt auf eine mehrschichtige Verteidigung, um Ihre Daten zu schützen und Missbrauch zu verhindern.

WASM Sandbox

Alle nicht vertrauenswürdigen Tools werden in isolierten WebAssembly-Containern ausgeführt:

  • Fähigkeitsbasierte Berechtigungen - Explizites Opt-in für HTTP, Secrets und Tool-Aufrufe
  • Endpunkt-Allowlisting - HTTP-Anfragen nur an genehmigte Hosts/Pfade
  • Credential-Injection - Secrets werden an der Host-Grenze injiziert, niemals dem WASM-Code ausgesetzt
  • Leckerkennung - Scannt Anfragen und Antworten auf Geheimnis-Exfiltrationsversuche
  • Ratenbegrenzung - Pro-Tool-Anfragegrenzen, um Missbrauch zu verhindern
  • Ressourcenbeschränkungen - Einschränkungen für Arbeitsspeicher, CPU und Ausführungszeit``` WASM ──► Allowlist ──► Leak Scan ──► Credential ──► Execute ──► Leak Scan ──► WASM Validator (request) Injector Request (response)
### Schutz vor Prompt-Injection

Externe Inhalte durchlaufen mehrere Sicherheitsebenen:

- Musterbasierte Erkennung von Injectionsversuchen
- Inhaltsbereinigung und Escape-Verarbeitung
- Richtlinienregeln mit Schweregraden (Blockieren/Warnen/Prüfen/Bereinigen)
- Tool-Ausgabeumhüllung für sichere LLM-Kontext-Injektion

### Datenschutz

- Alle Daten werden lokal in Ihrer PostgreSQL-Datenbank gespeichert
- Geheimnisse mit AES-256-GCM verschlüsselt
- Keine Telemetrie, Analyse oder Datenweitergabe
- Vollständiges Prüfprotokoll aller Tool-Ausführungen

## Architektur```
┌────────────────────────────────────────────────────────────────┐
│                          Channels                              │
│  ┌──────┐  ┌──────┐   ┌─────────────┐  ┌─────────────┐         │
│  │ REPL │  │ HTTP │   │WASM Channels│  │ Web Gateway │         │
│  └──┬───┘  └──┬───┘   └──────┬──────┘  │ (SSE + WS)  │         │
│     │         │              │         └──────┬──────┘         │
│     └─────────┴──────────────┴────────────────┘                │
│                              │                                 │
│                    ┌─────────▼─────────┐                       │
│                    │    Agent Loop     │  Intent routing       │
│                    └────┬──────────┬───┘                       │
│                         │          │                           │
│              ┌──────────▼────┐  ┌──▼───────────────┐           │
│              │  Scheduler    │  │ Routines Engine  │           │
│              │(parallel jobs)│  │(cron, event, wh) │           │
│              └──────┬────────┘  └────────┬─────────┘           │
│                     │                    │                     │
│       ┌─────────────┼────────────────────┘                     │
│       │             │                                          │
│   ┌───▼─────┐  ┌────▼────────────────┐                         │
│   │ Local   │  │    Orchestrator     │                         │
│   │Workers  │  │  ┌───────────────┐  │                         │
│   │(in-proc)│  │  │ Docker Sandbox│  │                         │
│   └───┬─────┘  │  │   Containers  │  │                         │
│       │        │  │ ┌───────────┐ │  │                         │
│       │        │  │ │Worker / CC│ │  │                         │
│       │        │  │ └───────────┘ │  │                         │
│       │        │  └───────────────┘  │                         │
│       │        └─────────┬───────────┘                         │
│       └──────────────────┤                                     │
│                          │                                     │
│              ┌───────────▼──────────┐                          │
│              │    Tool Registry     │                          │
│              │  Built-in, MCP, WASM │                          │
│              └──────────────────────┘                          │
└────────────────────────────────────────────────────────────────┘

Kernkomponenten

KomponenteZweck
Agent LoopHauptnachrichtenverarbeitung und Job-Koordination
RouterKlassifiziert Benutzerabsicht (Befehl, Abfrage, Aufgabe)
SchedulerVerwaltet parallele Job-Ausführung mit Prioritäten
WorkerFührt Jobs mit LLM-Argumentation und Tool-Aufrufen aus
OrchestratorContainer-Lebenszyklus, LLM-Proxy, Authentifizierung pro Job
Web GatewayBrowser-UI mit Chat, Speicher, Jobs, Logs, Erweiterungen, Routinen
Routines EngineGeplante (Cron) und reaktive (Ereignis, Webhook) Hintergrundaufgaben
WorkspacePersistenter Speicher mit hybrider Suche
Safety LayerPrompt-Injection-Abwehr und Inhaltsbereinigung

IronClaw Verwendung```bash

First-time setup (configures database, auth, etc.)

ironclaw onboard

Start interactive REPL

cargo run

REPL with debug logging

RUST_LOG=ironclaw=debug cargo run

## Entwicklung```bash
# Format code
cargo fmt

# Lint
cargo clippy --all --benches --tests --examples --all-features

# Run tests
createdb ironclaw_test
cargo test

# Run specific test
cargo test test_name
  • Channels: Siehe docs/channels/overview.mdx für die Einrichtung von Telegram, Discord und anderen Kanälen.
  • Changing channel sources: Führen Sie ./channels-src/telegram/build.sh vor cargo build aus, damit die aktualisierte WASM eingebunden wird.

OpenClaw Erbe

IronClaw ist eine Rust-Neuimplementierung, inspiriert von OpenClaw. Siehe FEATURE_PARITY.md für die vollständige Tracking-Matrix.

Wesentliche Unterschiede:

  • Rust vs TypeScript - Native Leistung, Speichersicherheit, einzelne Binärdatei
  • WASM-Sandbox vs Docker - Leichtgewichtig, capability-basierte Sicherheit
  • PostgreSQL vs SQLite - Produktionsreife Persistenz
  • Security-first-Design - Mehrere Verteidigungsebenen, Schutz von Anmeldeinformationen

Lizenz

Lizenziert unter einer der folgenden Lizenzen:

nach Ihrer Wahl.

Kategorien