> **Hinweis (2026-07-05):** Beschreibt das **Zielbild**, nicht den Implementierungsstand. Ist-Stand: [`Kairo_Implementation_Truth_Table_v0.1.md`](../product/Kairo_Implementation_Truth_Table_v0.1.md). v0.2 wird explizite Implementierungs-Marker pro Kapitel ergänzen.
**Zweck:** Beschreibung des angedachten späteren Zielzustands von Kairo als System, unabhängig von konkreten Implementierungsschnitten.
---
## 1. Executive Summary
Kairo ist langfristig keine einfache Aufgabenliste, keine reine Projektmanagement-App, kein Roadmap-Tool und keine freie Workflow-Automatisierungsplattform.
Kairo ist eine:
```text
adaptive, methodengeführte Entwicklungs- und Steuerungsplattform
```
Der Kern ist ein:
```text
Method-driven Adaptive Steering Core
```
Kairo soll unterschiedliche Entwicklungs- und Steuerungskontexte führen können:
```text
- Software- und Produktentwicklung
- Buch- und Content-Entwicklung
- Programmsteuerung
- Projekt- und Initiativensteuerung
- persönliche Entwicklung
- Reifegradentwicklung
- Lernpfade
- Routinen / Betrieb
- Review- und Auditkontexte
- Agentenläufe
- KI-/Tool-gestützte Steuerung
```
Die zentrale Leitfrage lautet:
```text
Welcher nächste Schritt bringt diesen steuerbaren Kontext jetzt am wirksamsten voran?
```
---
## 2. Grundverständnis
Kairo steuert nicht nur Aufgaben.
Kairo steuert Entwicklungen.
Eine Entwicklung kann sein:
```text
- ein Produkt
- ein Programm
- ein Projekt
- eine Initiative
- ein Buch
- eine Fähigkeit
- ein Reifegradziel
- eine Routine
- ein Review
- ein Audit
- ein Agentenauftrag
```
Kairo hält dabei fest:
```text
- Was soll entwickelt werden?
- Warum ist es relevant?
- Welche Methode gilt?
- Welche Struktur braucht diese Methode?
- Wo steht der Kontext aktuell?
- Was fehlt?
- Was blockiert?
- Was braucht Aufmerksamkeit?
- Was ist der nächste wirksame Schritt?
- Wer oder welcher Agent soll handeln?
- Worauf wartet Kairo?
- Welche Nachweise, Reviews oder Entscheidungen sind nötig?
- Wann wird angepasst, eskaliert oder abgeschlossen?
```
---
## 3. Produktidentität
Kairo ist:
```text
System of Record
Steering Authority
Actor-/Tenant-sicherer Kontextgeber
methodengeführter Steuerungskern
Roadmap- und Entwicklungsstrukturmodell
Signal- und NextAction-System
später Workflow-/Agenten-/Tool-orchestrierend
```
Kairo ist nicht:
```text
freie Workflow-Plattform
beliebiger Automatisierungsbaukasten
reines Projektmanagementsystem
reine To-do-Liste
reines Roadmap-Tool
reine KI-Agentenplattform
reines Prompt-System
```
---
## 4. Kernmodell
Das Zielmodell:
```text
Steerable Object
→ Steering Context
→ Steering Method
→ Standard Lifecycle / Method Lifecycle
→ Hook Slugs
→ Structure Builder
→ Signal Rules
→ NextAction Strategy
→ Assignment Strategy
→ Waiting / Reminder / Escalation Strategy
→ Result Intake
→ Evidence / Review / Decision
→ Adaptation / Closure
→ optionale Workflow-Fragmente
→ optionale Human / Agent / LLM / Tool Steps
```
---
## 5. Method-driven Adaptive Steering Core
Der Adaptive Steering Core ist der fachliche und technische Kern von Kairo.
Er führt steuerbare Kontexte durch methodengeführte Steuerungsabläufe.
Typischer Ablauf:
```text
1. Ziel / Entwicklungsabsicht erfassen
2. Name, Scope und Kontext definieren
3. passende Basismethode wählen oder vorschlagen
4. gemäß Methode eine Steuerungsstruktur erzeugen
- Roadmap
- Backlog
- WBS
- Reifegradpfad
- Kapitelstruktur
- Feature Landscape
- WorkCycles
- Review Gates
5. Next Best Action ableiten
6. Actor zuweisen
7. auf Ergebnis, Rückmeldung, Termin oder Ereignis warten
8. erinnern, eskalieren oder nachsteuern
9. Ergebnis zurückführen
10. prüfen, reviewen, adaptieren oder abschließen
```
Dieser Ablauf ist der methodengeführte Steuerungsworkflow.
Er ist nicht gleichbedeutend mit einer freien technischen Workflow Engine.
---
## 6. Standard Lifecycle
Kairo besitzt einen minimalen Standard Lifecycle als gemeinsame Basis.
```text
intake
method_selection
structure_setup
planning
action_selection
assignment
waiting
result_intake
validation
review
adaptation
closure
```
Methoden können diesen Lifecycle:
```text
- verwenden
- teilweise überspringen
- spezialisieren
- erweitern
- eigene Hooks ergänzen
```
Der Standard Lifecycle ist kein starrer Projektprozess, sondern ein gemeinsames Steuerungsraster.
---
## 7. Steering Methods
Eine Methode ist kein Label, sondern ein registriertes Steuerungspaket.
Eine Methode definiert:
```text
- supported_domains
- supported_scope_types
- default_lifecycle
- required_structures
- allowed_structures
- hook_slugs
- structure_builders
- attention_rule_providers
- next_action_strategy
- assignment_strategy
- waiting_strategy
- reminder_strategy
- escalation_strategy
- result_intake_strategy
- review_strategy
- evidence_policy
- closure_policy
- allowed_workflow_fragments
- allowed_node_types
- default_configuration
```
Methoden werden zunächst built-in und code-first angelegt, später versioniert und begrenzt konfigurierbar.
Langfristig können Method Profiles entstehen.
---
## 8. Method Registry
Kairo benötigt eine Method Registry.
Sie funktioniert ähnlich einem Widget-System:
```text
Eine Methode meldet sich mit Slug, Version, unterstützten Domains,
Lifecycle, Hooks, Structure Builders, Strategies und Policies an.
Der Steuerungskern endet nicht mit dem Erzeugen einer Action.
Kairo muss steuern:
```text
- Actor auswählen
- Actor zuweisen
- auf Ergebnis warten
- Fälligkeit überwachen
- erinnern
- eskalieren
- externe Ereignisse aufnehmen
- Agentenergebnisse zurückführen
```
Actors können sein:
```text
human
agent
working_group
external_system
```
---
## 19. Result Intake / Evidence / Review / Decision
Kairo führt Ergebnisse zurück und entscheidet, was daraus folgt.
Mögliche Rückführungen:
```text
- Action erledigt
- Ergebnis unvollständig
- Evidence erforderlich
- Review erforderlich
- Decision erforderlich
- Blocker entstanden
- RoadmapItem erreicht
- Reifegrad plausibel erhöht
- neue NextAction nötig
```
Evidence, Reviews und Decisions sind zentrale Qualitätssicherungs- und Steuerungsobjekte.
---
## 20. Workflow-Fragmente und Runtime
Kairo soll langfristig Workflow-Fähigkeit haben.
Aber:
```text
Workflows sind methodengeführte Steuerungsabläufe,
keine beliebige freie Automatisierungsplattform als Produktkern.
```
Zielmodell:
```text
Hook
→ Workflow Fragment
→ Node / Step
→ Result
→ Rückführung in Kairo
```
Workflow-Fragmente können später enthalten:
```text
human_task
approval
decision_gate
review
reflection
llm_prompt
agent_task
tool_call
state_transition
evidence_check
dod_check
dependency_analysis
notification
reminder
escalation
```
---
## 21. Agenten / LLMs / Tools
Kairo bleibt Steering Authority.
Agenten, LLMs und Tools sind Provider.
Sie können später an Hooks und Workflow-Fragmente angebunden werden.
Grundsatz:
```text
Kairo entscheidet Kontext, Methode, Auftrag und Rückführung.
Agenten / LLMs / Tools führen einzelne Steps aus.
```
Agenten sind Actors.
Das ist wichtig für:
```text
- Verantwortlichkeit
- Audit
- Assignments
- Sichtbarkeit
- Tenant-Kontext
```
---
## 22. Security / Governance / Audit
Kairo muss tenant- und actor-sicher bleiben.
Grundsätze:
```text
- tenant_id immer aus TenantContext
- keine tenant_id aus Client Input vertrauen
- Actor-Bezüge tenant-intern validieren
- Capabilities prüfen
- Router dünn
- Services schreiben
- Data Layer liest
- Audit-by-design
- Signals und NextActions erklärbar
- Agentenaktionen nachvollziehbar
```
---
## 23. UI-Zielbild
Die UI dient als Steuerungs- und Interaktionsschicht.
Langfristige Views:
```text
Workspace
Steering View
Roadmap View
Method View
Attention / NextAction View
Backlog View
Action View
Waiting / Reminder View
Evidence / Review / Decision View
Workflow Run View später
Method/Profile Admin später
Agent Run View später
```
Die UI darf nicht die Methode hart kodieren.
Sie muss methodenbewusst und strukturgetrieben sein.
---
## 24. Architektur-Evolutionslinie
Grobe Evolutionslinie:
```text
1. Existing Foundation
2. Adaptive Steering Core Foundation
3. Method Registry / Hook Registry / Standard Lifecycle
4. Roadmap / Structure Builder Foundation
5. Signal / NextAction Engine
6. Assignment / Waiting / Reminder / Escalation
7. Evidence / Review / Decision
8. Workflow Fragments and Bindings
9. Workflow Runtime
10. Agent / LLM / Tool Providers
11. Method Profiles
12. Method Designer / Advanced Configuration
13. Advanced AI Steering / Next Best Action Ranking
```
Dies ist keine Sprintplanung, sondern ein Zielbild der technischen Entwicklung.
---
## 25. Zielzustand in einem Satz
Kairo soll ein methodengeführter adaptiver Steuerungskern werden, der Entwicklungen unterschiedlichster Art über registrierbare Methoden, gemeinsame Kernstrukturen, Roadmaps, Hooks, Signals, NextActions, Assignments, Waiting-/Reminder-/Escalation-Mechanismen und später Agent-/Workflow-Fragmente wirksam und nachvollziehbar steuert.
