ZeroClaw 🦀

Null Overhead. Null Kompromiss. 100% Rust. 100% Agnostisch.
⚡️ Läuft auf 10$ Hardware mit <5MB RAM: Das ist 99% weniger Speicher als OpenClaw und 98% günstiger als ein Mac mini!

Erstellt von Studenten und Mitgliedern der Harvard, MIT und Sundai.Club Gemeinschaften.

🌐 Sprachen:🇺🇸 English · 🇨🇳 简体中文 · 🇯🇵 日本語 · 🇰🇷 한국어 · 🇻🇳 Tiếng Việt · 🇵🇭 Tagalog · 🇪🇸 Español · 🇧🇷 Português · 🇮🇹 Italiano · 🇩🇪 Deutsch · 🇫🇷 Français · 🇸🇦 العربية · 🇮🇳 हिन्दी · 🇷🇺 Русский · 🇧🇩 বাংলা · 🇮🇱 עברית · 🇵🇱 Polski · 🇨🇿 Čeština · 🇳🇱 Nederlands · 🇹🇷 Türkçe · 🇺🇦 Українська · 🇮🇩 Bahasa Indonesia · 🇹🇭 ไทย · 🇵🇰 اردو · 🇷🇴 Română · 🇸🇪 Svenska · 🇬🇷 Ελληνικά · 🇭🇺 Magyar · 🇫🇮 Suomi · 🇩🇰 Dansk · 🇳🇴 Norsk

Schnellstart | Ein-Klick-Einrichtung | Dokumentations-Hub | Dokumentations-Inhaltsverzeichnis

📝 Hinweis: Die Dokumentationslinks verweisen auf die englischsprachige Dokumentation. Lokalisierte Dokumentation für Deutsch ist noch nicht verfügbar.

Schnellzugriffe: Referenz · Betrieb · Fehlerbehebung · Sicherheit · Hardware · Mitwirken

Schnelle, leichtgewichtige und vollständig autonome KI-Assistenten-Infrastruktur
Deploy überall. Tausche alles.

ZeroClaw ist das Runtime-Betriebssystem für Agenten-Workflows — eine Infrastruktur, die Modelle, Tools, Speicher und Ausführung abstrahiert, um Agenten einmal zu bauen und überall auszuführen.

Trait-basierte Architektur · sicheres Runtime standardmäßig · Provider/Channel/Tool austauschbar · alles ist steckbar

📢 Ankündigungen

Verwende diese Tabelle für wichtige Hinweise (Kompatibilitätsänderungen, Sicherheitshinweise, Wartungsfenster und Versionsblockierungen).

Datum (UTC)	Ebene	Hinweis	Aktion
2026-02-19	Kritisch	Wir sind nicht verbunden mit `openagen/zeroclaw` oder `zeroclaw.org`. Die Domain `zeroclaw.org` zeigt derzeit auf den Fork `openagen/zeroclaw`, und diese Domain/Repository fälscht unsere offizielle Website/Projekt.	Vertraue keinen Informationen, Binärdateien, Fundraising oder Ankündigungen aus diesen Quellen. Verwende nur dieses Repository und unsere verifizierten Social-Media-Konten.
2026-02-21	Wichtig	Unsere offizielle Website ist jetzt online: zeroclawlabs.ai. Danke für deine Geduld während der Wartezeit. Wir erkennen weiterhin Fälschungsversuche: nimm an keiner Investitions-/Finanzierungsaktivität im Namen von ZeroClaw teil, wenn sie nicht über unsere offiziellen Kanäle veröffentlicht wird.	Verwende dieses Repository als einzige Quelle der Wahrheit. Folge X (@zeroclawlabs), Telegram (@zeroclawlabs), Facebook (Gruppe), Reddit (r/zeroclawlabs), und Xiaohongshu für offizielle Updates.
2026-02-19	Wichtig	Anthropic hat die Nutzungsbedingungen für Authentifizierung und Anmeldedaten am 2026-02-19 aktualisiert. Die OAuth-Authentifizierung (Free, Pro, Max) ist ausschließlich für Claude Code und Claude.ai; die Verwendung von Claude Free/Pro/Max OAuth-Token in einem anderen Produkt, Tool oder Dienst (einschließlich Agent SDK) ist nicht erlaubt und kann gegen die Verbrauchernutzungsbedingungen verstoßen.	Bitte vermeide vorübergehend Claude Code OAuth-Integrationen, um potenzielle Verluste zu verhindern. Originalklausel: Authentication and Credential Use.

✨ Funktionen

🏎️ Leichtgewichtiges Runtime standardmäßig: Gängige CLI-Workflows und Statusbefehle laufen in einem Speicherbereich von wenigen Megabyte bei Produktions-Builds.
💰 Kosteneffizientes Deployment: Entwickelt für Low-Cost-Boards und kleine Cloud-Instanzen ohne schwere Runtime-Abhängigkeiten.
⚡ Schnelle Kaltstarts: Die Single-Binary-Rust-Runtime hält Befehls- und Daemon-Starts für tägliche Operationen nahezu augenblicklich.
🌍 Portable Architektur: Ein Single-Binary-Workflow auf ARM, x86 und RISC-V mit austauschbaren Providern/Channels/Tools.

Warum Teams ZeroClaw wählen

Leichtgewichtig standardmäßig: kleines Rust-Binary, schneller Start, geringer Speicherbedarf.
Sicher by Design: Pairing, striktes Sandboxing, explizite Allowlists, Workspace-Scope.
Vollständig austauschbar: Kernsysteme sind Traits (Provider, Channels, Tools, Speicher, Tunnel).
Kein Provider-Lock-in: OpenAI-kompatible Provider-Unterstützung + steckbare Custom-Endpoints.

Benchmark-Snapshot (ZeroClaw vs OpenClaw, Reproduzierbar)

Schneller Benchmark auf lokalem Rechner (macOS arm64, Feb. 2026) normalisiert für 0.8 GHz Edge-Hardware.

	OpenClaw	NanoBot	PicoClaw	ZeroClaw 🦀
Sprache	TypeScript	Python	Go	Rust
RAM	> 1 GB	> 100 MB	< 10 MB	< 5 MB
Start (0.8 GHz Kern)	> 500s	> 30s	< 1s	< 10ms
Binary-Größe	~28 MB (dist)	N/A (Scripts)	~8 MB	3.4 MB
Kosten	Mac Mini $599	Linux SBC ~$50	Linux-Board $10	Jede Hardware $10

Hinweise: ZeroClaw-Ergebnisse werden auf Produktions-Builds mit /usr/bin/time -l gemessen. OpenClaw benötigt die Node.js-Runtime (typischerweise ~390 MB zusätzlicher Speicher-Overhead), während NanoBot die Python-Runtime benötigt. PicoClaw und ZeroClaw sind statische Binaries. Die oben genannten RAM-Zahlen sind Runtime-Speicher; Build-time-Kompilierungsanforderungen sind höher.

Reproduzierbare lokale Messung

Benchmark-Behauptungen können sich ändern, wenn Code und Toolchains sich weiterentwickeln, also miss deinen aktuellen Build immer lokal:

cargo build --release
ls -lh target/release/zeroclaw

/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status

Beispielstichprobe (macOS arm64, gemessen am 18. Februar 2026):

Release-Binary-Größe: 8.8M
zeroclaw --help: Echtzeit ca. 0.02s, maximaler Speicherbedarf ~3.9 MB
zeroclaw status: Echtzeit ca. 0.01s, maximaler Speicherbedarf ~4.1 MB

Voraussetzungen

Windows

Windows — Erforderlich

Visual Studio Build Tools (stellt MSVC-Linker und Windows SDK bereit):
```
winget install Microsoft.VisualStudio.2022.BuildTools
```
Wähle während der Installation (oder über Visual Studio Installer) die Workload "Desktop-Entwicklung mit C++".
Rust-Toolchain:
```
winget install Rustlang.Rustup
```
Öffne nach der Installation ein neues Terminal und führe rustup default stable aus, um sicherzustellen, dass die stabile Toolchain aktiv ist.
Überprüfe, dass beide funktionieren:
```
rustc --version
cargo --version
```

Windows — Optional

Docker Desktop — nur erforderlich, wenn du die Docker-Sandbox-Runtime verwendest (runtime.kind = "docker"). Installiere über winget install Docker.DockerDesktop.

Linux / macOS

Linux / macOS — Erforderlich

Essentielle Build-Tools:
- Linux (Debian/Ubuntu): sudo apt install build-essential pkg-config
- Linux (Fedora/RHEL): sudo dnf group install development-tools && sudo dnf install pkg-config
- macOS: Installiere Xcode Command Line Tools: xcode-select --install

Rust-Toolchain:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Siehe rustup.rs für Details.

Überprüfe:
```
rustc --version
cargo --version
```

Linux / macOS — Optional

Docker — nur erforderlich, wenn du die Docker-Sandbox-Runtime verwendest (runtime.kind = "docker").
- Linux (Debian/Ubuntu): siehe docs.docker.com
- Linux (Fedora/RHEL): siehe docs.docker.com
- macOS: installiere Docker Desktop über docker.com/products/docker-desktop

Schnellstart

Option 1: Automatisierte Einrichtung (empfohlen)

Das bootstrap.sh-Skript installiert Rust, klont ZeroClaw, kompiliert es und richtet deine anfängliche Entwicklungsumgebung ein:

curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/master/bootstrap.sh | bash

Dies wird:

Rust installieren (falls nicht vorhanden)
Das ZeroClaw-Repository klonen
ZeroClaw im Release-Modus kompilieren
zeroclaw in ~/.cargo/bin/ installieren
Die Standard-Workspace-Struktur in ~/.zeroclaw/workspace/ erstellen
Eine Startkonfigurationsdatei ~/.zeroclaw/workspace/config.toml generieren

Nach dem Bootstrap lade deine Shell neu oder führe source ~/.cargo/env aus, um den zeroclaw-Befehl global zu verwenden.

Option 2: Manuelle Installation

Klicke, um die manuellen Installationsschritte zu sehen

# 1. Klone das Repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw

# 2. Kompiliere im Release-Modus
cargo build --release --locked

# 3. Installiere das Binary
cargo install --path . --locked

# 4. Initialisiere den Workspace
zeroclaw init

# 5. Überprüfe die Installation
zeroclaw --version
zeroclaw status

Nach der Installation

Nach der Installation (via Bootstrap oder manuell) solltest du sehen:

~/.zeroclaw/workspace/
├── config.toml          # Hauptkonfiguration
├── .pairing             # Pairing-Geheimnisse (beim ersten Start generiert)
├── logs/                # Daemon/Agent-Logs
├── skills/              # Benutzerdefinierte Skills
└── memory/              # Konversationskontext-Speicherung

Nächste Schritte:

Konfiguriere deine KI-Provider in ~/.zeroclaw/workspace/config.toml
Sieh dir die Konfigurationsreferenz für erweiterte Optionen an
Starte den Agent: zeroclaw agent start
Teste über deinen bevorzugten Channel (siehe Channel-Referenz)

Konfiguration

Bearbeite ~/.zeroclaw/workspace/config.toml, um Provider, Channels und Systemverhalten zu konfigurieren.

Schnelle Konfigurationsreferenz

[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"

[providers.openai]
api_key = "sk-..."
model = "gpt-4o"

[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."

[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."

[memory]
kind = "markdown"  # oder "sqlite" oder "none"

[runtime]
kind = "native"    # oder "docker" (erfordert Docker)

Vollständige Referenzdokumente:

Konfigurationsreferenz — alle Einstellungen, Validierungen, Standardwerte
Provider-Referenz — KI-Provider-spezifische Konfigurationen
Channel-Referenz — Telegram, Matrix, Slack, Discord und mehr
Betrieb — Produktionsüberwachung, Secret-Rotation, Skalierung

Aktuelle Runtime-Unterstützung

ZeroClaw unterstützt zwei Code-Ausführungs-Backends:

native (Standard) — direkte Prozessausführung, schnellster Pfad, ideal für vertrauenswürdige Umgebungen
docker — vollständige Container-Isolierung, gehärtete Sicherheitsrichtlinien, erfordert Docker

Verwende runtime.kind = "docker", wenn du striktes Sandboxing oder Netzwerkisolierung benötigst. Siehe Konfigurationsreferenz für vollständige Details.

Befehle

# Workspace-Verwaltung
zeroclaw init                # Initialisiert einen neuen Workspace
zeroclaw status              # Zeigt Daemon/Agent-Status
zeroclaw config validate     # Überprüft config.toml Syntax und Werte

# Daemon-Verwaltung
zeroclaw daemon start        # Startet den Daemon im Hintergrund
zeroclaw daemon stop         # Stoppt den laufenden Daemon
zeroclaw daemon restart      # Startet den Daemon neu (Config-Neuladen)
zeroclaw daemon logs         # Zeigt Daemon-Logs

# Agent-Verwaltung
zeroclaw agent start         # Startet den Agent (erfordert laufenden Daemon)
zeroclaw agent stop          # Stoppt den Agent
zeroclaw agent restart       # Startet den Agent neu (Config-Neuladen)

# Pairing-Operationen
zeroclaw pairing init        # Generiert ein neues Pairing-Geheimnis
zeroclaw pairing rotate      # Rotiert das bestehende Pairing-Geheimnis

# Tunneling (für öffentliche Exposition)
zeroclaw tunnel start        # Startet einen Tunnel zum lokalen Daemon
zeroclaw tunnel stop         # Stoppt den aktiven Tunnel

# Diagnose
zeroclaw doctor              # Führt System-Gesundheitsprüfungen durch
zeroclaw version             # Zeigt Version und Build-Informationen

Siehe Befehlsreferenz für vollständige Optionen und Beispiele.

Architektur

┌─────────────────────────────────────────────────────────────────┐
│                        Channels (Trait)                         │
│  Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom       │
└─────────────────────────┬───────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────────────┐
│                      Agent-Orchestrator                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │   Routing    │  │   Kontext    │  │  Ausführung  │          │
│  │   Nachricht  │  │   Speicher   │  │   Werkzeug   │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
└─────────────────────────┬───────────────────────────────────────┘
                          │
          ┌───────────────┼───────────────┐
          ▼               ▼               ▼
┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│   Provider   │  │   Speicher   │  │  Werkzeuge   │
│   (Trait)    │  │   (Trait)    │  │   (Trait)    │
├──────────────┤  ├──────────────┤  ├──────────────┤
│  Anthropic   │  │   Markdown   │  │  Filesystem  │
│   OpenAI     │  │    SQLite    │  │     Bash     │
│   Gemini     │  │     None     │  │   Web Fetch  │
│   Ollama     │  │    Custom    │  │   Custom     │
│   Custom     │  └──────────────┘  └──────────────┘
└──────────────┘
          │
          ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Runtime (Trait)                               │
│                  Native │ Docker                                │
└─────────────────────────────────────────────────────────────────┘

Schlüsselprinzipien:

Alles ist ein Trait — Provider, Channels, Tools, Speicher, Tunnel
Channels rufen den Orchestrator auf; der Orchestrator ruft Provider + Tools auf
Das Speichersystem verwaltet Konversationskontext (Markdown, SQLite, oder keiner)
Das Runtime abstrahiert Code-Ausführung (nativ oder Docker)
Kein Provider-Lock-in — tausche Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama ohne Code-Änderungen

Siehe Architektur-Dokumentation für detaillierte Diagramme und Implementierungsdetails.

Beispiele

Telegram-Bot

[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321]  # Deine Telegram-Benutzer-ID

Starte den Daemon + Agent, dann sende eine Nachricht an deinen Bot auf Telegram:

/start
Hallo! Könntest du mir helfen, ein Python-Skript zu schreiben?

Der Bot antwortet mit KI-generiertem Code, führt Tools auf Anfrage aus und behält den Konversationskontext.

Matrix (Ende-zu-Ende-Verschlüsselung)

[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true

Lade @zeroclaw:matrix.org in einen verschlüsselten Raum ein, und der Bot wird mit vollständiger Verschlüsselung antworten. Siehe Matrix E2EE-Leitfaden für Geräteverifizierungs-Setup.

Multi-Provider

[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"

[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"

[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"]  # Failover bei Provider-Fehler

Wenn Anthropic fehlschlägt oder Rate-Limit erreicht, wechselt der Orchestrator automatisch zu OpenAI.

Benutzerdefinierter Speicher

[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90  # Automatische Bereinigung nach 90 Tagen

Oder verwende Markdown für menschenlesbaren Speicher:

[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"

Siehe Konfigurationsreferenz für alle Speicheroptionen.

Provider-Unterstützung

Provider	Status	API-Schlüssel	Beispielmodelle
Anthropic	✅ Stabil	`ANTHROPIC_API_KEY`	`claude-sonnet-4-20250514`, `claude-opus-4-20250514`
OpenAI	✅ Stabil	`OPENAI_API_KEY`	`gpt-4o`, `gpt-4o-mini`, `o1`, `o1-mini`
Google Gemini	✅ Stabil	`GOOGLE_API_KEY`	`gemini-2.0-flash-exp`, `gemini-exp-1206`
Ollama	✅ Stabil	N/A (lokal)	`llama3.3`, `qwen2.5`, `phi4`
Cerebras	✅ Stabil	`CEREBRAS_API_KEY`	`llama-3.3-70b`
Groq	✅ Stabil	`GROQ_API_KEY`	`llama-3.3-70b-versatile`
Mistral	🚧 Geplant	`MISTRAL_API_KEY`	TBD
Cohere	🚧 Geplant	`COHERE_API_KEY`	TBD

Benutzerdefinierte Endpoints

ZeroClaw unterstützt OpenAI-kompatible Endpoints:

[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"

Beispiel: verwende LiteLLM als Proxy, um auf jedes LLM über die OpenAI-Schnittstelle zuzugreifen.

Siehe Provider-Referenz für vollständige Konfigurationsdetails.

Channel-Unterstützung

Channel	Status	Authentifizierung	Hinweise
Telegram	✅ Stabil	Bot-Token	Vollständige Unterstützung inklusive Dateien, Bilder, Inline-Buttons
Matrix	✅ Stabil	Passwort oder Token	E2EE-Unterstützung mit Geräteverifizierung
Slack	🚧 Geplant	OAuth oder Bot-Token	Erfordert Workspace-Zugriff
Discord	🚧 Geplant	Bot-Token	Erfordert Guild-Berechtigungen
WhatsApp	🚧 Geplant	Twilio oder offizielle API	Erfordert Business-Konto
CLI	✅ Stabil	Keine	Direkte konversationelle Schnittstelle
Web	🚧 Geplant	API-Schlüssel oder OAuth	Browserbasierte Chat-Schnittstelle

Siehe Channel-Referenz für vollständige Konfigurationsanleitungen.

Tool-Unterstützung

ZeroClaw bietet integrierte Tools für Code-Ausführung, Dateisystemzugriff und Web-Abruf:

Tool	Beschreibung	Erforderliches Runtime
bash	Führt Shell-Befehle aus	Nativ oder Docker
python	Führt Python-Skripte aus	Python 3.8+ (nativ) oder Docker
javascript	Führt Node.js-Code aus	Node.js 18+ (nativ) oder Docker
filesystem_read	Liest Dateien	Nativ oder Docker
filesystem_write	Schreibt Dateien	Nativ oder Docker
web_fetch	Ruft Web-Inhalte ab	Nativ oder Docker

Ausführungssicherheit

Natives Runtime — läuft als Benutzerprozess des Daemons, voller Dateisystemzugriff
Docker-Runtime — vollständige Container-Isolierung, separate Dateisysteme und Netzwerke

Konfiguriere die Ausführungsrichtlinie in config.toml:

[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"]  # Explizite Allowlist

Siehe Konfigurationsreferenz für vollständige Sicherheitsoptionen.

Deployment

Lokales Deployment (Entwicklung)

zeroclaw daemon start
zeroclaw agent start

Server-Deployment (Produktion)

Verwende systemd, um Daemon und Agent als Dienste zu verwalten:

# Installiere das Binary
cargo install --path . --locked

# Konfiguriere den Workspace
zeroclaw init

# Erstelle systemd-Dienstdateien
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/

# Aktiviere und starte die Dienste
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent

# Überprüfe den Status
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent

Siehe Netzwerk-Deployment-Leitfaden für vollständige Produktions-Deployment-Anleitungen.

Docker

# Baue das Image
docker build -t zeroclaw:latest .

# Führe den Container aus
docker run -d \
  --name zeroclaw \
  -v ~/.zeroclaw/workspace:/workspace \
  -e ANTHROPIC_API_KEY=sk-ant-... \
  zeroclaw:latest

Siehe Dockerfile für Build-Details und Konfigurationsoptionen.

Edge-Hardware

ZeroClaw ist für den Betrieb auf Low-Power-Hardware konzipiert:

Raspberry Pi Zero 2 W — ~512 MB RAM, einzelner ARMv8-Kern, < $5 Hardware-Kosten
Raspberry Pi 4/5 — 1 GB+ RAM, Multi-Core, ideal für gleichzeitige Workloads
Orange Pi Zero 2 — ~512 MB RAM, Quad-Core ARMv8, Ultra-Low-Cost
x86 SBCs (Intel N100) — 4-8 GB RAM, schnelle Builds, nativer Docker-Support

Siehe Hardware-Leitfaden für gerätespezifische Einrichtungsanleitungen.

Tunneling (Öffentliche Exposition)

Exponiere deinen lokalen ZeroClaw-Daemon über sichere Tunnel zum öffentlichen Netzwerk:

zeroclaw tunnel start --provider cloudflare

Unterstützte Tunnel-Provider:

Cloudflare Tunnel — kostenloses HTTPS, keine Port-Exposition, Multi-Domain-Support
Ngrok — schnelle Einrichtung, benutzerdefinierte Domains (kostenpflichtiger Plan)
Tailscale — privates Mesh-Netzwerk, kein öffentlicher Port

Siehe Konfigurationsreferenz für vollständige Konfigurationsoptionen.

Sicherheit

ZeroClaw implementiert mehrere Sicherheitsebenen:

Pairing

Der Daemon generiert beim ersten Start ein Pairing-Geheimnis, das in ~/.zeroclaw/workspace/.pairing gespeichert wird. Clients (Agent, CLI) müssen dieses Geheimnis präsentieren, um eine Verbindung herzustellen.

zeroclaw pairing rotate  # Generiert ein neues Geheimnis und erklärt das alte für ungültig

Sandboxing

Docker-Runtime — vollständige Container-Isolierung mit separaten Dateisystemen und Netzwerken
Natives Runtime — läuft als Benutzerprozess, standardmäßig auf Workspace beschränkt

Allowlists

Channels können den Zugriff nach Benutzer-ID einschränken:

[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321]  # Explizite Allowlist

Verschlüsselung

Matrix E2EE — vollständige Ende-zu-Ende-Verschlüsselung mit Geräteverifizierung
TLS-Transport — der gesamte API- und Tunnel-Verkehr verwendet HTTPS/TLS

Siehe Sicherheitsdokumentation für vollständige Richtlinien und Praktiken.

Observability

ZeroClaw protokolliert standardmäßig in ~/.zeroclaw/workspace/logs/. Logs werden nach Komponente gespeichert:

~/.zeroclaw/workspace/logs/
├── daemon.log           # Daemon-Logs (Start, API-Anfragen, Fehler)
├── agent.log            # Agent-Logs (Nachrichten-Routing, Tool-Ausführung)
├── telegram.log         # Kanalspezifische Logs (falls aktiviert)
└── matrix.log           # Kanalspezifische Logs (falls aktiviert)

Logging-Konfiguration

[logging]
level = "info"                           # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily"                       # daily, hourly, size
max_size_mb = 100                        # Für größenbasierte Rotation
retention_days = 30                      # Automatische Bereinigung nach N Tagen

Siehe Konfigurationsreferenz für alle Logging-Optionen.

Metriken (Geplant)

Prometheus-Metrik-Unterstützung für Produktionsüberwachung kommt bald. Verfolgung in #234.

Skills

ZeroClaw unterstützt benutzerdefinierte Skills — wiederverwendbare Module, die die Systemfähigkeiten erweitern.

Skill-Definition

Skills werden in ~/.zeroclaw/workspace/skills/<skill-name>/ mit dieser Struktur gespeichert:

skills/
└── my-skill/
    ├── skill.toml       # Skill-Metadaten (Name, Beschreibung, Abhängigkeiten)
    ├── prompt.md        # System-Prompt für die KI
    └── tools/           # Optionale benutzerdefinierte Tools
        └── my_tool.py

Skill-Beispiel

# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Sucht im Web und fasst Ergebnisse zusammen"
version = "1.0.0"

[dependencies]
tools = ["web_fetch", "bash"]

<!-- skills/web-research/prompt.md -->

Du bist ein Forschungsassistent. Wenn du gebeten wirst, etwas zu recherchieren:

1. Verwende web_fetch, um den Inhalt abzurufen
2. Fasse die Ergebnisse in einem leicht lesbaren Format zusammen
3. Zitiere die Quellen mit URLs

Skill-Verwendung

Skills werden beim Agent-Start automatisch geladen. Referenziere sie nach Namen in Konversationen:

Benutzer: Verwende den Web-Research-Skill, um die neuesten KI-Nachrichten zu finden
Bot: [lädt den Web-Research-Skill, führt web_fetch aus, fasst Ergebnisse zusammen]

Siehe Abschnitt Skills für vollständige Skill-Erstellungsanleitungen.

Open Skills

ZeroClaw unterstützt Open Skills — ein modulares und provider-agnostisches System zur Erweiterung von KI-Agenten-Fähigkeiten.

Open Skills aktivieren

[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills"  # optional

Du kannst auch zur Laufzeit mit ZEROCLAW_OPEN_SKILLS_ENABLED und ZEROCLAW_OPEN_SKILLS_DIR überschreiben.

Entwicklung

cargo build              # Entwicklungs-Build
cargo build --release    # Release-Build (codegen-units=1, funktioniert auf allen Geräten einschließlich Raspberry Pi)
cargo build --profile release-fast    # Schnellerer Build (codegen-units=8, erfordert 16 GB+ RAM)
cargo test               # Führt die vollständige Test-Suite aus
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt                # Formatierung

# Führe den SQLite vs Markdown Vergleichs-Benchmark aus
cargo test --test memory_comparison -- --nocapture

Pre-push-Hook

Ein Git-Hook führt cargo fmt --check, cargo clippy -- -D warnings, und cargo test vor jedem Push aus. Aktiviere ihn einmal:

git config core.hooksPath .githooks

Build-Fehlerbehebung (OpenSSL-Fehler unter Linux)

Wenn du auf einen openssl-sys-Build-Fehler stößt, synchronisiere Abhängigkeiten und kompiliere mit dem Lockfile des Repositories neu:

git pull
cargo build --release --locked
cargo install --path . --force --locked

ZeroClaw ist so konfiguriert, dass es rustls für HTTP/TLS-Abhängigkeiten verwendet; --locked hält den transitiven Graphen in sauberen Umgebungen deterministisch.

Um den Hook zu überspringen, wenn du während der Entwicklung einen schnellen Push benötigst:

git push --no-verify

Zusammenarbeit & Docs

Beginne mit dem Dokumentations-Hub für eine Aufgaben-basierte Karte:

Dokumentations-Hub: docs/README.md
Vereinigtes Docs-Inhaltsverzeichnis: docs/SUMMARY.md
Befehlsreferenz: docs/commands-reference.md
Konfigurationsreferenz: docs/config-reference.md
Provider-Referenz: docs/providers-reference.md
Channel-Referenz: docs/channels-reference.md
Betriebshandbuch: docs/operations-runbook.md
Fehlerbehebung: docs/troubleshooting.md
Docs-Inventar/Klassifizierung: docs/docs-inventory.md
PR/Issue-Triage-Snapshot (Stand 18. Feb. 2026): docs/project-triage-snapshot-2026-02-18.md

Hauptzusammenarbeitsreferenzen:

Dokumentations-Hub: docs/README.md
Dokumentationsvorlage: docs/doc-template.md
Dokumentationsänderungs-Checkliste: docs/README.md#4-documentation-change-checklist
Channel-Konfigurationsreferenz: docs/channels-reference.md
Matrix-verschlüsselte Raum-Operationen: docs/matrix-e2ee-guide.md
Beitragsleitfaden: CONTRIBUTING.md
PR-Workflow-Richtlinie: docs/pr-workflow.md
Reviewer-Playbook (Triage + Tiefenreview): docs/reviewer-playbook.md
Eigentums- und CI-Triage-Map: docs/ci-map.md
Sicherheits-Offenlegungsrichtlinie: SECURITY.md

Für Deployment und Runtime-Betrieb:

Netzwerk-Deployment-Leitfaden: docs/network-deployment.md
Proxy-Agent-Playbook: docs/proxy-agent-playbook.md

ZeroClaw unterstützen

Wenn ZeroClaw deine Arbeit hilft und du die kontinuierliche Entwicklung unterstützen möchtest, kannst du hier spenden:

🙏 Besonderer Dank

Ein herzliches Dankeschön an die Gemeinschaften und Institutionen, die diese Open-Source-Arbeit inspirieren und unterstützen:

Harvard University — für die Förderung intellektueller Neugier und das Erweitern der Grenzen des Möglichen.
MIT — für das Eintreten für offenes Wissen, Open Source und die Überzeugung, dass Technologie für alle zugänglich sein sollte.
Sundai Club — für die Gemeinschaft, die Energie und den unermüdlichen Willen, Dinge zu bauen, die zählen.
Die Welt und Darüber Hinaus 🌍✨ — an jeden Mitwirkenden, Träumer und Erbauer da draußen, der Open Source zu einer Kraft für das Gute macht. Das ist für dich.

Wir bauen in Open Source, weil die besten Ideen von überall kommen. Wenn du das liest, bist du Teil davon. Willkommen. 🦀❤️

⚠️ Offizielles Repository und Fälschungswarnung

Dies ist das einzige offizielle ZeroClaw-Repository:

https://github.com/zeroclaw-labs/zeroclaw

Jedes andere Repository, Organisation, Domain oder Paket, das behauptet "ZeroClaw" zu sein oder eine Verbindung zu ZeroClaw Labs zu implizieren, ist nicht autorisiert und nicht mit diesem Projekt verbunden. Bekannte nicht autorisierte Forks werden in TRADEMARK.md aufgeführt.

Wenn du auf Fälschung oder Markenmissbrauch stößt, bitte öffne ein Issue.

Lizenz

ZeroClaw ist doppelt lizenziert für maximale Offenheit und Contributorschutz:

Lizenz	Anwendungsfälle
MIT	Open-Source, Forschung, akademisch, persönliche Nutzung
Apache 2.0	Patentschutz, institutionell, kommerzielles Deployment

Du kannst eine der beiden Lizenzen wählen. Contributors gewähren automatisch Rechte unter beiden — siehe CLA.md für die vollständige Contributor-Vereinbarung.

Marke

Der Name ZeroClaw und das Logo sind eingetragene Marken von ZeroClaw Labs. Diese Lizenz gewährt keine Erlaubnis, sie zu verwenden, um Befürwortung oder Verbindung zu implizieren. Siehe TRADEMARK.md für erlaubte und verbotene Verwendungen.

Contributorschutz

Du behältst das Urheberrecht an deinen Beiträgen
Patentgewährung (Apache 2.0) schützt dich vor Patentansprüchen anderer Contributors
Deine Beiträge werden dauerhaft zugeschrieben in der Commit-Historie und NOTICE
Keine Markenrechte werden durch Beiträge übertragen

Mitwirken

Siehe CONTRIBUTING.md und CLA.md. Implementiere einen Trait, reiche eine PR ein:

CI-Workflow-Leitfaden: docs/ci-map.md
Neuer Provider → src/providers/
Neuer Channel → src/channels/
Neuer Observer → src/observability/
Neues Tool → src/tools/
Neuer Memory → src/memory/
Neuer Tunnel → src/tunnel/
Neuer Skill → ~/.zeroclaw/workspace/skills/<n>/

ZeroClaw — Null Overhead. Null Kompromiss. Deploy überall. Tausche alles. 🦀

FilesExpand file tree

README.de.md

Latest commit

History