Die nxs Open-Source-Suite

Der Datenstand, aus dem deine Agenten arbeiten.

Ein Binary, drei Produkte — flow, memory und chat — auf einem einzigen offline-first CRDT-Substrat. Agenten-nativ, deterministisch, konvergent.

$ curl -fsSL https://nxsflow.com/nxs/install.sh | sh

macOS & Linux · Apple Silicon und x86-64 · signierte, same-origin Updatesnxsflow/nexus-flow

Ein Binary, drei Produkte

Was in der Suite steckt

Alle drei stecken in einem Binary. Einmal installieren — jeder Workspace aktiviert dann nur, was er wirklich braucht.

nxf

flow

das Verzeichnis

Issues, Epics und die Abhängigkeiten dazwischen. ready, blocked und next entstehen bei jeder Abfrage neu aus dem Graphen — nie gespeichert, deshalb kann die Arbeitsliste nicht veralten.

nxm

memory

das Wissen

Dauerhafte Projekt-Fakten unter festen Schlüsseln — ein Fakt wächst an seiner Stelle weiter, statt sich zu vervielfachen, und liegt in jeder Session wieder vor, die ihn braucht.

nxcHeute schon in der Binary — die Anleitungen folgen mit 1.0

chat

das Gespräch

Nachrichten von Agent zu Agent über dasselbe Change-Log — ein Team von Agenten stimmt sich ab, statt sich gegenseitig die Ausgabe abzulesen.

In Aktion

next und blocked — abgeleitet, nicht gespeichert

nxf — Agent-Session

$ nxf next
0001  P1  open  [epic]  Payments revamp
0002  P1  open  [feature]  Design new checkout flow
    ↳ 0001 · Payments revamp

$ nxf blocked
0003  P2  open  [chore]  Migrate billing webhooks
    ↳ blocked by: 0002 (open)

$ nxf next --json[{"archived":null,"assignee":null,"belongs_to":null,"closed_at":null,"closing_comment":null,"completion_criterion":null,"created_at":"2026-06-23T00:00:00Z","defer_until":null,"deleted":null,"description":"Rework the payments stack for v2.","design":null,"due":null,"id":"ab12.0001","parent":null,"priority":"1","priority_label":"P1","status":"open","title":"Payments revamp","type":"epic","type_label":"epic","updated_at":"2026-06-23T00:00:00Z"},{"archived":null,"assignee":null,"belongs_to":"ab12.0001","closed_at":null,"closing_comment":null,"completion_criterion":null,"created_at":"2026-06-23T00:00:00Z","defer_until":null,"deleted":null,"description":"One-page checkout with saved cards.","design":null,"due":null,"id":"ab12.0002","parent":{"id":"ab12.0001","title":"Payments revamp","type":"epic","type_label":"epic"},"priority":"1","priority_label":"P1","status":"open","title":"Design new checkout flow","type":"feature","type_label":"feature","updated_at":"2026-06-23T00:00:00Z"}]
$

Echte, in CI drift-gesicherte nxf-Ausgabe: die bereite Arbeit, die vom Graphen zurückgehaltene Arbeit und dieselbe Abfrage als --json.

Warum so gebaut

Eine Engine, der Agenten vertrauen

Offline-first von Haus aus

Alles liegt in einer lokalen Datenbank — Lesen und Schreiben sind sofort und funktionieren weiter, wenn das Netz weg ist.

Konvergente CRDT-Sync

Jede Änderung wird an ein Change-Log angehängt, nie überschrieben. Gleichzeitige Edits verschiedener Geräte verschmelzen ohne Last-Write-Wins-Datenverlust.

Abgeleitet, nie gespeichert

ready, blocked und next werden deterministisch aus dem Abhängigkeitsgraphen berechnet — die Arbeitsliste ist immer konsistent, nie ein veralteter Cache.

Plugin-deklariertes Vokabular

Item-Typen, Ranking und Präsentation leben in Plugins — ein Issue-Tracker und eine persönliche To-do-Liste sind dabei; eigene lassen sich deklarieren.

Überall --json

Eine deterministische, byte-stabile Maschinen-Schnittstelle auf jedem Befehl — der Vertrag, auf dem Agenten bauen, und der Maßstab der ganzen CLI.

Ein Binary, ein Substrat

flow, memory und chat teilen eine lokale Datenbank, eine Sync und ein Change-Log — Plan, Gedächtnis und Nachrichten eines Agenten konvergieren zu einer Wahrheit.

Changelog

Neu

0.66.0

2026-08-24

Hinzugefügt**`nxf next` liest sich wie eine Liste, die ein Mensch überfliegen kann — und lässt sich kürzen, ohne darüber zu schweigen.** Auf einem echten Terminal steht der Ticket-Titel fett: das Einzige, wonach man wirklich sucht, und bisher genauso schwer wie die Id davor. Id und `↳`-Epic-Zeile sind gedämpft, und die Priorität ist entlang einer einzigen Rampe eingefärbt, von Deep Ember über Ember und Flame hinunter zu Graphit — die Gewichtung ist damit sichtbar, ohne das Label zu lesen. Die Rampe bildet auf den kanonischen ORDINALWERT der Priorität ab, nicht auf ihren Namen; sie stimmt deshalb genauso unter einem Plugin, das seine Stufen jetzt/bald/später nennt. `nxf next --limit <n>` zeigt nur den Kopf der Liste und kürzt nie stillschweigend: über einer gekürzten Liste steht `showing 15 of 180`, und unter `--json` verpackt die Option die Datensätze als `{"items": [...], "total": 180}`, damit ein Konsument die echte Gesamtzahl liest, statt sie aus der Länge des Arrays zu erschließen. Das Limit greift zuletzt, nach `--sort` und nach `--label` — eine gefilterte Liste weist also aus, wie viel Ihres Filters Sie sehen. Ohne `--limit` ist der Befehl unverändert vollständig, und seine `--json`-Ausgabe bleibt dasselbe blanke Array. Sonst ändert sich nichts: `--json`, eine Pipe, CI und der `prime`-Kontext eines Agenten bekommen weiterhin dasselbe schlichte ASCII, Byte für Byte, ohne jede Escape-Sequenz, und `NO_COLOR` / `TERM=dumb` behalten das Gewicht und lassen die Farbe weg.
Hinzugefügt**`nxm guide` — der Speicher hat jetzt eine Dokumentation.** Fünf Anleitungen, auf Deutsch und Englisch, in der Binary mitgeliefert und auf der Doku-Seite veröffentlicht: eine Einführung, die Grundbegriffe (Schlüssel und Auto-Schlüssel, Kategorie/Reichweite/Verweise, die Abrufregel, die entscheidet, wo eine Erinnerung gelesen wird, die Lesereihenfolge, der umkehrbare Grabstein), die vollständige Befehlsreferenz mit jeder `--json`-Form, die `memory_*`-MCP-Werkzeuge samt dem, was `nxs prime` beisteuert, und wie man einen bestehenden Claude-Speicher übernimmt. Bisher hatte `nxm` `--help` und sonst nichts.
Hinzugefügt**`Engine::withdraw`** — eine einbettende Anwendung kann eine Beauftragung zurücknehmen, die noch hinter der Arbeitskopie geparkt ist; derselbe enge Fall, den `nxc withdraw` abdeckt. Die Naht gab auf einer Sende-Quittung längst `queue_position`/`queued_behind` heraus („nicht gestartet, 3. in der Reihe"), ohne einen Aufruf, der darauf antwortet. Das ist damit geschlossen.
Geändert**Eine Sitzung kann nicht mehr enden, ohne die geschuldete Antwort zu geben und ohne dass es jemandem auffällt.** Wer ohne Antwort auf seinen Faden endet, bekommt den Zug zurück und wird erinnert — einmal, mit dem konkreten Faden, beiden Arten einen Zug zu beenden, und jeder von ihm beauftragten Runde, die noch offen ist —, bevor der Sidecar in seinem Namen etwas postet. Die meisten antworten dann. Wer erinnert wurde und erneut stumm endet, wird als Eskalation zurückgegeben; `escalated: true` in `nxc status` sagt dem Aufrufer damit, dass es kein Ergebnis gibt und jemand entscheiden muss. Eine Eskalation ist jetzt in dem Text erkennbar, den die empfangende Sitzung ZUERST liest — auf allen drei Wegen, die sie nehmen kann (Kanal-Durchreichung, 1:1-Wiederaufnahme, Quorum-Weckruf): was es ist, dass die Arbeitskopie währenddessen gehalten wird, und was erwartet wird. Das Kennzeichen allein half nicht, denn ein Agent liest die Nachricht, die ihn geweckt hat, nicht `nxc status`. Und jede Sitzung, die eine Antwort schuldet, erfährt in ihrem Systemprompt, dass ihr Zug auf genau eine von zwei Arten enden muss: `nxc reply --thread <id> "<Ergebnis>"` oder `nxc reply --thread <id> --escalate "<was im Weg steht>"`. Diese Pflicht erreicht auch eine Persona, die `prime: false` deklariert — eine Deklaration kann die eine Regel, auf die sich die Maschinerie verlässt, also nicht weglassen.
Geändert**Das Board sagt, worauf es wartet.** `nxc status` bekommt zwei Kennzeichen am Vorgang: `needs_decision` (irgendwo unter dieser Wurzel wurde eine Aufgabe zurückgegeben und niemand hat sie aufgenommen — neben `awaiting_human` zu lesen, das genauso aussieht und das Gegenteil bedeutet) und `holds_working_tree` (irgendwo darunter wird die Arbeitskopie gehalten, Sie wissen also, ob Sie überhaupt nachsehen müssen). `nxc tick` unterscheidet jetzt eine erledigte Runde, deren einziger verbleibender Blocker eine lebende Sitzung ist, und meldet `waiting_for_a_session` statt `not_due` — der Unterschied zählt, denn genau das prüft keine Uhr nach, und dieses Verb ist der Weg heraus. Und eine Runde, deren sämtliche Beauftragungen zurückgenommen wurden, zählt nicht mehr als offener Vorgang: `nxc withdraw` entlastet jetzt auch den genannten Faden, statt ihn auf einen Betreuer warten zu lassen, dem man gerade die Runde weggenommen hat.
Behoben**Ein Schritt, der die Arbeitskopie exklusiv beansprucht, endet jetzt mit dem Prozess seiner Sitzung, nicht mit dem Eintreffen seiner Antwort.** Ein Mitglied eines `flow: sequential`-Kanals, das geantwortet hat und weiterarbeitet, ließ bisher den nächsten Schritt in dieselbe Arbeitskopie starten: in einem echten Lauf gemessen, antwortete ein Coder um 00:16:33 und editierte bis 00:34:27 weiter, während der nächste Schritt seit 00:16:36 lief. Sitzungen melden ihr Ende jetzt selbst — `nxc session ended`, aufgerufen vom Abbau des Agent-Sidecars, und `Engine::session_ended` für einen Wirt mit eigener Laufzeitumgebung —, und wo diese Meldung nie eintrifft, antwortet die Prozessprüfung des Workers beim nächsten Mal, wenn überhaupt jemand fragt. **Keine Uhr prüft das nach:** das deklarierte `timeout:` eines Kanals ist eine Frist für eine *Antwort*, und wer geantwortet hat, hat geantwortet. Geht die Meldung verloren (ein vor dem Abbau getöteter Sidecar, ein älteres `nxc`, eine Wirtslaufzeit, die `Engine::session_ended` nie verdrahtet), wartet die Runde, bis jemand `nxc tick --thread <id>` ausführt — was jetzt genau das sagt, statt „nichts zu tun". Dieser Abbau ist selbst zeitlich begrenzt: eine Erinnerungsrunde von fünf Minuten und ein Zeitlimit von dreißig Sekunden auf jeden `nxc`-Aufruf, den er macht. Denn er läuft in genau dem Prozess, auf dessen Ende ein exklusiver Kanal wartet — ein Aufruf, der nie zurückkommt, hält eine Arbeitskopie und nicht bloß einen Prozess. Kanäle ohne exklusiven Anspruch auf die Arbeitskopie sind unverändert.
Geändert**Für alle, die nexus-flow als Rust-Bibliothek einbetten: dieser Sprung ist rein additiv — neuen Tag pinnen, sonst nichts ändern.** Über die ganze Spanne haben die drei konsumierten Oberflächen (`nexus-flow-facade`, `nexus-chat`, `nexus-memory`) nur hinzugewonnen: `Engine::withdraw` nimmt eine Beauftragung zurück, die noch hinter der Arbeitskopie geparkt ist; `Engine::session_ended` lässt einen Wirt mit eigener Agent-Laufzeit das Ende einer Sitzung melden, mit `Worker::session_is_running` als Rückfallantwort, wo diese Meldung ausbleibt; `StatusOperation` trägt die zwei neuen Kennzeichen am Vorgang; und die Leseschicht von flow bekam `truncate_next` samt seinem Ergebnis `NextPage` — der eine Mechanismus hinter `nxf next --limit` und der Kürzung in `prime`. Nichts wurde entfernt, umbenannt oder umtypisiert; `cargo-semver-checks` bestätigt das gegen v0.63.0 für alle drei Pakete. Das eine, was Sie bei der Gelegenheit verdrahten sollten, ist `Engine::session_ended`: ohne es fällt ein Kanalschritt mit exklusivem Anspruch auf die Arbeitskopie auf die Prozessprüfung zurück und wartet darauf, dass jemand `nxc tick` ausführt. Die genaue Form jedes einzelnen Schritts steht in den Einträgen je Version auf der Releases-Seite.

0.63.0

2026-08-22

Hinzugefügt**`nxc` — Ihre Agenten reden miteinander.** Das ist die Überschrift über allem seit 0.35.0. Sie deklarieren, wer Ihre Agenten sind und wo sie reden, in `<Projektwurzel>/.nxs-personas/`: eine YAML je Persona (Prompt, Modellklasse, Werkzeuge, wen sie ansprechen darf) und eine `channels.yaml` für die Räume, in denen sie sich treffen. Dann gibt es zwei Verben. `nxc send --to <Persona|Kanal>` eröffnet ein Gespräch und startet, wer am anderen Ende steht; `nxc reply --thread <id>` beantwortet eines. Alles andere — wer wartet, was gesagt wurde, wo eine Operation steht — wird gelesen, nicht getippt.
Hinzugefügt**Ein Kanal ist eine Deklaration, und die Deklaration ist der Ablauf.** Schreiben Sie seine Mitglieder hin, und er fächert zu ihnen auf; ergänzen Sie `expects:`, und er wartet auf ein Quorum; ergänzen Sie `timeout:`, und ein verstummtes Mitglied gibt die Runde frei, statt sie ewig zu halten. `on_complete:` entscheidet, was zurückkommt — jede Antwort, wie sie steht, oder eine gefaltete Zusammenfassung. `flow: sequential` macht aus der Mitgliederliste eine Reihenfolge, ein Kanal IST damit ein Ablauf: dieselbe Deklaration, ein Schritt nach dem anderen. Ein Kanal kann außerdem `public` sein — die Vordertür eines Projekts, über Projektgrenzen hinweg lesbar und ansprechbar.
Hinzugefügt**`nxc status` — wo eine Operation steht.** Eine Operation ist jetzt ein Fadenbaum: Ihre Frage, die Runde, die sie eröffnet hat, die Runde, die jene eröffnet hat. `nxc status` liest diesen Baum von der Wurzel abwärts, über jede Kanalgrenze, und sagt je Faden, wer noch eine Antwort schuldet, ob ein Fenster abgelaufen ist und welche Sitzung daran arbeitet. `awaiting_human` markiert die eine Stelle, an der ein Mensch handeln muss. Wer eine Operation eröffnet hat, kann außerdem jede Nachricht darin lesen, in welchem Kanal ein Agent sie auch eröffnet hat.
Hinzugefügt**Eine Kette je Arbeitskopie.** Eine Persona oder ein Kanal mit `working_tree: exclusive` bekommt die Arbeitskopie und das Build-Verzeichnis für die Dauer ihrer Aufgabe allein; eine zweite Kette, die kollidieren würde, wartet, statt ihren Build gegen dasselbe Zielverzeichnis laufen zu lassen. Der Schutz wird abgeleitet, nicht wiederholt: deklarieren Sie ihn an der Persona, die baut, und jeder Kanal, in dem diese Persona deklariertes Mitglied ist, gilt ebenfalls als schützenswert.
Hinzugefügt**Zwei Dinge, die ein Agent außer einer Antwort sagen kann.** `nxc reply --escalate "<Grund>"` heißt „das kann ich nicht ausführen" — es beendet den Zug, wird nie in eine Zusammenfassung gefaltet und reist eine Ebene nach oben, statt in der Runde zu sterben, in der es gesagt wurde. Und `nxc withdraw --thread <id>` nimmt eine Beauftragung zurück, die noch auf die Arbeitskopie wartet: es hat nichts begonnen, also geht nichts verloren.
Hinzugefügt**Agenten-Sitzungen hinterlassen einen Verlauf, und der ist begrenzt.** Der normalisierte Strom jeder Rollensitzung — Text, Denkschritte, Werkzeugaufrufe samt Ergebnissen und alles, was Subagenten dabei taten — ist mit `nxc transcript show <Sitzung>` lesbar. Verläufe sind gerätelokal und werden nie synchronisiert; sie werden 30 Tage nach dem letzten Schreibvorgang aufbewahrt und wachsen damit nicht mehr unbegrenzt.
Hinzugefügt**Anleitungen, offline, in der Binary.** `nxc guide`, `nxm guide` und `nxf guide` liefern je die erzählende Dokumentation ihres Bausteins — was er ist, was Sie tippen, was Sie deklarieren und was das alles einhegt; `nxs guide` liest die ganze Suite auf einmal. Kein Netz, kein Browser. Jeder darin gezeigte Befehl wird gegen den Testkorpus ausgeführt, eine Anleitung kann also keinen Aufruf zeigen, den es nicht gibt.
Hinzugefügt**Projektwissen ist jetzt eine Datei.** `NEXUS_MEMORY.md` in der Workspace-Wurzel ist eine erzeugte Projektion des `nxm`-Speichers, damit der Kontext auch für einen Leser ohne installiertes nexus-flow erhalten bleibt — ändern Sie sie mit `nxm remember` / `nxm forget`, nie von Hand; `nxm doc --check` meldet Abweichungen. Erinnerungen tragen Kategorie, Reichweite (dieser Workspace oder überall), die Board-Items, um die es geht, und eine Lesereihenfolge; `nxs prime` übergibt sie einer Sitzung in dieser Reihenfolge statt alphabetisch. `nxm migrate` löst einen Workspace von einer handgepflegten `CLAUDE.md`.
Hinzugefügt**Sync läuft von selbst — und auf Ihrem eigenen Postgres.** `nxs sync daemon` hält jeden gebundenen Workspace fortlaufend synchron statt nur auf Zuruf, und `nxs sync bind` braucht kein `--create` oder `--join` mehr: ohne Flags aufgerufen leitet es die Stream-Id deterministisch ab. Der `nxf-relay` in jedem Release-Archiv kann jetzt ein Postgres benutzen, Supabase eingeschlossen — Sie können den Bus also selbst betreiben.
Hinzugefügt**Eine Anwendung kann das alles einbetten.** Die Handle der Chat-Engine trägt die Rollen-Laufzeit, nicht nur das Messaging: eine App öffnet eine Handle für ihre Lebensdauer und liest und schreibt darüber — mit denselben Ableitungen und denselben Ablehnungen wie die Kommandozeile; ein Differenztest vergleicht beide Nähte Byte für Byte. Ein Wirt kann außerdem seine eigene Agenten-Laufzeit mitbringen statt der mitgelieferten; so dockt ein entfernter oder containerisierter Executor an.
Geändert**Deklarationen liegen jetzt in `.nxs-personas/`**, nicht mehr in `roles/`. Wer Ihre Agenten sind und wo sie reden, steht in einem Ordner in der Projektwurzel: eine YAML je Persona plus `channels.yaml`. Den alten Ordner liest nichts mehr.
Geändert**`nxc` hat einen Weg, ein Gespräch zu beginnen, und einen, es zu beantworten.** `send --to` eröffnet einen Faden und startet immer eine frische Persona-Sitzung; `reply --thread` postet in einen bestehenden und setzt die Sitzung fort, die er schon hat. Der Aufruf entscheidet, nicht die Deklaration. Die Optionen, die daneben standen — `--kind`, `--priority`, `--disposition`, `--model`, `--deadline` — sind weg: was eine Nachricht ist und wie lange eine Runde warten darf, wird einmal am Kanal deklariert statt bei jedem Aufruf neu beantwortet.
Geändert**Die Release-Notizen beantworten „ändert das den Bibliothekskontrakt?".** Jeder Eintrag, der eine konsumierte Oberfläche berührt, trägt ein ausdrückliches `facade:`-Urteil — `changed` oder `breaking` — und die Notizen rendern dafür einen eigenen Abschnitt zum Facade-Kontrakt. Ein einbettender Konsument entscheidet Nachprüfung oder Durchwinken am Feed statt am Diff.
Entfernt**Die Befehlsgruppe `nxc workflow` ist weg, und mit ihr die Run-Engine dahinter.** `workflow start`, `step done`, `status`, `list` und `liveness` gibt es nicht mehr, und den gespeicherten Run-Datensatz auch nicht. Ein Kanal deklariert jetzt seinen Ablauf, `send --to <Kanal>` startet ihn, und `nxc status` ist die Stelle, an der man den Stand einer Operation liest. Ohne Nachfolger bleibt allein die Schritt-Lebendüberwachung — ein benannter Verlust, kein Versehen.
Entfernt**Ein Kanal ist jetzt eine Deklaration, oder er ist nichts.** Die Verben, die einen undeklarierten Kanal anlegten oder ansprachen, sind weg: `nxc ask` und die ganze Gruppe `nxc channels` (`create`, `dm`, `join`, `leave`, `list`, `public`). Deklarieren Sie den Kanal und benutzen Sie `send --to <Name>`; die Deklaration trägt, wer gefragt wird und was erwartet wird — genau das, was `ask --expect` und `channels create` vorher je Aufruf sagten. Der Deklarationsschlüssel `member_session` ist ebenfalls entfallen: wann eine Persona fortgesetzt wird, entscheidet der Aufruf.
Entfernt**Der alte Auslieferungs-Origin `nxf.nxsflow.com` ist endgültig abgeschaltet.** Downloads, `install.sh` und `nxs self-update` laufen alle über `https://nxsflow.com/nxs`. Eine Installation, die noch auf den alten Host zeigt, kann sich nicht selbst aktualisieren und muss einmal über den aktuellen Install-Befehl neu installiert werden.
Behoben**Zwei Prozesse auf einem Workspace verlieren einander die Schreibvorgänge nicht mehr.** Die logische Uhr, die zwei parallel laufende `nxs`-Aufrufe fortschreiben, ist unter Nebenläufigkeit jetzt korrekt — ein Schreibvorgang während eines anderen geht nicht mehr stillschweigend verloren. Außerdem können Ops nicht mehr ohne Autor geschrieben werden: ein nicht gesetzter Akteur wird abgelehnt, statt als niemand festgehalten zu werden.
Behoben**Eine Runde endet jetzt, wenn sie wirklich geendet hat.** Die Antwort, die eine Tafel vollständig macht, ist die, die es tatsächlich getan hat; eine Antwort erledigt den Zug, den sie beantwortet, statt das ganze Leben des Fadens; und ein Schritt, dessen Fenster mitten in einem geordneten Ablauf ablief, hält nicht mehr alles dahinter an. Ein lang laufender Agent geht nicht mehr an der Spawn-Tiefe aus, nur weil er ein Gespräch führt, und ein Kanal, der im selben Moment fertig wird, in dem sein Zeitgeber feuert, startet nicht mehr zwei Zusammenfasser für eine Runde.
Behoben**Eine Agenten-Sitzung startet, bleibt einzeln und verliert ihre Antwort nicht.** Auf macOS starb bisher jede gespawnte Persona-Sitzung an der Authentifizierung; sie startet jetzt. Eine interne Sitzung führt genau einen Prozess — ein Wecken, das eintrifft, während diese Sitzung noch arbeitet, wird abgelehnt und gemeldet, statt einen zweiten Agenten im selben Arbeitsverzeichnis zu starten, wo beide einander die Änderungen überschrieben. Eine Sitzung, die an einem Fehler stirbt, ist maschinell von einer beantworteten unterscheidbar, und ein fehlgeschlagener Verlaufsschreibvorgang kostet nicht mehr den Zug.
Behoben**Sync bringt zu Ende, was es beginnt.** Ein Pull beendet einen Durchlauf nicht mehr, weil eine Seite leer oder kürzer als angefordert zurückkam — er endet, wenn das Relay sagt, dass nichts mehr da ist. Eine Stream-Id mit `/`, `#` oder `?` erzeugte bisher einen 404 oder eine still abgeschnittene Id, statt zu synchronisieren. Und das Relay trägt jetzt Umschlagfelder weiter, die es selbst nicht versteht — ein neuerer Client und ein älteres Relay arbeiten damit weiter zusammen.
Geändert**Für alle, die nexus-flow als Rust-Bibliothek einbetten: das ist ein Bruch, aber EINE Migration, nicht achtundzwanzig.** Die Handle der Chat-Engine hat sich auf eine kleine, bewusste Oberfläche gesetzt — sieben lesende Verben, zwei schreibende, und die Rollen-Laufzeit flach daneben — und der Kontext je Aufruf trägt nur noch, wer aufruft. Deklarationen werden aus dem Workspace-Ordner gelesen statt injiziert. Konkret über die ganze Spanne: die Worker-Naht änderte ihre Form, `Engine::ask`/`channel_open`/`role_trigger`/`role_resume`/`send`/`reply` und zehn Lesezugriffe entfielen oder wurden ersetzt, `RoleDecl.address_book` wurde ein `Option`, `channel::declared_visibility` ging in `declared_policy` auf, und `timer::AtTimer` ist kein Unit-Struct mehr. Per Git-Tag pinnen, einmal migrieren, und die Einträge je Version auf der Releases-Seite lesen, wenn Sie die genaue Form eines einzelnen Schritts brauchen.

0.35.0

2026-07-29

Hinzugefügt`nxf recap` — eine Rückschau auf das zuletzt Erledigte (jüngster Abschluss zuerst, inkl. archivierter Abschlüsse), mit `--limit` (Standard 10), `--since <Datum>` und `--json`. Dieselbe Recency-Sicht erscheint jetzt auch als Abschnitt „Recently Closed" in `nxf prime`, sodass eine neue Session auf einen Blick sieht, was gerade fertig wurde. Getrennt von `nxf closed` (der Lane, ohne archivierte), die unverändert bleibt. Facade: ergänzt `read::recap()` (die geteilte Recency-Abfrage — volle, ungekappte Records), die geteilten Notiz-Helfer `read::truncate_notes` / `read::recap_note` sowie ein Feld `recently_closed` an `PrimeReport` (dessen `--json` erhält ein gespiegeltes Array `recently_closed`). Das neue `PrimeReport`-Feld bricht erschöpfende Struct-Literale — wer `PrimeReport` direkt konstruiert, muss das Feld ergänzen; zum Lesen ist keine Änderung nötig.
Hinzugefügt`nxs mcp install` erkennt jetzt **Amazon Quick** (das umbenannte Amazon Q Developer) als Install-Host und schreibt den gemeinsamen `mcpServers`-Eintrag in dessen globale Konfiguration unter `~/.aws/amazonq/mcp.json` — automatisch erkannt wie die anderen Hosts oder gezielt per `--host amazon-quick`. Eine **Multi-Workspace-Registry** (`~/.nexusflow/workspaces.toml`) lässt einen MCP-Host Boards per Name statt per Pfad finden: `nxs mcp install --workspace <pfad>` registriert den angehefteten Workspace, das neue `list_workspaces`-Tool (und der Befehl `nxs mcp workspaces`) liefern die deterministische `{name, path}`-Liste, und ein Host reicht einen gelisteten Pfad über den Per-Call-`workspace`-Override eines beliebigen Tools weiter — Auswahl eines anderen Boards, ohne dessen Ort zu kennen.
Hinzugefügt`nxc` erhält die Role-Runtime: `roles/*.yaml`-Deklarationen, `send --role`/`reply`, die als Folge einer Nachricht eine echte Claude-Agent-SDK-Session (Node-Sidecar) starten, ambiente Caller-Auflösung, ein internes Session-ID-Mapping und Rückfrage-Resume — eine Rolle kann zurückfragen, ohne dass die Aufgabe totläuft.
HinzugefügtAgenten-Transkripte: Was eine Rollen-Session tatsächlich getan hat, wird jetzt aufgezeichnet und ist lesbar. Bisher wurden nur die fertigen **Nachrichten** einer Rolle aufbewahrt — die Überlegungen, die Tool-Aufrufe samt Ergebnissen und alles, was ein beauftragter Subagent unterwegs getan hat, wurden verbraucht und mit dem Ende der Session verworfen; eine überraschende Antwort ließ sich deshalb nie zu ihrem Zustandekommen zurückverfolgen. Das vollständige Agenten-Transkript jeder Rollen-Session wird jetzt während des Laufs erfasst und dauerhaft gespeichert: Assistenz-Text, jeder Tool-Aufruf mit seinem Ergebnis und — der Teil, der üblicherweise verloren geht — die komplette Unter-Zeitleiste jedes von der Rolle gestarteten Subagenten, verschachtelt unter dem Schritt, der ihn gestartet hat. Abrufbar mit `nxc transcript show <session>` als eingerückte Zeitleiste oder als JSON für Werkzeuge; dieselbe Sicht steht Apps, die nexus-chat einbetten, direkt im Prozess zur Verfügung. Transkripte bleiben auf dem Rechner, der sie erzeugt hat (sie beschreiben eine lokale Session, werden also nie zu Peers synchronisiert und blähen das gemeinsame Log nicht auf), und ein mitten im Lauf geschriebenes Transkript zeigt weiterhin alles, was es hat, statt Teilbelege zu verbergen. Zwei besonders lange Felder werden beim Erfassen gekürzt, damit ein einzelner Zug den Datensatz nicht dominiert: ein Denk-Block wird bis 4000 Zeichen, ein Tool-Ergebnis bis 8000 Zeichen aufbewahrt, jeweils mit einem Hinweis am Ende, wie viel abgeschnitten wurde. Alles andere — auch die Eingabe eines Tool-Aufrufs, wie groß sie auch ist — wird vollständig gespeichert. Eine ehrliche Einschränkung: Das **erweiterte Nachdenken** des Modells ist noch nicht Teil des Transkripts. Die Aufzeichnung dafür ist gebaut und greift, sobald es verfügbar wird — aber das Claude Agent SDK gibt Denk-Blöcke derzeit nicht an ein Programm heraus, das es so ansteuert wie nexus-chat. Ein Transkript zeigt heute also, was der Agent getan und gesagt hat, nicht, was er dabei überlegt hat.
GeändertEin Workspace kann jetzt **mehrere benannte Workflows** gleichzeitig deklarieren: neben der bisherigen einzelnen `roles/workflow.yaml` können beliebig viele weitere Workflows unter `roles/workflows/*.yaml` liegen (der `name:` jeder Datei muss über die gesamte Menge hinweg eindeutig sein). `nxc workflow start` erhält einen echten `--name`-Selektor: bei genau einem deklarierten Workflow bleibt er optional und wählt ihn automatisch, wie bisher; sind mehrere deklariert, wird `--name` zur Pflicht — sowohl ein fehlender als auch ein unbekannter Name scheitern mit einem Validierungsfehler, der alle verfügbaren Namen auflistet. `nxc prime`/ `nxs prime` listet jetzt jeden deklarierten Workflow unter dem pluralen JSON-Schlüssel `workflows` (er ersetzt den bisherigen singulären Schlüssel `workflow`) und validiert jeden einzeln — ein fehlerhafter Workflow wird aus der Übersicht ausgeschlossen, statt die ganze Sitzung zu blockieren, genau wie es bei Rollen und Channels bereits der Fall war. Ein Workspace mit ausschließlich der alten `roles/workflow.yaml` und ohne `roles/workflows/`-Verzeichnis funktioniert weiterhin unverändert, ganz ohne `--name`-Flag — diese Abwärtskompatibilität ist durch einen eigenen Regressionstest abgesichert.
Hinzugefügt`nxf show <id>` hängt jetzt am ganz Ende der Ausgabe einen auffälligen, wörtlichen Hinweis an, wenn das Item Elternteil(e) hat: "This item has the following parents: <ids>. URGENT RECOMMENDATION: ALSO READ THESE ITEMS TO GET THE COMPLETE PICTURE!!!" — ein Stupser, damit ein Agent, der ein Kind-Ticket liest, auch das Elternteil (oft ein Epic) zieht, das die Spezifikation, globale Randbedingungen und den Designkontext trägt, von denen das Kind ausgeht. Einmalig im Engine-/ Facade-Lese-Layer berechnet (`ShowRecord::parents` + `parents_notice`), sodass das menschenlesbare `nxf show`, `--json` (`parents`/`parents_notice`, sparsam — nur vorhanden, wenn das Item Elternteil(e) hat) und jeder andere Konsument (MCP, Embedder) denselben Text rendern. Beschränkt auf Zugehörigkeits-/Containment-`parent`-Kanten, nicht `contributes_to`.
HinzugefügtRole Runtime v2: Rollen werden automatisch mit korrekter `nxc`-Nutzung und ihrer eigenen Aufgabenbeschreibung geprimt, sodass eine Trigger-Nachricht nur noch die Aufgabe trägt, nie mehr den Rollen-Prompt; `send --role <Handle>` öffnet automatisch die DM mit einer Partnerrolle und startet eine frische Session, kein manueller `channels dm`-Schritt mehr nötig; der verschachtelte `send --role`-Aufruf einer Rolle erreicht den Sidecar zuverlässig über mehrere Hops hinweg; ein YAML-deklarierter Team-Workflow mit Validierungs-Prompts pro Übergang steuert eine PM/Coder-Schleife ohne fest verdrahtete Orchestrierung; und ein 4-Rollen-Review-Quorum (General + Code-Qualität/Test-Qualität/Integrität) weckt den PM erst, wenn jeder Reviewer geantwortet hat — verdrahtet über die bestehende Thread-Quorum-Mechanik. Rollen-Sessions laufen jetzt zusätzlich mit `settingSources: []` (SDK-Isolationshärtung): eine gestartete Rolle ignoriert die eigene `.claude/`-Plugin-, Skill- und Hook-Konfiguration des Operators/Projekts, ihr Verhalten hängt also nur noch von der eigenen Rollen-YAML ab.
HinzugefügtRole Runtime v3: `nxc` wird zum Orchestrator. Eine neue deklarierte **Channel**-Primitive ist typisierte Gruppenkommunikation — wer antworten soll, ob Antworten nur für den Anfragenden oder für alle Mitglieder sichtbar sind, und ein einmaliges Timeout — und `nxc` **verteilt** einen Channel-Aufruf jetzt tatsächlich an jedes deklarierte Mitglied (außer den Absender); das schließt die v2-Lücke, in der eine Rolle nur deklarieren konnte, wer antworten soll, ohne je jemanden auszulösen — genau das verursachte das Deadlock "PM öffnet das Board und wartet für immer". Der Abschluss eines Channels liefert entweder die rohen Antworten unverändert aus (`pass_through`) oder startet eine ephemere Synthesizer-Session, die alle Antworten liest und ein zusammengefasstes Verdikt postet (`summarize`), sodass keine Rolle mehr von Hand zusammenfassen muss. Darauf setzt ein expliziter **Workflow-Orchestrator** auf (`nxc workflow start`/`step done`/`status`/`tick`): ein deklarierter Schrittgraph mit verzweigenden und rückführenden Übergängen und einer harten Zyklus-Obergrenze, sodass der Kontrollfluss eines Teams jetzt `nxc` selbst gehört statt als Prosa über Rollen-Prompts verstreut zu sein; jeder Schritt kann die vorherige Session einer Rolle fortsetzen oder eine frische starten, sodass eine später im selben Lauf wiederkehrende Rolle dort weitermacht, wo sie aufgehört hat, wenn der Schritt das vorsieht. Das Beispiel-Coding-Team (PM/Coder/4-Rollen-Review-Quorum) wurde mit einem Merge-Verdikt pro Reviewer und Anti-Abnick-Disziplin bei Reviews gehärtet. Alles wurde Ende-zu-Ende mit echten (nicht gemockten) Claude-Agent-SDK-Sessions verifiziert. Nach einem unabhängigen Pre-PR-Review gehärtet: `nxc workflow step done` prüft jetzt, dass der Aufrufer tatsächlich die an den aktuellen Schritt des Laufs gebundene Rolle ist (ein `channel:`-Zielschritt kann nur über sein eigenes Quorum/seine eigene Synthese abgeschlossen werden, nie über einen direkten Aufruf); die Rücksende-Adresse eines Workflow-Laufs wird gegen die eigene Aufzeichnung der Engine geprüft statt als bloße Zeichenkette vertraut; eine deklarierte `visibility: requester_only` wird jetzt bei `nxc threads show`/der Embedding-Facade tatsächlich durchgesetzt (bisher wurde sie zwar validiert und gespeichert, aber nie angewendet); der Prompt des `summarize`-Synthesizers grenzt die nicht vertrauenswürdigen gesammelten Antworten jetzt klar ab, und sein Outcome-Token wird aus der letzten passenden Zeile geparst; eine veraltete Antwort kann einen bereits weitergerückten Lauf nicht mehr erneut voranbringen; und eine fehlerhafte Channel-Deklaration (z. B. `summarize` ohne `summary_prompt`) wird jetzt am Verwendungsort zurückgewiesen, statt still zu degradieren.
Hinzugefügt`nxf-relay` kann jetzt auch DynamoDB als dauerhaftes Speicher-Backend nutzen, zusätzlich zu den bestehenden SQLite- und Postgres-Optionen. Mit `--features dynamodb` bauen und `NXF_RELAY_BACKEND=dynamodb` setzen; `NXF_RELAY_DDB_TABLE` / `NXF_RELAY_DDB_REGISTRY_TABLE` benennen die (extern bereitgestellten) Ops- und Prefix-Registry-Tabellen — beide mit Standardwert, sodass nichts zwingend erforderlich ist — und `NXF_RELAY_DDB_ENDPOINT` / `NXF_RELAY_DDB_REGION` überschreiben Endpoint und Region, etwa für DynamoDB Local oder ein Self-Hosting-Setup.

0.30.0

2026-07-17

HinzugefügtEmbedding-API: Das langlebige Engine-Handle stellt jetzt `closed_value`, `deferred_value`, `archived_value` und `blocked_value` bereit — die Lanes `closed`/`deferred`/`archived`/`blocked` als dieselben kanonischen `--json`-Records wie die CLI, jeweils mit der spärlichen Plugin-`custom`-Map (und `blocked_value` mit seiner Liste offener `blockers`). Ein neues `custom_fields_bulk` liefert die deklarierte `custom`-Map für viele IDs in einem Read, um Custom-Werte an Zeilenmengen zu joinen, die das Handle nicht selbst projiziert (insbesondere die `next`-Liste von `prime`). In-Process-Consumer können damit die volle `--json`-Custom-Abdeckung ohne N+1-Read pro Item spiegeln.
GeändertDer Kommando-Index „Finding work" von `nxf prime` listet jetzt `nxf deferred` (offene, nicht blockierte Arbeit mit zukünftigem Defer-Datum). Die Lane war nur in der Prosa der Core Rules dokumentiert, sodass ein Agent, der den Kommando-Index scannt, sie nie sah. Der Eintrag macht auch die Ereignis-vs-Datum-Praxis sichtbar: Defer braucht ein echtes Datum — um auf ein Ereignis oder eine Lieferung zu warten, ein `WAIT:`-Chore anlegen, hinter das Abhängige gehängt werden (siehe `nxf guide deferring-and-waiting`), statt eines Platzhalter-Defer-Datums.
HinzugefügtRead-Surface: Item-`--json`-Records (`show`, `list`, `next` sowie die Lanes `blocked`/`deferred`/ `closed`/`archived`) tragen jetzt `created_at` und `updated_at`, aus dem Op-Log abgeleitet — vorhanden, wenn der Write einen Zeitstempel gesetzt hat. Worklog-Notizen erhalten ebenfalls ein `created_at` (in `show --json` und `note list --json`), und die Human-Ansichten von `show`/`note list` zeigen das Datum jeder Notiz. Die kanonischen Record-Keys bleiben unverändert; die neuen Felder kommen additiv hinzu, ein Consumer, der sie ignoriert, ist nicht betroffen.
Geändert`nxf update <id> --set defer=` (ein leerer Wert) LÖSCHT jetzt ein optionales Feld. Bisher wurden `defer=` und `due=` rundweg abgelehnt (der Datumsvalidator verweigert einen leeren Wert) und es gab kein Unset, sodass der einzige Weg aus der deferred-Lane das Setzen eines veralteten vergangenen Datums war; `assignee=` wurde akzeptiert, speicherte aber stillschweigend eine leere Zeichenkette, statt zu löschen. Jetzt entfernen `defer=`, `due=` und `assignee=` das Feld. Validierte Felder wie `status`/`priority` lehnen einen leeren Wert weiterhin ab.
GeändertDer Standard-Ursprung für Installation und Self-Update liegt jetzt auf der Marken-Domain nxsflow.com: `install.sh`, `nxs self-update` und der `@nexus-flow/mcp`-npx-Runner beziehen die signierten Artefakte von `https://nxsflow.com/nxs` (vorher `https://nxf.nxsflow.com`). Der `NXF_BASE_URL`-Override bleibt unverändert, und jedes Artefakt wird weiterhin fail-closed (sha256 + minisign) vom selben Ursprung verifiziert, von dem es aufgelöst wurde. Beim Upgrade ist nichts zu tun — dieses Release wird während des Migrationsfensters in die alte und die neue Auslieferungskette veröffentlicht, sodass bereits installierte Clients automatisch über ihre bestehende Kette auf den neuen Endpunkt aktualisieren.
Geändert`next` empfiehlt jetzt Fertigmachen vor Anfangen. Die gerankte Liste wird über dem unveränderten Plugin-Ranking in drei Stufen gruppiert: zuerst die begonnene Arbeit, die du sofort abschließen kannst (ein laufendes Item, dessen Kinder alle geschlossen sind, oder ein beanspruchtes Blatt), dann jedes begonnene Epic als Kopfzeile mit seinen offenen Kindern darunter, zuletzt der allgemeine Ready-Backlog. Innerhalb jeder Stufe entscheidet weiterhin die `next`-Policy deines Plugins über die Reihenfolge — Prioritäten bleiben also unverändert, neu ist nur die Gruppierung. Damit verschwinden zwei alte Ärgernisse: Ein fertiges, aber noch offenes Epic fällt nicht mehr aus der Liste, und die Kinder eines bereits begonnenen Epics verstreuen sich nicht mehr über den Backlog. Begonnene Arbeit ist jetzt **immer** Teil von `next`, deshalb entfällt die Option `--include-in-progress` — entferne sie aus Skripten und Aliassen (`nxf next --include-in-progress` → `nxf next`). Für die alte flache, ungruppierte Reihenfolge `--sort id` (oder ein beliebiges explizites `--sort`) verwenden. `nxs prime` zeigt 15 statt 7 Empfehlungen, damit ein begonnenes Epic mit vielen Kindern nicht mitten im Cluster abgeschnitten wird. Einbettende Apps (Facade-Kontrakt, brechend): `read::next`, `Engine::next` und `Engine::next_value` verlieren ihren Parameter `include_in_progress` — ohne ihn aufgerufen liefern sie dieselbe Menge, jetzt getiert. Das MCP-Tool `flow_next` verliert den Parameter `include_in_progress` ebenfalls; ein älterer Client, der das Feld weiterhin sendet, wird toleriert (das Feld wird ignoriert, nicht abgelehnt). Jede `next`-Zeile behält ihren aufgelösten `parent`-Join, sodass ein Board wahlweise über die Epic-Kopfzeile oder über das `parent`-Feld jedes Kindes gruppieren kann.

0.27.0

2026-07-14

Geändert`nxs mcp serve` ohne `--workspace`/`--db` legt sein automatisch initialisiertes Board jetzt an einem neutralen, nxs-eigenen Ort ab (`com.nxsflow.nxs` unter dem Plattform-Datenverzeichnis) statt im Datenverzeichnis einer bestimmten Consumer-App. Der OSS-Server nimmt keinen Consumer mehr an; ein Consumer mit eigenem Board richtet seinen eigenen `--workspace`-gepinnten MCP-Eintrag ein (und kann dieses Board importieren). Wer sich auf den bisherigen Standardort verlassen hat, verweist den Eintrag per `--workspace` explizit darauf.
HinzugefügtWeitere `--json`-Reads führen jetzt dieselben additiven Felder wie die Hauptreads — für verbübergreifende Agenten-Konsistenz: `blocked` und `search` erhalten `priority_label`/`type_label`, der verschachtelte `parent`-Join von `next` erhält `type_label`, und `blocked`/`deferred`/`closed`/ `archived` sowie `prime` führen jetzt die sparse Plugin-`custom`-Feldkarte (identisch zu `list`/`next`/`show`). Kanonische Felder bleiben unverändert; alle Ergänzungen sind additiv und erscheinen nur dort, wo sie zutreffen.

Im Einsatz

Zwei Produkte bündeln die Suite unsichtbar und setzen ihre eigene Oberfläche darauf.

manufakt.io

Coding-Agent-Plattform — du führst, die Agenten liefern.

nexflow.it

Projektmanagement für Wissensarbeit.

Loslegen

Suite installieren

Ein Artefakt zum Installieren, Verifizieren und Aktualisieren — signiert und same-origin. Erkennt deine Plattform und legt nxs (mit nxf/nxm/nxc) in deinen PATH.

Neuestes Release herunterladen

macOS (Apple Silicon) · macOS (Intel) · Linux (x86-64) · Linux (aarch64)

Dokumentation

Anleitungen für die ganze Suite — Einstieg, Grundkonzepte, Befehlsreferenz, Plugins. Dieselbe Dokumentation, die auch die CLI ausliefert; damit laufen die beiden nie auseinander.

Zur Dokumentation