v2.24.16 · 290/290 Tests

Die KI-Agent-Runtime
Architektonisch ausgelegt für robuste
Mesh-Infrastruktur

KnotenCore ist eine hochperformante, headless Rust-Runtime und P2P-Mesh-Engine für autonome KI-Agenten. Entwickelt mit Zero-Trust-kryptografischem Peering, Quorum-Governance und sandgeboxten VM-Isolates — angetrieben von strukturiertem JSON-AST.

Auf GitHub ansehen So funktioniert's Engineering Blog

290/290

Aktive verifizierte Tests

Clippy-Warnungen

27+

JSON-RPC-Endpoints

v2.24.16

Zero-Trust-Protokoll

JSON-RPC 2.0 Terminal

// knc_store_diff — Anti-Entropy-Sync mit SHA-256 State-Digests { "jsonrpc": "2.0", "method": "knc_store_diff", "params": { "peer_digest": "7f8a1c9e4b...", "since_timestamp": 1740000000 }, "id": 1 } // → liefert ausschließlich geänderte Key-Deltas statt Full-Store-Flood { "result": { "status": "ok", "in_sync": false, "state_digest": "9b2e4f01ca...", "entries_count": 2, "entries": [ { "key": "agent:7:route", "value": "node-beta", "timestamp": 1740000120 } ] } }

// knc_mesh_revoke_peer — Quorum-gesichert, persistent auf Disk { "jsonrpc": "2.0", "method": "knc_mesh_revoke_peer", "params": { "peer_pubkey": "a1b2c3d4...", "mesh_auth_token": "••••••••" }, "id": 2 } // → gespeichert in revoked_keys.json { "result": { "status": "ok", "revoked": true } }

// knc_swarm_quorum — schließt Evicted/Stale-Peers aus { "jsonrpc": "2.0", "method": "knc_swarm_quorum", "params": { "operation": "shard_rebalance", "mesh_auth_token": "••••••••" }, "id": 3 } // Server erzwingt: Schwellwert = (aktive / 2) + 1 { "result": { "quorum_reached": true, "active_nodes": 5, "quorum_threshold": 3 } }

// JSON-AST: kompilieren + in sandgeboxtem Isolate ausführen { "jsonrpc": "2.0", "method": "knc_compile", "params": { "session_id": "agent-7", "ast": { "Add": [ { "IntLiteral": 21 }, { "IntLiteral": 21 } ] } }, "id": 4 } // → { "result": { "status": "ok" }, "id": 4 }

💡 Neu hier? · KnotenCore einfach erklärt

Was zum Geier ist KnotenCore eigentlich?

Wenn Begriffe wie „CRDT-Anti-Entropy“, „Ed25519-Quorum-Governance“ und „Register-VM“ nach böhmischen Dörfern klingen: Hier ist die 60-Sekunden-Erklärung für Menschen.

KnotenCore Architektur: KI-Planung, geschützte Ausführungs-Sandbox und sicheres Agenten-Schwarm-Mesh

🧠 ➔ 🏗️

1. KI-Modelle planen. KnotenCore baut.

Große Sprachmodelle (wie ChatGPT oder Claude) sind brillante Denker und Planer. Aber man drückt einem Architekten keinen Presslufthammer in die Hand und lässt ihn unbeaufsichtigt auf die Baustelle.

Was KnotenCore macht: Es nimmt die Pläne der KI als strukturiertes JSON entgegen und führt jeden Schritt blitzschnell und kontrolliert aus. Halluzinierte oder verbotene Befehle werden sofort gestoppt.

📦 🛡️

2. Strikte Sandbox-Isolation (Fehlertolerante Ausführung)

KI-Agenten können Fehler machen – Endlosschleifen erzeugen oder unkontrolliert Arbeitsspeicher anfordern.

Was KnotenCore macht: Jeder Agent läuft in einem isolierten VM-Isolate mit festem „Sprit-Budget“ (Gas-Metering) und Speicherlimit. Läuft ein Agent heiß oder überschreitet Kontingente, wird das Isolate sicher beendet – der Host-Server und andere Agenten laufen ungestört weiter.

🐝 🤝

3. Swarm-Governance: Kryptografische Agenten-Koordination

Komplexe Workflows erfordern Agenten-Teams über mehrere Knoten hinweg, die Daten austauschen und Aufgaben übergeben.

Was KnotenCore macht: Agenten kommunizieren über ein P2P-Mesh, in dem jede Anfrage mit Ed25519 signiert und mit Replay-Fenstern validiert wird, um unberechtigte Befehlsinjektionen im Swarm zu unterbinden.

TL;DR KnotenCore ist eine experimentelle, hochperformante Ausführungs-Engine in Rust, mit der autonome KI-Agenten Code ausführen, verteilten State verwalten und in Mesh-Netzwerken mit klaren Speicher- und Ausführungsgrenzen kooperieren können.

⚠️

Wichtiger Hinweis zum Entwicklungsstand: KnotenCore befindet sich im experimentellen Alpha-Zustand (Forschungs- & Entwicklungs-Prototyp). Die kryptografische Mesh-Verifizierung und Sandbox-Isolates sind für Entwicklungs- und Test-Cluster gebaut, ersetzen jedoch keine formale externe Sicherheitszertifizierung. Bitte nicht für ungehärtete, geschäftskritische Produktivsysteme mit sensiblen Daten einsetzen!

Fähigkeiten

Gebaut für autonome Agenten

Jede Schicht ist darauf ausgelegt, Mehrdeutigkeiten zu eliminieren, Grenzen durchzusetzen und adversarialen Mesh-Bedingungen standzuhalten.

🔒

Zero-Trust-Mesh

Ed25519-Envelope-Signierung, 30-Sekunden-Replay-Fenster und Anti-Downgrade-Governance über alle RPC-Endpoints. Authentifizierungs-geschützt bei aktivem Zero-Trust- oder Mesh-Token.

v2.24.16

🗄️

CRDT Anti-Entropy & Diff Sync

In-Memory LWW-CRDT-Store mit deterministischen SHA-256 State-Digests (knc_store_digest) via ring und schlankem Differentiell-Sync (knc_store_diff).

knc_store_diff

⚖️

Zero-Trust Raft-Swarm

Ed25519-signierte Heartbeat-Envelopes mit 30-Sekunden-Replay-Schutz und serverseitigen Anti-Downgrade-Invarianten. Quorum-gesichertes Leader-Failover.

knc_swarm_heartbeat

🗝️

Gossip Revocation Gate

Gesperrte Peer-Keys werden persistiert und bei epidemischer Gossip-Frame-Ingestion proaktiv abgewiesen und entfernt (knc_mesh_peers?action=gossip).

v2.24.14+

📦

Sandgeboxte VM-Isolates

Multi-Tenant-VM-Isolates mit konfigurierbarer IsolateQuota: Gas-Metering, Memory-Watchdog, Call-Depth-Limits und Live-Isolate-Hot-Reloading.

IsolateQuota

🌐

P2P-Mesh & Teleportation

Broker-freie Peer-Discovery, Gossip-Auto-Healing und Live-Isolate-State-Migration über Cluster-Knoten hinweg. Binärer Snapshot → Netz → Wiederaufnahme.

knc_agent_teleport

⚡

AOT-Stack-VM & Batch-Vektor-Opcodes

JSON-AST kompiliert zu flachem Bytecode via AOT-Stack-VM (statt Tree-Walker-Ausführung). Batch-Vektor-Opcodes, Peephole-Optimierung und PGO. (Siehe BENCHMARKS.md)

aether_compiler

🔄

Work-Stealing-Scheduler

Verteilte Task-Queue mit adaptivem CPU-Last-basiertem Work-Stealing über Cluster-Knoten hinweg. Kryptografische Task-Verifikation.

knc_task_steal

🤖

KI-Readiness 20/20

Formale EBNF-Grammatik, Draft-07-JSON-Schema mit additionalProperties: false, Fehlerkatalog mit Self-Healing-Hinweisen und Anti-Pattern-Guide.

llm.md

Sicherheitsmodell

Auf jeder Schicht
gehärtet

Kontinuierliche Sicherheits-Sprints auditieren und schließen Angriffsflächen systematisch. Die Codebase erzwingt strikte Fehlerisolation ohne Panic-Risiko über alle Pfade.

✓
Anti-Downgrade-Governance
Zero-Trust-Modus ist serverseitig fixiert; Client-Downgrade-Flags (z. B. Legacy-HMAC) werden strikt mit -32001 abgewiesen.
✓
Resiliente Transport-Streams
Zero-Panic-Garantie bei FD-Exhaustion im TCP/WebSocket-Server durch isoliertes try_clone()-Fehlerhandling und sauberen Stream-Abbau.
✓
Durchgängige Signaturkette
Ed25519-Signaturen sichern Guest-Isolates, epidemische Gossip-Frames und Raft-Governance-Heartbeat-Envelopes lückenlos ab.
✓
Epidemisches Gossip-Revocation-Gate
Eingehende Gossip-Payloads werden direkt bei der Ingestion gegen die Sperrliste validiert; revozierte Identitäten werden aktiv entfernt.
✓
Deterministische CRDT-Anti-Entropy
Native ring::digest::SHA256 State-Digests ermöglichen Konsistenzprüfungen und übertragen ausschließlich veränderte Deltas.

aether_compiler/src/rpc/handlers/store.rs · compute_state_digest() v2.24.16

pub fn compute_state_digest(&self) -> String { let store = self.entries.lock().unwrap(); let mut keys: Vec<_> = store.keys().collect(); keys.sort(); let mut ctx = Context::new(&SHA256); for key in keys { let entry = &store[key]; let val_hash = digest(&SHA256, entry.value.to_string().as_bytes()); ctx.update(format!("{}:{}:{}:{}\n", key, hex::encode(val_hash), entry.timestamp, entry.writer_id).as_bytes()); } hex::encode(ctx.finish()) } // Deterministischer Anti-Entropy State-Digest mit ring::digest. // Ermöglicht sofortigen differentiellen Mesh-Sync.

API-Referenz

27+ JSON-RPC-2.0-Endpoints

Zero-Trust Ed25519 & HMAC-SHA256 gesichert. Alle Endpoints erreichbar via TCP (Port) oder WebSocket (--ws-port) Transport.

Ausführung & Isolates

knc_compileknc_executeknc_eval_isolateknc_isolate_reloadknc_yield_resumeknc_inspect_state

Agent-Lifecycle

knc_agent_handshakeknc_agent_snapshotknc_agent_restoreknc_agent_teleport

Mesh- & Gossip-Protokoll

knc_mesh_discoverknc_mesh_peersknc_mesh_gossipknc_mesh_pingknc_mesh_metricsknc_mesh_verify_peerknc_mesh_rotate_keyknc_mesh_revoke_peer

Task-Queue & Scheduling

knc_task_submitknc_task_statusknc_task_cancelknc_task_stealknc_task_complete

CRDT-Anti-Entropy-Store

knc_store_putknc_store_getknc_store_syncknc_store_digestknc_store_diff

Swarm-Governance & Raft

knc_swarm_electknc_swarm_rolesknc_swarm_quorumknc_swarm_heartbeatknc_swarm_request_vote

Interne Architektur

Drei-Crate-Workspace

Strikt getrennt, frei von zirkulären Abhängigkeiten. JSON-AST rein, Bytecode raus, Mesh über die Leitung.

Crate / Modul	Beschreibung	Rolle
knoten_core	Schlanke Top-Level-Re-Export-Fassade für nahtlose Workspace-Integration.	Fassade
aether_compiler	Engine-Kern: JIT-Graph-Executor, AOT-Bytecode-Compiler, Stack-VM, 27+ Endpoint Zero-Trust RPC-Server, Mesh-Protokoll, Swarm-Governance.	Engine-Kern
knoten_core_types	Alleinige Wahrheitsquelle für reine Datentypen: `Node`-Enum, `OpCode`, `SimdOp`, `IsolateQuota`. Keine Cross-Crate-Logik-Kopplung.	Typ-Autorität
vm/machine.rs	Register-Stack-VM: ALU, Call-Frame-Stack (MAX 512), Opcode-Ausführung, Memory-Estimator mit vollständiger Stack-Traversierung, IsolateQuota-Durchsetzung.	VM-Kern
vm/isolate.rs	VMIsolate: Pro-Tenant-VM-Instanzen mit konfigurierbarer `IsolateQuota`, Hot-Swap-Code-Reloading, spekulative Shadow-Execution, lokale Heap-Isolation.	Multi-Tenancy
rpc/mod.rs & handlers/	Modularer JSON-RPC-2.0-Dispatcher (TCP + WebSocket). 27+ `knc_*`-Endpoint-Handler. Zero-Trust Ed25519-Signierung, Anti-Entropy-Store, Raft-Governance.	RPC-Transport

Perspektiven & Einblicke

Architektur-Reviews & Engineering-Kultur

Externe Validierung und zentrale Entwicklungsprinzipien der KnotenCore-Runtime.

Grok

@grok · xAI

Antwort an @knotencore

„Twice is accurate. Training clusters maximize scale and throughput. Agent runtimes need isolation, gas metering, and recoverable exhaustion. Snapshot/rollback on isolate limits is the correct primitive for executing untrusted plans safely. The architecture is sound.“

21. Aug. 2026 · Architektur-Review Auf X ansehen ↗

KnotenCore DevLog

Engineering-Kultur · Multi-LLM

🦀🤖

Aus Beitrag #32 · Qualitäts-Invarianten

„Diese Trennung ist mehr als Arbeitsteilung – sie ist strukturelles Misstrauen mit echtem Mehrwert. Ein Modell, das seinen eigenen Code prüft, teilt oft dieselben blinden Flecken, die überhaupt erst zum Fehler geführt haben. Der Wert des zweiten, unabhängigen Modells liegt darin, nichts zu glauben, was sich nicht direkt am Quellcode nachweisen lässt.“

August 2026 · Beitrag #32 Beitrag lesen →

Roadmap

Was kommt als Nächstes

KnotenCore wird inkrementell ausgeliefert. Jeder Sprint wird auditiert, getestet und gepusht — keine Big-Bang-Releases.

Zuletzt ausgeliefert

CRDT-Anti-Entropy-State-Digests (ring::digest) & differentieller Sync (knc_store_diff) · v2.24.16

Ed25519-signierte Raft-Heartbeat-Envelopes & Anti-Downgrade-Härtung · v2.24.15

Persistente Peer-Sperrung (revoked_keys.json) & epidemisches Gossip-Gate · v2.24.14

Hot-Module-Replacement (HMR) & Live-Isolate-Hot-Reloading · v2.23.0

Formale vergleichende Benchmark-Suite (docs/BENCHMARKS.md) · v2.24.0

Zero-Trust Host vs. Guest Architektur & Agent-Orchestrierungs-Leitfaden · v2.24.13

Multi-Modell-Entwicklungsmethodik: Rollentrennung (Architekt · AG · Prüfer) + Rohterminal-Nachweis-Invariante · Sprint 353+

Kommend

WASM-Edge-Mesh — Guest-Isolates über Browser- und Edge-Knoten via WebRTC-Datenkanäle skalieren.

Nativer ARM64-JIT-Target — Native ARM64-Maschinencode-Generierung (ergänzend zum x86_64 JIT).

Byzantine Fault Tolerance (BFT) Evaluierung — Untersuchung von BFT-Konsens für nicht-vertrauenswürdige Multi-Tenant-Swarms.

Verteilte Telemetrie (OTLP) — OpenTelemetry-Tracing für Multi-Hop-Agent-Dispatch und Ausführungsspuren.

Knoten-Package-Registry — Gehostete Registry und Dependency-Resolver für .nod-Bytecode-Programme.

Open Source · MIT-Lizenz

Mit KnotenCore entwickeln

Forken, auditieren, erweitern. PRs mit härteren Testfällen und unabhängigen Benchmarks sind willkommen.

Auf GitHub ansehen Spezifikation lesen Engineering Blog

Hinweis: Die kryptografische Mesh-Verifizierung (lokale Ed25519-Key-Rotation & Peer-Sperrlisten) schützt die Cluster-Kommunikation. Sie ersetzt keine externe professionelle Penetrationsprüfung oder Drittanbieter-Sicherheitsaudit.

Die KI-Agent-Runtime Architektonisch ausgelegt für robuste Mesh-Infrastruktur