Nutzerhandbuch

Theron stellt aus Claude Code und lokalen Modellen ein Team aus KI-Agents zusammen, verbindet sie in Prozessen und lässt dich jeden Schritt live verfolgen. Dieses Handbuch beschreibt alle Funktionen der App.

Erste Schritte

Installieren: Die App für macOS (Apple Silicon), Windows oder Linux gibt es im Download-Bereich. macOS: Beim ersten Start Systemeinstellungen → Datenschutz & Sicherheit → „Dennoch öffnen“. Windows: SmartScreen mit Weitere Informationen → Trotzdem ausführen. Linux: AppImage ausführbar machen und starten.
Claude anmelden (einmalig): Im Terminal claude starten und anmelden (Pro, Max, Team, Enterprise oder API-Key). Das Claude-CLI ist in der App enthalten.
Optional OpenCode für lokale Modelle (z. B. Ollama): installieren und Modelle in ~/.config/opencode/opencode.json eintragen.
Prüfen: Einstellungen → Engines prüfen zeigt, ob beide CLIs gefunden werden.
Ganz ohne Claude? Unter Einstellungen → Kern-Modell ein lokales Modell aus OpenCode wählen – siehe Kern-Modell.
Loslegen: Am einfachsten über THERON: Auftrag beschreiben, Theron klärt den Rest. Oder klassisch ein Projekt mit Prozess anlegen und im Cockpit einen Task starten.

Grundbegriffe

Agent	Ein KI-Mitarbeiter mit Aufgabe, Regeln, Engine (Claude Code oder OpenCode), Modell und Wissen.
Prozess	Ein grafischer Ablauf: Agents und Steuerknoten, verbunden über ✔ Erfolg- und ✖ Fehler-Ausgänge, mit einem Ziel.
Projekt	Arbeitsordner, Projektregeln und der verwendete Prozess.
Task	Ein Auftrag in einem Projekt, mit eigenem Chat. Jeder Agent behält innerhalb eines Tasks seine Session.
Theron (Orchestrator)	Führt den Prozess aus: ruft Agents auf, reicht Ergebnisse weiter, hält das Routing ein und fragt dich, wenn er dich braucht.

THERON-Assistent

Der erste Punkt in der Navigation. Du sagst, was erledigt werden soll – Theron kümmert sich um den Rest:

Vorgespräch: Theron klärt Wo (Arbeitsordner – auch über den 📁-Button wählbar), Was (Ziel) und Wie (nur, was wirklich offen ist). Seine Rückfragen kommen gebündelt mit Antwortvorschlägen, siehe Rückfragen. Am Ende fasst er den Auftrag zusammen und holt dein OK.
Modelle: Theron fragt, ob die Agents mit Claude oder mit einem lokalen Modell (über OpenCode) arbeiten sollen – hast du es schon gesagt, gilt das für jeden Schritt des Teams.
Team-Entwurf: Theron entwirft Prozess und Agents und zeigt sie dir – im Chat Schritt für Schritt und als Prozessfluss mit Agent-Karten. Passt etwas nicht, sag es einfach („Tester parallel zum Reviewer“, „ohne Doku-Schritt“): Theron baut den Entwurf um und fragt erneut. Erst nach deinem OK startet das Team; du siehst es dann wie im Cockpit: Chat, Rückfragen des Teams, Agent-Karten und Prozessfluss.
Abschluss: Ist der Auftrag erledigt, fragt Theron „Ist alles erledigt?“. ✔ Erledigt – aufräumen löscht den temporären Prozess, seine Agents und den Verlauf. Die Dateien im Ordner bleiben. + Neue Session beginnt von vorn und räumt ebenfalls auf.
↻ Folgeauftrag: Im selben Ordner weitermachen. Theron bekommt Ziel und Ergebnis des erledigten Auftrags, fragt, was als Nächstes kommt, und stellt dafür ein neues Team zusammen. Das neue Team erhält alle bisherigen Ergebnisse der Session als Kontext.

Die für einen Auftrag angelegten Prozesse, Agents und Projekte sind temporär: Sie erscheinen in keiner Liste. Eigene Agents, die der Entwurf mitbenutzt, bleiben unangetastet. Die Session erscheint auch auf dem, Rückfragen lassen sich dort je nach Sicherheitsstufe beantworten.

Cockpit

Projekt und Task: Oben wählst du Projekt und Task (● läuft, ◐ wartet auf dich). + Neuer Task beginnt einen neuen Auftrag, ▶ Task-Liste setzt eine Task-Liste um.
Chat: Auftrag beschreiben und mit ⌘/Strg + Enter senden. Im Chat erscheinen Übergaben, Ergebnisse und Routing-Entscheidungen.
⌨ Code-Modus: Oben im Chat zwischen Orchestrator und ⌨ Code umschalten – auch auf der THERON-Seite. Im Code-Modus chattest du direkt mit einem eigenen Worker (Claude Code), ohne Prozess und ohne Agents: Er arbeitet im Arbeitsordner des Projekts und kennt den bisherigen Verlauf des Orchestrators zu diesem Task. ↻ Neu starten beginnt eine leere Session, ■ Stopp unterbricht ihn.
⚡ AUTO: Schalter oben im Chat – auch auf der THERON-Seite. Theron beantwortet seine Rückfragen dann selbst: mit der empfohlenen Antwort, sonst nach Best Practice (ein Modell wählt anhand von Frage und bisherigem Verlauf). Gibt der Orchestrator ohne Abschluss zurück, macht er ohne Rückfrage weiter; der Task läuft so bis zum Ende durch. Gilt für den offenen Task; vor der ersten Nachricht eingeschaltet, für den neuen. Eine schon offene Rückfrage wird beim Einschalten sofort beantwortet. Damit nichts endlos läuft, schaltet AUTO sich ab, wenn Theron dreimal ohne Fortschritt zurückgibt oder nach 100 automatischen Antworten – die Frage wartet dann auf dich. Automatische Antworten stehen im Chat als ⚡ AUTO · ….
Anhänge 📎: Bilder, PDFs, Word, Excel, PowerPoint und Text ins Feld ziehen, mit ⌘/Strg + V einfügen oder über 📎 wählen. Im Text steht eine Referenz wie [📎1 foto.png]; die Dateien landen unter .theron/anhaenge/ im Arbeitsordner.
Ergebnis eines anderen Projekts 🔗: Übergibt Zusammenfassung und Arbeitsordner eines Tasks aus einem anderen Projekt. Die Agents dürfen dort lesen, aber nichts ändern.
Agent-Karten: Status, aktueller Schritt und Live-Log jedes Agents, mit Engine, Modell und aktueller Kontext-Größe (z. B. „Kontext 42k / 200k · 21 %“). Über dem Chat steht, mit welchem Modell Theron selbst arbeitet.
Prozessfluss: Unten der animierte Ablauf mit Fehler-Schleifen (↺ 1/3). Ein Klick auf einen Knoten lässt Theron den Schritt erklären. ⤢ Vollansicht öffnet den ganzen Fluss in einem eigenen Fenster; Unterprozesse klappst du mit [+] live auf. Ein Schalter wechselt dort zwischen kompaktem Ablauf und Prozessdiagramm (wie im Editor); Task-Listen, die ein Lauf anlegt, klappen direkt im Fluss auf. ↺ unter einem Knoten startet den Prozess ab dort neu: Ein laufender Prozess wird gestoppt, der Schritt und alle folgenden beginnen von vorn (Stand, Loop-Einträge, Agent-Sitzungen), der Schritt bekommt seine letzten Übergaben wieder, alles davor bleibt.
📡 Zwischenstand: Solange ein Agent arbeitet, fragt Theron ihn alle 2 Minuten nebenbei nach seinem Stand, ohne ihn zu unterbrechen (eine Kopie seiner Sitzung antwortet), und teilt die Antwort im Chat, auf der Agent-Karte, im Web und per Sprachausgabe. Den Abstand stellst du unter Einstellungen → Engines ein (0 = aus).
An wen (unter dem Chat): Standard ist Theron · Orchestrator. Während ein Task läuft, kannst du dort einen Agent des Prozesses wählen und ihm direkt schreiben (● = arbeitet gerade). Ein arbeitender Agent unterbricht kurz, liest die Nachricht und macht in seiner Sitzung weiter – wie Esc + Tippen in Claude Code; ein Agent, der gerade nicht dran ist, bekommt sie bei seinem nächsten Einsatz. Bei einer Parallel-Gruppe oder Schleife bekommen alle laufenden Instanzen die Nachricht.
Stopp: Wahlweise sofort oder wenn die aktuellen Schritte fertig sind – dann startet nichts Neues mehr.
Mehrere Projekte parallel: Tasks verschiedener Projekte laufen gleichzeitig. Die Seitenleiste AKTIV listet alle laufenden und wartenden Tasks; ein Klick öffnet sie.
Ordner öffnen zeigt das Arbeitsverzeichnis im Finder bzw. Explorer.

Rückfragen beantworten

Braucht Theron dich, stellt er zusammengehörige Fragen gebündelt – wie Claude Code:

Jede Frage hat Antwortoptionen mit kurzer Beschreibung. Die Option, die Theron für die sinnvollste hält, ist mit ★ Empfohlen markiert. Manche Fragen erlauben Mehrfachauswahl (☐/☑).
Du beantwortest die Fragen nacheinander. Oben zeigen Chips den Fortschritt (✔ beantwortet); ein Klick springt zu einer Frage.
Unter jeder Frage steht Eigene Antwort … für eine freie Antwort oder Ergänzung.
Am Ende siehst du alle Antworten zur Kontrolle und klickst Absenden. Was im Chatfeld steht, geht als Nachricht mit.
Eine einzelne Frage ist mit einem Klick auf die Option beantwortet.

Theron meldet sich bei Rückfragen im Dock bzw. in der Taskleiste und – wenn eingeschaltet – per Sprache.

Projekte

Prozess wechseln: Oben im Cockpit neben „PROZESS · …“ mit ⇄ wechseln oder im Projekt-Formular. Die bisherigen Tasks bleiben mit ihrem Prozess erhalten – Verlauf, Schritte, Ergebnisse; führst du einen fort, läuft er mit seinem Prozess weiter. Neue Tasks laufen mit dem neuen Prozess, im selben Arbeitsordner – er findet alles bisher Erstellte vor. Typisch: erst „Recherche“, dann „Umsetzung“ im selben Projekt.
Name, Beschreibung, Arbeitsverzeichnis (hier arbeiten die Agents; leer = automatisch anlegen) und Prozess.
Regeln: Technische Vorgaben, Standards, Zielplattform – jeder Agent und der Orchestrator bekommen sie in jedem Schritt.
Modelle überschreiben – nur für dieses Projekt: Zeigt alle Agents, die der Prozess ausführt (auch in Parallel-Gruppen, Schleifen und Unterprozessen), mit Engine und Modell aus dem Prozess. Pro Agent wählst du eine andere Engine bzw. ein anderes Modell, oder mit Für alle übernehmen z. B. alles auf ein lokales Modell. „wie im Prozess“ setzt zurück. Agents und Prozess selbst bleiben unverändert; der Orchestrator nutzt weiter das Kern-Modell.
Cockpit öffnen ▸ springt direkt zum Projekt.
Löschen entfernt das Projekt mit all seinen Tasks samt Verlauf – laufende Tasks werden vorher gestoppt, und auch der Theron-Server vergisst sie.

Agents

Felder: Name, Aufgabe (was tut er), Regeln (woran hält er sich), Engine und Modell, Rechte (von „nur planen“ bis „autonom“) und maximale Schritte.
Wissen & Kontext: Dokumente, Ordner (z. B. eine Plugin-Hülle) und Links – über die Buttons oder per Drag & Drop. Theron kopiert Dateien in seinen Datenordner; der Agent bekommt sie als verbindlichen Kontext. Originale bleiben unverändert.
Gedächtnis: Optional legt der Agent seine Recherchen in einem lokalen Ordner ab (INDEX.md und eine Datei je Thema mit Stand). Vor jeder Recherche sieht er dort nach: Daten, die jünger als die eingestellte Dauer (Aktuell für, z. B. 7 Tage) sind, nutzt er direkt; ältere recherchiert er neu und aktualisiert sie. Ordner leer = Theron legt ihn im Datenordner an; Öffnen zeigt ihn im Finder bzw. Explorer.
Globale Regeln (Einstellungen) bekommt jeder Agent zusätzlich zu seinen eigenen und den Projektregeln.
Ordner: + Ordner legt einen an, Einträge ziehst du hinein. Rechtsklick: umbenennen, entfernen. ✦ KI-Struktur sortiert alle Agents nach Zweck in passende Ordner – du siehst den Vorschlag vorher.
✦ Mit KI erstellen: Beschreiben oder diktieren, was du brauchst – die KI entwirft Name, Aufgabe, Regeln und Modell.
Ungenutzte entfernen löscht Agents, die kein Prozess verwendet.

Prozesse & Editor

Links liegen die Werkzeuge und die Agents (mit Suche, nach Ordnern gegliedert). Ziehe sie auf die Fläche und verbinde die Ausgänge ✔ und ✖ mit dem Eingang des nächsten Knotens.

Welche Knoten es gibt und wie sie arbeiten, steht in der Knoten-Referenz.

Routing: ✔ führt weiter, ✖ zurück (Schleife mit maximal n Iterationen, danach fragen, weiter oder abbrechen). Theron reicht jedes Ergebnis automatisch an den richtigen Schritt weiter.
Prozess-Eigenschaften (Klick auf freie Fläche): Zusammenspiel, Ziel (Definition of Done), Orchestrator-Modell, maximale Agent-Aufrufe und Erwartete Eingabe – fehlt etwas Pflichtiges, fragt Theron nach, bevor ein Agent startet.
Bedienung: Mausrad zoomt, Ziehen auf freier Fläche verschiebt, Shift + Ziehen zieht einen Auswahlrahmen, Shift- bzw. ⌘/Strg-Klick wählt mehrere Knoten, ⌘/Strg + A alle, Entf löscht. „Als Startschritt setzen“ legt den Anfang fest. ▦ unten rechts ordnet alle Knoten automatisch neu an: Hauptweg von links nach rechts, Verzweigungen untereinander, Schleifenkörper unter ihrer Schleife.
✦ Mit KI erstellen entwirft einen ganzen Prozess aus deinen Agents und Prozessen; fehlende Rollen werden als Agents angelegt. ✦ Verfeinern baut den aktuellen Stand nach deinem Wunsch um. In beiden Dialogen wählst du die Modelle der Agents: Claude oder ein lokales Modell aus opencode.json – es gilt dann für jeden Agent-Schritt, deine eigenen Agents bleiben unverändert. Beides ist ungespeichert, bis du speicherst; Verwerfen löscht nur die dafür neu angelegten Agents.
Beschreibung je Knoten (optional): eine Notiz nur für dich – nie Teil eines Prompts. Ein Klick auf den Knoten im Prozessfluss lässt Theron sie vorlesen.
Export / Import sichern Prozesse samt Agents, Unterprozessen und Wissen als .theron-Datei.

Knoten-Referenz

Jeder Knoten im Prozess-Editor im Detail. Die Werkzeuge ziehst du aus der linken Palette auf die Fläche, Agents aus der Agent-Palette; ein Klick auf einen Knoten zeigt rechts seine Einstellungen.

▶THERON (Start)

Wozu: Der Anfang jedes Prozesses. Hier kommt dein Auftrag an – mit Anhängen und den erwarteten Eingaben.
Ein- & Ausgänge: Ein Ausgang. Er führt zum ersten Schritt; „Als Startschritt setzen“ legt ihn fest.

●Agent

Wozu: Ein Arbeitsschritt: ein Agent erledigt seinen Teil und meldet am Ende ERFOLG oder FEHLER.
Ein- & Ausgänge: Ein Eingang. ✔ Erfolg und ✖ Fehler als Ausgänge. ✖ zurück zu einem früheren Schritt ergibt eine Nachbesserungsschleife; ein offener ✖ fragt dich.
Einstellungen: Anweisungen für diesen Prozess, Erfolgskriterium, maximale Iterationen und was danach passiert (fragen, weiter, abbrechen), optional eine andere Engine bzw. ein anderes Modell als beim Agent.
Beispiel: Entwickler ✔ → Reviewer; Reviewer ✖ → zurück zum Entwickler, höchstens dreimal.

◆Bedingung

Wozu: Eine Wenn/Dann-Entscheidung: Theron prüft die Ergebnisse gegen die Bedingung und wählt den Weg – mit Begründung.
Ein- & Ausgänge: Ein Eingang. Ausgänge „wenn …“ und „sonst“.
Einstellungen: Name und Bedingung in Worten, z. B. „Tests sind grün“.
Beispiel: Memory lesen → Bedingung „Memory vorhanden“ → weiter, sonst → Unterprozess, der es füllt.

◆Switch

Wozu: Wie die Bedingung, aber mit beliebig vielen Zweigen.
Ein- & Ausgänge: Ein Eingang. Ein Ausgang je Zweig plus „sonst“.
Einstellungen: Name und je Zweig eine Bedingung in Worten.
Beispiel: „Bug“ → Bugfix-Team, „Feature“ → Entwicklung, „Frage“ → Antwort-Agent, sonst → nachfragen.

✋Nutzer-Entscheidung

Wozu: Human in the Loop an einer festen Stelle: Theron stellt dir eine Frage, du entscheidest.
Ein- & Ausgänge: Ein Eingang. Ein Ausgang je Antwort; eine eigene Antwort (Kommentar) geht über „sonst“ weiter.
Einstellungen: Frage und Antwortmöglichkeiten. Die eingehenden Übergaben (z. B. der Mängelbericht) hängt Theron an.
Beispiel: Nach dem Deploy: „Freigeben“ → Ziel, „Code nachbessern“ → Entwickler.

⋔UND-Verzweigung

Wozu: Startet mehrere Pfade, die unabhängig voneinander gleichzeitig laufen.
Ein- & Ausgänge: Ein Eingang. Ein Ausgang je Pfad.
Einstellungen: Anzahl der Pfade.
Beispiel: Frontend- und Backend-Entwickler bauen gleichzeitig, danach führt ⋈ Zusammenführen beide zusammen.

⋈Zusammenführen

Wozu: Wartet, bis alle hineinführenden Pfade angekommen sind, und geht dann mit allen Ergebnissen gemeinsam weiter.
Ein- & Ausgänge: Beliebig viele Eingänge – es gibt immer einen freien mehr. Ein Ausgang.
Einstellungen: Name.
Beispiel: UND-Verzweigung → zwei Pfade → Zusammenführen → Tester.

⧉Parallel-Gruppe

Wozu: Mehrere Agents bearbeiten dieselbe Übergabe gleichzeitig; ✔ nur, wenn alle zustimmen.
Ein- & Ausgänge: Ein Eingang. ✔ (alle erfolgreich) und ✖ (mindestens einer meldet Mängel – alle Mängel gesammelt).
Einstellungen: Agents hineinziehen, je Mitglied eigene Anweisungen und Modell.
Beispiel: Review, Security-Check und Tests gleichzeitig nach der Umsetzung.

⟳Schleife

Wozu: Arbeitet eine Liste ab – je Eintrag ein Durchlauf durch den Schleifenkörper.
Ein- & Ausgänge: Eingänge Input (die Liste) und Loop (Rückkehr aus dem Körper). Ausgänge Result (oben: weiter, wenn alle Einträge durch sind – alle Ergebnisse als eine Übergabe) und Item (unten: in den Körper). Der Körper – ein Agent, mehrere Knoten oder ein Unterprozess – muss zurück an Loop führen; eine nicht geschlossene Schleife meldet der Editor als Fehler.
Einstellungen: Regel, wie die Liste entsteht (z. B. „ein Eintrag je Plugin“), nacheinander oder parallel mit Maximum, Sicherheitslimit für die Anzahl, Hinweise je Eintrag, und was mit gescheiterten Einträgen passiert: über Result weiter (vermerkt) oder dich fragen (wiederholen, trotzdem weiter, abbrechen). Kommt eine Task-Liste an, ist jedes Requirement ein Eintrag – in der Reihenfolge der Abhängigkeiten.
Beispiel: Marktanalyst → Schleife „je Plugin“ → Item → Rechercheur → zurück an Loop; Result → Lead fasst zusammen.

⊞Unterprozess

Wozu: Führt einen anderen Prozess komplett aus – mit eigenem Orchestrator, eigenen Agents und eigenem Ziel.
Ein- & Ausgänge: Ein Eingang. ✔ (Ziel des Unterprozesses erreicht) und ✖.
Einstellungen: Welcher Prozess, Anweisungen und Erfolgskriterium. In der Vollansicht des Prozessflusses klappst du ihn live auf.
Beispiel: Am Ende der Entwicklung der Prozess „Dokumentation“.

⚑Meldung

Wozu: Info, Warnung oder Fehler an dich – im Cockpit, in der Web-UI, im Requirement-Protokoll und per Sprache.
Ein- & Ausgänge: Ein Eingang (meist an einem ✖), ein Ausgang.
Einstellungen: Stufe, Text und Verhalten: weiter oder anhalten, bis du entscheidest (weitermachen, erneut versuchen, beenden). Theron hängt die Details automatisch an.
Beispiel: Schleife mit gescheiterten Einträgen → Warnung „nicht recherchiert“, dann weiter.

☰Task-Liste

Wozu: Erzeugt, füllt oder liest eine Task-Liste und gibt sie weiter – typisch an eine Schleife, die jedes offene Requirement umsetzt. So kann ein ganzer Prozess aus einem Konzept eine Task-Liste mit Epics und Requirements machen und sie gleich umsetzen.
Ein- & Ausgänge: Ein Eingang, ein Ausgang.
Einstellungen: Vier Arten:
Temporär – die KI erstellt sie: Epics und Requirements aus der Eingabe (mit Hinweisen dafür). Unter TASKS als „(Temp.)“ sichtbar; wird entfernt, wenn der Prozess abgeschlossen ist.
Temporär – Kopie: kopiert eine gewählte Liste; das Original bleibt unverändert.
In eine Task-Liste schreiben: die KI macht aus der Eingabe – z. B. einem Konzept – Epics und Requirements und schreibt sie in eine dauerhafte Liste: eine gewählte, oder eine, die der Schritt im Projekt des Tasks unter dem angegebenen Namen selbst anlegt (gibt es sie schon, wird sie ergänzt; ohne Namen schlägt die KI einen vor). Epics gleichen Namens werden ergänzt statt verdoppelt, Vorhandenes nicht wiederholt.
Task-Liste lesen (Quelle): gibt eine bestehende Liste weiter – auch aus einem anderen Projekt. So hängt der Prozess nicht an einem Projekt.
Bei dauerhaften Listen pflegt die Schleife Status und Ergebnis direkt in der Liste.
Beispiel: Konzepter-Agent → Task-Liste „In eine Task-Liste schreiben: Umsetzung“ → Schleife → Item → Entwickler → Reviewer → zurück an Loop.

◉Memory speichern

Wozu: Hält Ergebnisse dauerhaft fest – über diesen Lauf und diesen Prozess hinaus. Das Kern-Modell fasst die eingehenden Übergaben zusammen und speichert sie unter einem Namen.
Ein- & Ausgänge: Ein Eingang, ein Ausgang (gibt die Zusammenfassung weiter).
Einstellungen: Name (frei wählbar), was festgehalten werden soll, und „Ergänzen statt ersetzen“. Im Knoten lässt sich jederzeit zwischen Speichern und Lesen umschalten.
Beispiel: Am Ende der Marktrecherche: Memory speichern „Marktdaten Wärmepumpen“.

◉Memory lesen

Wozu: Gibt ein gespeichertes Memory als Kontext weiter – oder meldet, dass es (noch) nicht vorhanden ist.
Ein- & Ausgänge: Ein Eingang, ein Ausgang: das Memory (mit Stand) zusammen mit den eingehenden Übergaben.
Einstellungen: Name – eines der vorhandenen Memorys (auch solche, die andere Prozesse schreiben).
Beispiel: Angebot: Memory lesen → Bedingung „Memory vorhanden“ → Angebots-Autor; sonst → Unterprozess „Marktrecherche“ → Memory speichern → zurück zu Memory lesen.

▤Datenbank

Wozu: Eine benannte Sammlung von Einträgen, die Prozesse schreiben und lesen – auch über Läufe und Prozesse hinweg. Jeder Eintrag hat einen Schlüssel (z. B. Firmenname oder URL) und freie Felder.
Ein- & Ausgänge: Ein Eingang, ein Ausgang. Schreiben gibt weiter, was angelegt bzw. aktualisiert wurde; Lesen gibt alle passenden Einträge als Übergabe weiter.
Einstellungen: Datenbank (vorhanden oder neu), Schreiben oder Lesen, beim Schreiben was als Schlüssel und welche Felder gelten (vorhandene Einträge werden ergänzt, nicht genannte Felder bleiben), beim Lesen optional eine Bedingung in Worten. Die Einträge siehst und bearbeitest du unter DATENBANKEN (mit CSV-Export); auf Wunsch werden sie über den Theron-Server synchronisiert.
Beispiel: Datenbank lesen „Firmen“ → Rechercheur ergänzt, was fehlt → Datenbank schreiben „Firmen“ (Schlüssel: Firmenname).

◎Ziel

Wozu: Das Ende des Prozesses. Theron prüft das Ziel (Definition of Done) und fasst zusammen.
Ein- & Ausgänge: Eingänge von jedem Schritt, der abschließt (✔ offen führt ebenfalls hierher).
Einstellungen: Das Ziel stellst du in den Prozess-Eigenschaften ein (Klick auf freie Fläche).

Task-Listen & Konzepter

Prozess je Task-Liste (optional): Im Formular der Task-Liste unter Prozess legst du fest, mit welchem Prozess ihre Epics umgesetzt werden – Standard ist „Wie das Projekt“. So laufen z. B. die Design-Epics durch den Design-Prozess und die Backend-Epics durch die Entwicklung. Startet Theron eine Task-Liste mit anderem Prozess im Gespräch, läuft sie als eigener Task. Vorlagen geben ihren Prozess an die erzeugten Listen weiter; temporäre Task-Listen laufen immer im Prozess, der sie angelegt hat.
Task-Listen (Bereich TASKS) bestehen aus Epics mit Requirements: Beschreibung, Akzeptanzkriterien, technische Regeln, Abhängigkeiten und Protokoll.
Umsetzen: Im Cockpit ▶ Task-Liste. Jedes Requirement durchläuft den kompletten Prozess; Abhängige kommen erst dran, wenn ihre Voraussetzungen erledigt sind. Innerhalb eines Epics behalten die Agents ihren Kontext.
Status: Offen, In Progress, HitL (wartet auf dich), Done, Fehlgeschlagen, Übersprungen, Closed.
✦ Konzepter: Ein Chat je Task-Liste. Er challengt dein Konzept und legt Epics und Requirements an – auch später, z. B. für Bugs. Er ändert nur offene Requirements und löscht nur, was geschlossen ist.
Vorlagen: „Als Vorlage speichern …“ macht eine Liste wiederverwendbar, mit Parametern (Ordner, Datei, Text, Auswahl) und Platzhaltern wie {{kunde}}. ▶ Neue Task-Liste aus Vorlage … fragt die Werte ab.

Kern-Modell – ohne Claude

Das Kern-Modell ist das Modell hinter Theron selbst: Orchestrator, THERON-Assistent, Konzepter, KI-Entwürfe, Prüfung von Web-Antworten und Ansagen. Unter Einstellungen → Kern-Modell wählst du:

Claude (Standard) – über das Claude-CLI.
Lokales Modell (aus OpenCode) – Theron spricht die OpenAI-kompatible Schnittstelle des Anbieters aus ~/.config/opencode/opencode.json direkt an (z. B. Ollama oder LM Studio) und führt seine Werkzeuge selbst aus. Das Modell muss Werkzeugaufrufe beherrschen (z. B. qwen3-coder). Eine abweichende Adresse ist optional; Verbindung testen prüft das Modell.

Laufen auch die Agents über OpenCode, arbeitet Theron vollständig ohne Claude. Agents, die die KI entwirft, bekommen dann automatisch OpenCode mit dem Kern-Modell. Die Claude-Limits halten einen lokalen Orchestrator nicht an.

Nutzung & Limits

Die Statusleiste zeigt die Claude-Nutzung für das 5-Stunden-Fenster und die Woche, mit Reset-Zeit und Kosten. Details zeigt die vollständige Ausgabe, ↻ Aktualisieren holt die Zahlen sofort neu. Im Slave-Betrieb stammen sie vom Claude-Abo des Workers.
Eigene Limits (Einstellungen → Engines): Erreicht die Nutzung den Wert, pausiert Theron. Laufende Agents werden angehalten und machen nach dem Zurücksetzen genau dort weiter; neue Claude-Aufrufe warten. Lokale OpenCode-Modelle sind nicht betroffen.

Sprache

Spracheingabe: Mikrofon-Knopf neben jedem Eingabefeld oder ⌘/Strg + Shift + Leertaste. Die Erkennung läuft lokal mit Whisper; kein Audio verlässt den Rechner. Modell, Sprache, Mikrofon (mit Test) und Fachbegriffe stellst du in den Einstellungen ein.
Theron spricht: Ansagen zu Statuswechseln mit neuronaler Stimme (Piper, lokal) in Deutsch, Englisch, Niederländisch oder Französisch, männlich oder weiblich – auf Wunsch von der KI natürlich formuliert. Probehören funktioniert ohne Download. Fremdsprachige Wörter (z. B. „Reviewer“ in einem deutschen Satz) spricht die Stimme lautschriftlich in ihrer eigenen Sprache; unter Aussprache legst du eigene Einträge an (Wort = en, Wort = so gesprochen oder Wort = [[IPA]]). „Theron“ wird immer englisch ausgesprochen – mit der deutschen Stimme „Sseron“. 🔊/🔇 in der Statusleiste schaltet sofort stumm.

Theron-Server verbinden

Einstellungen → Theron-Server: Adresse und Client-Token eintragen und „Status live synchronisieren“ einschalten. Unten in der Seitenleiste zeigt SERVER den Verbindungsstatus.
Sicherheitsstufe für Eingaben aus dem Web: keine Eingabe, nur vordefinierte Antworten oder freie Eingabe mit Sicherheitsprüfung – die Prüfung läuft auf deinem Rechner, bevor Theron die Antwort bekommt.
Prozesse und Agents synchronisieren – auf Wunsch mit Wissen, Memorys und Datenbanken. ⟳ SYNC unten in der Seitenleiste zeigt den Stand.
Installation, Web-UI und Bibliothek im Detail: Server.

Slave: Theron auf einem anderen Rechner

Einstellungen → Slave: Host, Port und Token eines Theron, der dort mit theron --listen oder als Headless-Worker läuft; „Verbindung prüfen“ zeigt seinen Fingerprint. Die App startet neu und steuert dann den Slave – Tasks, THERON und alle Modellaufrufe laufen dort, auch wenn die App geschlossen ist.
Einrichten des Slaves, Docker und Kubernetes: CLI · Headless.

Konsole

Einstellungen → Konsole richtet den Befehl theron auf diesem Rechner ein. Alles dazu: CLI · Headless.

Lokale API

Für eigene Skripte auf deinem Rechner: Projekte anlegen, Tasks starten und beantworten, Task-Listen befüllen und auf Ereignisse reagieren. Einschalten unter Einstellungen → Lokale API. Alle Details in der API-Dokumentation.

Weitermachen nach Neustart

Wird Theron mitten in einem Task beendet oder stürzt ab, zeigt er beim nächsten Start die unterbrochenen Tasks und bietet ▶ Weitermachen an. Orchestrator und Agents setzen ihre Sessions fort und kennen ihren bisherigen Kontext – auch mit lokalem Kern-Modell; unterbrochene Agents erfahren, dass sie mittendrin waren. Offene Rückfragen werden erneut gestellt.

Privatsphäre

Was in Theron passiert, verlässt deinen Rechner nicht – außer an deinen eigenen Theron-Server und an die Modelle, mit denen deine Agents arbeiten (Claude bzw. dein lokales Modell). Telemetrie, Fehler- und Absturzberichte und Auto-Updates sind in allen Bausteinen abgeschaltet: Claude Code, OpenCode, onnxruntime (neuronale Stimme, Spracherkennung) und Hugging Face. Spracherkennung und Stimme laufen lokal; Stimmen und Sprachmodelle werden nur einmalig heruntergeladen.

Einstellungen & Daten

Sprache der App (Deutsch, Englisch – ein Wechsel startet Theron neu), Kern-Modell, Globale Regeln (gelten für jeden Agent), Engines und Limits, Server, lokale API, Spracheingabe und Sprachausgabe.
Plugins: Plugins hochladen, ein- und ausschalten, ihre Einstellungen und ihr Protokoll öffnen. Plugins bringen eigene Navigationspunkte, Einstellungen, Prozess-Nodes (im Editor unter WERKZEUGE) und Anbindungen mit – siehe Plugins.
Daten: macOS ~/Library/Application Support/Theron/, Windows %APPDATA%\Theron\, Linux ~/.local/share/theron/.
Alles zurücksetzen … löscht Projekte, Tasks, Prozesse, Agents und Task-Listen; Einstellungen und Dateien in den Arbeitsordnern bleiben.
Alle Bereiche lassen sich über Trennbalken in der Größe anpassen; Theron merkt sich die Größen und öffnet beim Start das zuletzt genutzte Projekt.

Tastenkürzel

⌘/Strg + Enter	Nachricht senden
⌘/Strg + Shift + Leertaste	Diktat starten / beenden
⌘/Strg + V	Bild oder Datei als Anhang einfügen
⌘/Strg + A	Prozess-Editor: alle Knoten wählen
⌘/Strg + / − / 0	Prozess-Editor: zoomen / 100 %
Entf / ⌫	Prozess-Editor: Auswahl löschen

User guide

Theron turns Claude Code and local models into a team of AI agents, connects them in processes and lets you follow every step live. This guide describes all features of the app.

Getting started

Install: the app for macOS (Apple Silicon), Windows or Linux is in the download section. macOS: on the first start use System Settings → Privacy & Security → “Open Anyway”. Windows: SmartScreen More info → Run anyway. Linux: make the AppImage executable and start it.
Log in to Claude (once): run claude in a terminal and log in (Pro, Max, Team, Enterprise or API key). The Claude CLI is included in the app.
Optionally OpenCode for local models (e.g. Ollama): install it and add models to ~/.config/opencode/opencode.json.
Check: Settings → Check engines shows whether both CLIs are found.
No Claude at all? Choose a local model from OpenCode under Settings → Core model – see Core model.
Get going: the easiest way is THERON: describe the job, Theron clarifies the rest. Or the classic way: create a project with a process and start a task in the cockpit.

Key terms

Agent	An AI team member with a task, rules, engine (Claude Code or OpenCode), model and knowledge.
Process	A visual workflow: agents and control nodes connected by ✔ success and ✖ failure exits, with a goal.
Project	Working folder, project rules and the process it uses.
Task	A job in a project, with its own chat. Every agent keeps its session within a task.
Theron (orchestrator)	Runs the process: calls agents, hands results on, keeps to the routing and asks you when it needs you.

THERON assistant

The first entry in the navigation. You say what should be done – Theron takes care of the rest:

Briefing talk: Theron clarifies where (the working folder – also selectable with the 📁 button), what (the goal) and how (only what is really open). His questions come bundled with suggested answers, see answering questions. Finally he sums the job up and gets your OK.
Models: Theron asks whether the agents work with Claude or with a local model (through OpenCode) – if you already said so, it applies to every step of the team.
Team draft: Theron drafts the process and agents and shows them to you – in the chat step by step and as a process flow with agent cards. If something isn't right, just say so (“tester parallel to the reviewer”, “without the docs step”): Theron reworks the draft and asks again. Only after your OK does the team start; you then see it as in the cockpit: chat, the team's questions, agent cards and process flow.
Done: when the job is finished, Theron asks “Is everything done?”. ✔ Done – clean up deletes the temporary process, its agents and the history. The files in the folder stay. + New session starts over and cleans up as well.
↻ Follow-up job: continue in the same folder. Theron gets the goal and the result of the finished job, asks what comes next and puts a new team together for it. The new team gets all earlier results of the session as context.

Processes, agents and projects created for a job are temporary: they don't show up in any list. Your own agents that a design reuses stay untouched. The session also appears on the Theron server, where questions can be answered depending on the security level.

Cockpit

Project and task: choose them at the top (● running, ◐ waiting for you). + New task starts a new job, ▶ Task list works through a task list.
Chat: describe the job and send it with ⌘/Ctrl + Enter. The chat shows hand-overs, results and routing decisions.
⌨ Code mode: switch between Orchestrator and ⌨ Code at the top of the chat – on the THERON page too. In code mode you chat straight with a worker of its own (Claude Code), no process, no agents: it works in the project's working folder and knows the orchestrator's history of this task. ↻ Restart begins a blank session, ■ Stop interrupts it.
⚡ AUTO: switch at the top of the chat – on the THERON page too. Theron then answers its own questions: with the recommended answer, otherwise following best practice (a model picks from the question and the course of the task). When the orchestrator hands back without finishing, it carries on without asking, so the task runs through to the end. It applies to the open task; switched on before the first message, to the new one. A question already open is answered as soon as you switch it on. So that nothing runs forever, AUTO switches off when Theron hands back three times without progress or after 100 automatic answers – the question then waits for you. Automatic answers show up in the chat as ⚡ AUTO · ….
Attachments 📎: drag images, PDFs, Word, Excel, PowerPoint and text files into the field, paste them with ⌘/Ctrl + V or pick them with 📎. The text contains a reference like [📎1 photo.png]; the files are stored in .theron/anhaenge/ in the working folder.
Result of another project 🔗: hands over the summary and working folder of a task from another project. The agents may read there but change nothing.
Agent cards: status, current step and live log of every agent, with engine, model and current context size (e.g. “Context 42k / 200k · 21 %”). Above the chat you see which model Theron itself works with.
Process flow: the animated flow at the bottom, with failure loops (↺ 1/3). Click a node and Theron explains the step. ⤢ Full view opens the whole flow in its own window; open sub-processes live with [+]. A switch there changes between the compact flow and the process diagram (as in the editor); task lists a run creates unfold right in the flow. ↺ below a node restarts the process from there: a running process stops, the step and every step after it start over (state, loop items, agent sessions), the step gets its last hand-overs again, everything before stays.
📡 Progress: while an agent works, Theron asks it for its progress every 2 minutes on the side, without interrupting it (a copy of its session answers), and shares the answer in the chat, on the agent card, on the web and by voice. Set the interval under Settings → Engines (0 = off).
To whom (below the chat): the default is Theron · orchestrator. While a task runs you can pick an agent of the process there and write to it directly (● = working right now). A working agent pauses briefly, reads the message and carries on in its session – like Esc + typing in Claude Code; an agent that isn't on turn gets it with its next turn. In a parallel group or a loop every running instance gets the message.
Stop: immediately or when the current steps are done – then nothing new starts.
Several projects in parallel: tasks of different projects run at the same time. The ACTIVE sidebar lists all running and waiting tasks; a click opens them.
Open folder shows the working folder in Finder or Explorer.

Answering questions

When Theron needs you, he asks related questions together – like Claude Code:

Every question has answer options with a short description. The option Theron considers most sensible is marked ★ Recommended. Some questions allow multiple choice (☐/☑).
You answer the questions one after another. Chips at the top show your progress (✔ answered); a click jumps to a question.
Below every question there is Your own answer … for a free answer or an addition.
At the end you review all answers and click Submit. Whatever is in the chat field goes along as a message.
A single question is answered with one click on an option.

Theron signals questions in the Dock or taskbar and – if enabled – by voice.

Projects

Switching the process: at the top of the cockpit next to “PROCESS · …” with ⇄ switch, or in the project form. The tasks so far keep their process – history, steps, results; if you continue one, it goes on with its process. New tasks run with the new process, in the same working folder – it finds everything created so far. Typical: first “research”, then “implementation” in the same project.
Name, description, working folder (where the agents work; empty = created automatically) and process.
Rules: technical requirements, standards, target platform – every agent and the orchestrator get them in every step.
Override models – for this project only: shows every agent the process runs (also in parallel groups, loops and sub-processes) with the engine and model set in the process. Choose a different engine or model per agent, or use Apply to all, e.g. to run everything on a local model. “as in the process” resets it. Agents and process stay unchanged; the orchestrator keeps using the core model.
Open cockpit ▸ jumps straight to the project.
Delete removes the project with all its tasks and their history – running tasks are stopped first, and the Theron server forgets them too.

Agents

Fields: name, task (what it does), rules (what it sticks to), engine and model, permissions (from “plan only” to “autonomous”) and maximum steps.
Knowledge & context: documents, folders (e.g. a plugin skeleton) and links – via the buttons or drag & drop. Theron copies files into its data folder; the agent gets them as binding context. Originals stay unchanged.
Memory: optionally the agent stores its research in a local folder (INDEX.md and one dated file per topic). Before researching it looks there first: data younger than the set period (Current for, e.g. 7 days) is used directly, older data is researched again and updated. Empty folder = Theron creates it in its data folder; Open shows it in Finder or Explorer.
Global rules (settings) are given to every agent in addition to its own and the project rules.
Folders: + Folder creates one, drag entries into it. Right-click: rename, remove. ✦ AI structure sorts all agents into fitting folders by purpose – you see the suggestion first.
✦ Create with AI: describe or dictate what you need – the AI drafts name, task, rules and model.
Remove unused deletes agents no process uses.

Processes & editor

On the left are the tools and the agents (searchable, sorted into folders). Drag them onto the canvas and connect the ✔ and ✖ exits to the input of the next node.

Which nodes there are and how they work is described in the node reference.

Routing: ✔ leads forward, ✖ back (a loop with at most n iterations, then ask, continue or abort). Theron hands every result on to the right step automatically.
Process properties (click on free canvas space): collaboration, goal (definition of done), orchestrator model, maximum agent calls and expected input – if something required is missing, Theron asks before any agent starts.
Handling: the mouse wheel zooms, dragging free space pans, Shift + drag draws a selection frame, Shift or ⌘/Ctrl click selects several nodes, ⌘/Ctrl + A all, Delete removes them. “Set as start step” sets the beginning. ▦ at the bottom right rearranges all nodes automatically: the main route left to right, branches stacked, loop bodies below their loop.
✦ Create with AI designs a whole process from your agents and processes; missing roles are created as agents. ✦ Refine reworks the current state as you wish. In both dialogs you choose the models of the agents: Claude or a local model from opencode.json – it then applies to every agent step, your own agents stay unchanged. Both stay unsaved until you save; Discard only deletes the agents created for it.
Description per node (optional): a note for you only – never part of a prompt. Click the node in the process flow and Theron reads it out.
Export / import save processes with their agents, sub-processes and knowledge as a .theron file.

Node reference

Every node of the process editor in detail. Drag the tools from the left palette onto the canvas, agents from the agent palette; a click on a node shows its settings on the right.

▶THERON (start)

Purpose: The beginning of every process. Your job arrives here – with attachments and the expected inputs.
Inputs & outputs: One output. It leads to the first step; “Set as start step” chooses it.

●Agent

Purpose: A work step: an agent does its part and reports SUCCESS or FAILURE at the end.
Inputs & outputs: One input. ✔ success and ✖ failure as outputs. ✖ back to an earlier step makes a rework loop; an open ✖ asks you.
Settings: Instructions for this process, success criterion, maximum iterations and what happens then (ask, continue, abort), optionally another engine or model than the agent's.
Example: Developer ✔ → reviewer; reviewer ✖ → back to the developer, at most three times.

◆Condition

Purpose: An if/then decision: Theron checks the results against the condition and picks the way – with a reason.
Inputs & outputs: One input. Outputs “if …” and “else”.
Settings: Name and the condition in words, e.g. “tests are green”.
Example: Read memory → condition “memory available” → continue, else → a sub-process that fills it.

◆Switch

Purpose: Like the condition, but with any number of branches.
Inputs & outputs: One input. One output per branch plus “else”.
Settings: Name and a condition in words per branch.
Example: “bug” → bugfix team, “feature” → development, “question” → answer agent, else → ask.

✋User decision

Purpose: Human in the loop at a fixed point: Theron asks you a question, you decide.
Inputs & outputs: One input. One output per answer; a free answer (comment) continues via “else”.
Settings: Question and answers. Theron attaches the incoming hand-overs (e.g. the defect report).
Example: After the deploy: “release” → goal, “fix the code” → developer.

⋔AND split

Purpose: Starts several paths that run independently at the same time.
Inputs & outputs: One input. One output per path.
Settings: Number of paths.
Example: Frontend and backend developers build at the same time, then ⋈ join brings both together.

⋈Join

Purpose: Waits until all paths leading into it have arrived, then continues with all results together.
Inputs & outputs: Any number of inputs – there is always one free more. One output.
Settings: Name.
Example: AND split → two paths → join → tester.

⧉Parallel group

Purpose: Several agents work on the same hand-over at the same time; ✔ only if all agree.
Inputs & outputs: One input. ✔ (all succeeded) and ✖ (at least one reports defects – all defects collected).
Settings: Drag agents in, own instructions and model per member.
Example: Review, security check and tests at once after the implementation.

⟳Loop

Purpose: Works through a list – one pass through the loop body per item.
Inputs & outputs: Inputs Input (the list) and Loop (return from the body). Outputs Result (top: continue once all items are done – all results as one hand-over) and Item (bottom: into the body). The body – an agent, several nodes or a sub-process – must lead back to Loop; the editor reports a loop that isn't closed as an error.
Settings: Rule for the list (e.g. “one item per plugin”), one after another or in parallel with a maximum, a safety limit for the count, notes per item, and what happens to failed items: continue via Result (noted) or ask you (retry, continue anyway, abort). If a task list arrives, every requirement is an item – in dependency order.
Example: Market analyst → loop “per plugin” → Item → researcher → back to Loop; Result → lead sums up.

⊞Sub-process

Purpose: Runs another process completely – with its own orchestrator, agents and goal.
Inputs & outputs: One input. ✔ (the sub-process reached its goal) and ✖.
Settings: Which process, instructions and success criterion. In the full flow view you open it live.
Example: The “documentation” process at the end of development.

⚑Message

Purpose: Info, warning or error for you – in the cockpit, the web UI, the requirement log and spoken.
Inputs & outputs: One input (usually at a ✖), one output.
Settings: Level, text and behaviour: continue, or halt until you decide (continue, retry, end). Theron adds the details automatically.
Example: Loop with failed items → warning “not researched”, then continue.

☰Task list

Purpose: Creates, fills or reads a task list and hands it on – typically to a loop that builds every open requirement. That way a whole process can turn a concept into a task list with epics and requirements and build it right away.
Inputs & outputs: One input, one output.
Settings: Four kinds:
Temporary – the AI drafts it: epics and requirements from the input (with hints for it). Visible under TASKS as “(Temp.)”; removed when the process completes.
Temporary – copy: copies a chosen list; the original stays unchanged.
Write into a task list: the AI turns the input – e.g. a concept – into epics and requirements and writes them into a lasting list: a chosen one, or one the step creates in the task's project under the given name (if it exists already, it is added to; without a name the AI suggests one). Epics of the same name are added to instead of duplicated, nothing already there is repeated.
Read a task list (source): hands on an existing list – from another project, too. That way the process doesn't depend on a project.
With lasting lists the loop keeps status and result right in the list.
Example: Concept agent → task list “write into a task list: Implementation” → loop → Item → developer → reviewer → back to Loop.

◉Save memory

Purpose: Keeps results beyond this run and this process. The core model summarises the incoming hand-overs and stores them under a name.
Inputs & outputs: One input, one output (hands the summary on).
Settings: Name (free text), what to keep, and “add instead of replace”. In the node you can switch between saving and reading at any time.
Example: At the end of the market research: save memory “heat pump market data”.

◉Read memory

Purpose: Hands a stored memory on as context – or reports that it isn't available (yet).
Inputs & outputs: One input, one output: the memory (with its date) together with the incoming hand-overs.
Settings: Name – one of the existing memories (including those other processes write).
Example: Offer: read memory → condition “memory available” → offer writer; else → sub-process “market research” → save memory → back to read memory.

▤Database

Purpose: A named collection of entries that processes write and read – across runs and processes. Every entry has a key (e.g. a company name or a URL) and free fields.
Inputs & outputs: One input, one output. Write hands on what was created or updated; read hands on all matching entries.
Settings: Database (existing or new), write or read; for writing, what the key is and which fields to keep (existing entries are updated, fields not mentioned stay), for reading an optional condition in words. You see and edit the entries under DATABASES (with CSV export); optionally they are synchronised via the Theron server.
Example: Read database “companies” → researcher fills in what is missing → write database “companies” (key: company name).

◎Goal

Purpose: The end of the process. Theron checks the goal (definition of done) and sums up.
Inputs & outputs: Inputs from every step that finishes (an open ✔ leads here as well).
Settings: You set the goal in the process properties (click on free canvas space).

Task lists & Konzepter

Process per task list (optional): in the task list's form under Process you choose which process its epics are built with – the default is “Like the project”. So, e.g., the design epics run through the design process and the backend epics through development. If Theron starts a task list with another process in the conversation, it runs as a task of its own. Templates pass their process on to the lists made from them; temporary task lists always run inside the process that made them.
Task lists (TASKS) consist of epics with requirements: description, acceptance criteria, technical rules, dependencies and protocol.
Work through: in the cockpit ▶ Task list. Every requirement goes through the complete process; dependent ones start once their prerequisites are done. Within an epic the agents keep their context.
Status: open, in progress, HitL (waiting for you), done, failed, skipped, closed.
✦ Konzepter: a chat per task list. It challenges your concept and creates epics and requirements – later too, e.g. for bugs. It only changes open requirements and only deletes what is closed.
Templates: “Save as template …” makes a list reusable, with parameters (folder, file, text, choice) and placeholders like {{customer}}. ▶ New task list from template … asks for the values.

Core model – without Claude

The core model is the model behind Theron itself: orchestrator, THERON assistant, Konzepter, AI drafts, the check of web answers and announcements. Under Settings → Core model you choose:

Claude (default) – through the Claude CLI.
Local model (from OpenCode) – Theron talks directly to the OpenAI-compatible API of the provider in ~/.config/opencode/opencode.json (e.g. Ollama or LM Studio) and runs its tools itself. The model must support tool calls (e.g. qwen3-coder). A different address is optional; Test connection checks the model.

If the agents run through OpenCode as well, Theron works entirely without Claude. Agents drafted by the AI then get OpenCode with the core model automatically. The Claude limits don't hold up a local orchestrator.

Usage & limits

The status bar shows your Claude usage for the 5-hour window and the week, with reset time and cost. Details shows the full output. ↻ Refresh fetches the numbers right away. In slave mode they come from the worker's Claude subscription.
Your own limits (Settings → Engines): when usage reaches the value, Theron pauses. Running agents are stopped and continue right there after the reset; new Claude calls wait. Local OpenCode models are not affected.

Voice

Voice input: the microphone button next to every input field, or ⌘/Ctrl + Shift + Space. Recognition runs locally with Whisper; no audio leaves your computer. Model, language, microphone (with test) and technical terms are set in the settings.
Theron speaks: announcements of status changes with a neural voice (Piper, local) in English, German, Dutch or French, male or female – phrased naturally by AI if you like. Previews play without a download. Words of another language (e.g. “Entwickler” in an English sentence) are spoken phonetically in their own language; under Pronunciation you add your own entries (word = de, word = as spoken or word = [[IPA]]). “Theron” is always pronounced the English way. 🔊/🔇 in the status bar mutes at once.

Connecting the Theron server

Settings → Theron server: enter the address and the client token and switch on “Synchronise status live”. At the bottom of the sidebar SERVER shows the connection.
Security level for input from the web: no input, predefined answers only, or free input with a security check – the check runs on your computer before Theron gets the answer.
Synchronise processes and agents – optionally with knowledge, memories and databases. ⟳ SYNC at the bottom of the sidebar shows the state.
Installation, web UI and library in detail: Server.

Slave: Theron on another machine

Settings → Slave: host, port and token of a Theron running there with theron --listen or as a headless worker; “Check connection” shows its fingerprint. The app restarts and then controls the slave – tasks, THERON and every model call run there, even while the app is closed.
Setting up the slave, Docker and Kubernetes: CLI · headless.

Console

Settings → Console sets up the theron command on this computer. All about it: CLI · headless.

Local API

For your own scripts on this computer: create projects, start and answer tasks, fill task lists and react to events. Enable it under Settings → Local API. All details in the API documentation.

Continue after a restart

If Theron is quit or crashes in the middle of a task, it shows the interrupted tasks on the next start and offers ▶ Continue. The orchestrator and the agents resume their sessions and know their context – with a local core model too; interrupted agents are told they were in the middle of their work. Open questions are asked again.

Privacy

What happens in Theron doesn't leave your computer – except to your own Theron server and to the models your agents work with (Claude or your local model). Telemetry, error and crash reports and auto-updates are switched off in every component: Claude Code, OpenCode, onnxruntime (neural voice, speech recognition) and Hugging Face. Speech recognition and the voice run locally; voices and speech models are only downloaded once.

Settings & data

App language (English, German – switching restarts Theron), core model, global rules (apply to every agent), engines and limits, server, local API, voice input and voice output.
Plugins: upload plugins, switch them on and off, open their settings and log. Plugins bring their own navigation entries, settings, process nodes (in the editor under TOOLS) and integrations – see Plugins.
Data: macOS ~/Library/Application Support/Theron/, Windows %APPDATA%\Theron\, Linux ~/.local/share/theron/.
Reset everything … deletes projects, tasks, processes, agents and task lists; settings and the files in the working folders stay.
All areas can be resized with the splitters; Theron remembers the sizes and reopens the project you used last.

Keyboard shortcuts

⌘/Ctrl + Enter	Send a message
⌘/Ctrl + Shift + Space	Start / stop dictation
⌘/Ctrl + V	Paste an image or file as attachment
⌘/Ctrl + A	Process editor: select all nodes
⌘/Ctrl + / − / 0	Process editor: zoom / 100 %
Delete / ⌫	Process editor: delete the selection