Nexus OS ist ein KI-Agenten-Betriebssystem, bei dem Agenten Bürger erster Klasse mit kryptografischen Identitäten, gelenkter Autonomie und der Fähigkeit zur Evolution sind. Es läuft vollständig auf Ihrer Hardware – keine Cloud-Abhängigkeit, keine Daten verlassen Ihren Rechner, luftspaltbar. Jede Aktion wird in einer Hash-Kette aufgezeichnet, jede Entscheidung ist prüfbar, jeder Agent ist in einer Sandbox isoliert.

┌──────────────────────────────────────────────────────────────────────┐
│                        Nexus OS v10.6.0                              │
│                                                                      │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐            │
│  │ Coder    │  │ Research │  │ Security │  │ DevOps   │  ...55     │
│  │ Agent    │  │ Agent    │  │ Agent    │  │ Agent    │  agents    │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘            │
│       │              │              │              │                  │
│  ┌────▼──────────────▼──────────────▼──────────────▼─────┐           │
│  │              Nexus Conductor (Orchestrierung)           │           │
│  │       A2A-Protokoll  ·  MCP-Protokoll  ·  Schwarm       │           │
│  └───────────────────────┬────────────────────────────────┘           │
│                          │                                            │
│  ┌───────────────────────▼────────────────────────────────┐           │
│  │                   Governance-Kernel                     │           │
│  │  Capability ACL · HITL Gates · Fuel Metering            │           │
│  │  OWASP 10/10 · Ed25519 Consent · PII-Entfernung         │           │
│  │  Hash-Chain-Prüfung · WASM-Sandbox · Cedar-Richtlinien  │           │
│  └───────────────────────┬────────────────────────────────┘           │
│                          │                                            │
│  ┌───────────────────────▼────────────────────────────────┐           │
│  │                    LLM-Anbieter (15)                     │           │
│  │  Ollama · OpenAI · Claude · Gemini · Groq · DeepSeek    │           │
│  │  NVIDIA NIM · OpenRouter · Mistral · Cohere · Fireworks  │           │
│  │  Together · Perplexity · Flash (llama.cpp) · + Mock      │           │
│  └────────────────────────────────────────────────────────┘           │
│                                                                      │
│  Rust-Kernel (326K LOC) · Tauri 2.0 Shell · React/TS Frontend (65K)  │
└──────────────────────────────────────────────────────────────────────┘

Warum Nexus OS?

Funktionen

Governance und Sicherheit

• OWASP Agentic Top 10 – Alle 10 Abwehrmaßnahmen implementiert und getestet (62 dedizierte Tests)
• Ed25519-Zustimmungsunterzeichnung – Genehmigungen der Stufe 2+ sind kryptografisch nicht abstreitbar
• Post-Quanten-bereit – Ed25519 + X25519 mit ML-DSA/ML-KEM-Fahrplan (nexus-crypto)
• Prompt-Firewall – 20 Injection-Muster, PII-Entfernung, Ausgabefilter
• Cedar-inspirierte Richtlinien – Deklarative Fähigkeitsregeln mit formaler Auswertung
• HITL-Zustimmungsgates – 4 Stufen (Stufe0-3) mit konfigurierbarer Anzahl von Genehmigungen
• Hash-verkettete Prüfung – Manipulationssicher, nur Anhängen, kryptografisch verifizierbar
• Checkpoint-Rollback – 3-stufige Wiederherstellung: Speicher, Ausführung, Nebenwirkungskompensation

Agentenintelligenz

• Kognitiver Kreislauf – Wahrnehmen, Denken, Planen, Handeln, Reflektieren, Lernen
• Darwin Core – Adversarial Arena, Schwarmkoordination, Evolutionsstrategien
• Fähigkeitsmessung – 4-Vektor-Bewertung mit Erkennung von Spielmanipulation
• Prädiktives Routing – Modellauswahl optimiert für Latenz, Kosten und Aufgabenkomplexität
• Speichersubsystem – 4 Typen (Arbeits-, episodischer, semantischer, prozeduraler Speicher) mit SQLite, GC, Rollback, ACL
• 55 vorgefertigte Agenten auf 7 Autonomiestufen (L0-L6)

Protokolle und Integration

• MCP – JSON-RPC 2.0-Client mit Subprozess-Werkzeugerkennung
• A2A – Agent-zu-Agent-Erkennung, Aufgabenweitergabe, Statusverfolgung
• OpenAI-kompatible REST-API – Chat-Completions, Tool-Aufrufe, SSE-Streaming
• Nachrichtenadapter – Slack, Discord, Matrix, Telegram, WhatsApp, Webhook
• Migrationstool – Import von CrewAI und LangGraph

Infrastruktur

• Tokenökonomie – Wallets, Fuel-Metering, Delegationsverträge, Stufenbeschränkung
• Softwarefabrik – Projekterstellung, Build-Pipeline, Qualitätsgates
• Marktplatz – Ed25519-signierte Pakete mit Verifizierungspipeline
• Weltsimulation – Virtuelles Dateisystem-Sandbox mit Trockenlauf und Risikobewertung
• Kollaborationsprotokoll – Multi-Agenten-Sitzungen mit Abstimmung und Konsens

Gelenkte Selbstverbesserung

• 5-stufige Pipeline – Beobachter, Analyzer, Vorschlagender, Validator, Anwender
• 10 harte Invarianten – Governance-Kernel unveränderlich, HITL Stufe3 erforderlich, Audit-Kettenintegrität
• DSPy/OPRO-Promptoptimierer – Variantengenerierung, Durchsetzung von Sicherheitsschlüsselwörtern, Kosinus-Ähnlichkeitsbewertung
• Konfigurationsoptimierer – 8 einstellbare Parameter mit begrenzten Schrittweitenanpassungen
• Richtlinienoptimierer – Cedar-Richtlinienverfeinerung (kann nur eingrenzen, nie erweitern)
• Verhaltenshülle – Drift Bounds Theorem (D* = alpha/gamma) begrenzt Agentendrift
• Simplex-Wächter – Verifizierte sichere Baseline mit Barrierezertifikat-Umschaltung
• 182 Tests + 7.424 eigenschaftsgenerierte Fälle

Desktop und Lokal zuerst

• Flash-Inferenz – llama.cpp via FFI, GGUF-Laden, spekulative Dekodierung
• 15 LLM-Anbieter – Alle mit echten HTTP-Aufrufen, automatischem Failover
• Sprachpipeline – Push-to-Talk, Whisper-Transkription, Web-Speech-API
• Browserautomatisierung – Playwright-Integration mit URL-Whitelist und Finanzsperre
• Computersteuerung – Bildschirmaufnahme, Eingabeausführung, governance-geregelt ab L4+
• 86 Frontend-Seiten – Vollständige Verwaltungsoberfläche für jedes Subsystem

Flash-Inferenz – Führen Sie jedes Open-Source-Modell lokal aus

Integrierte lokale Inferenz über llama.cpp, die über 60 Modellarchitekturen durch das GGUF-Format unterstützt. Führen Sie Qwen, DeepSeek, Llama, Mistral, Gemma, Phi und mehr aus – alle mit derselben Sicherheitspipeline wie Cloud-Anbieter geregelt.

397B-Modell nachweislich in 32-GB-systemd-Speicherkäfig über mmap-SSD-Streaming ausgeführt. Keine GPU erforderlich.

Jeder Inferenzaufruf durchläuft: Fähigkeitsprüfung, Kraftstoffreserve, Adversarial Arena, PII-Entfernung, Ausgabefirewall, Hash-verketteten Prüfpfad.

Schnellstart

Voraussetzungen

• Betriebssystem: Linux (Ubuntu 22.04+), macOS oder Windows 10+
• Rust: 1.75+ (curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh)
• Node.js: 18+ (nvm install 18)
• Ollama (optional): curl -fsSL https://ollama.ai/install.sh | sh

Bauen und Ausführen

git clone https://gitlab.com/nexaiceo/nexus-os.git
cd nexus-os

# Arbeitsbereich bauen
cargo build --workspace

# Frontend bauen
cd app && npm ci && npm run build && cd ..

# Im Entwicklungsmodus ausführen
cd app && npm run tauri dev

Server-Bereitstellung (Docker)

# Ein-Befehl-Start – bedient UI + API auf Port 8080
docker compose up -d

# Mit lokaler LLM-Inferenz über Ollama
docker compose --profile with-ollama up -d

# Überprüfung
curl http://localhost:8080/health

Siehe docs/DEPLOYMENT.md für Kubernetes/Helm, luftspaltbare und HA-Bereitstellung.

Prüfstatus nach Audit

Unabhängiges Audit abgeschlossen am 31.03.2026. Jede Metrik durch Inspektion des Quellcodes verifiziert.

Tauri-Befehle ..... 675     Agenten ............ 55
Rust-Crates ....... 66      Frontend-Seiten .... 86
Rust-Tests ........ 4.877   Frontend-Tests .... 352
LLM-Anbieter ...... 15      OWASP-Punktzahl .... 10/10
Produktions-TODOs .. 0      Produktions-Stubs .. 0

Sicherheit und Governance

OWASP Agentic Top 10 – Vollständige Abdeckung

Fähigkeitsbasierte Zugriffskontrolle

Agent: coder-agent (L3)
Fähigkeiten:
  file.read(Bereich: /workspace/*), file.write(Bereich: /workspace/*)
  llm.query(Anbieter: ollama, Modell: codestral)
Verweigert:
  network.external, file.write(Bereich: /system/*), process.execute(erhöht: true)
Kraftstoff: 10.000 Einheiten/Sitzung
HITL: Erforderlich für file.delete, process.execute

Projektstruktur

nexus-os/
├── kernel/          110K Zeilen – Governance, kognitiver Kreislauf, Aktuatoren, Prüfung
├── app/src-tauri/     34K Zeilen – 675 Tauri-Befehle über 19 Domänenmodule
├── app/src/           65K Zeilen – 86 React-Seiten, 352 Tests
├── connectors/        23K Zeilen – LLM (15 Anbieter), Nachrichten (6 Kanäle), Web, Soziales
├── crates/            55K Zeilen – Speicher, Kryptografie, Selbstverbesserung, A2A, MCP, Simulation, ...
├── agents/            19K Zeilen – 10 Agenten-Crates + 55 vorgefertigte Manifeste
├── sdk/               10K Zeilen – agentenseitige API, die den Kernel umschließt
├── distributed/        9K Zeilen – P2P, Geisterprotokoll, Mesh
├── protocols/          8K Zeilen – HTTP-Gateway, OpenAI-kompatible API, MCP-Client
├── marketplace/        5K Zeilen – Ed25519-Signierung, SQLite-Registry
├── enterprise/         7K Zeilen – Authentifizierung, Mandantenfähigkeit, Integrationen, Messung, Telemetrie
└── cli/                6K Zeilen – CLI-Werkzeuge, Packager

Dokumentation

Fahrplan

• v10.6.0 – Gelenkte Selbstverbesserung, SOC 2/NIST-Compliance, Docker/Helm-Bereitstellung
• v10.5.0 – Nach-Audit-Härtung: 9,5/10 Audit-Punktzahl, OWASP 10/10
• v10.4.0 – Agentengedächtnis, PQC-Kryptografie, Migrationstool, OpenAI-kompatible API
• v10.3.0 – Vollständiges Audit: 54 Agenten, 655 Befehle, 84 Seiten
• Darwin Core – Darwin’sche Evolutions-Engine mit Adversarial Arena
• Flash-Inferenz – llama.cpp-Integration, 397B-Modell verifiziert
• Docker + Helm-Chart für Server/K8s-Bereitstellung
• SOC 2 Typ II / NIST 800-53 formelle Zertifizierung
• Gelenkte Selbstverbesserung (Krönung – Agenten verbessern das Betriebssystem selbst)
• Forschungsarbeit: formale Verifikation von Governance-Eigenschaften

Lizenz

MIT-Lizenz