---
title: "Hermes Kanban einrichten: Task-Boards für Multi-Agent-KI-Workflows"
description: "So richtest du Hermes Kanban ein und nutzt es – das integrierte Task-Board-System, das strukturiertes Projektmanagement in KI-Agent-Workflows bringt."
date: 2026-05-04
categories: ["ai"]
tags: ["hermes-agent","kanban","ai-agents"]
---

Hermes Kanban ist ein Board-System, das direkt in [Hermes Agent](/hermes-agent-setup-guide/) eingebaut ist. Damit verwaltest du Tasks visuell, verfolgst den Fortschritt über mehrere KI-Agenten hinweg und koordinierst komplexe, mehrstufige Workflows. Statt alles über den Chat laufen zu lassen, gibt dir Kanban eine strukturierte Art, Arbeit zu planen, zuzuweisen und zu überwachen – mit einem visuellen Board, das du im integrierten [Dashboard](/hermes-dashboard-guide/) oder in [Hermes-Dashboards](/de/beste-hermes-dashboards/) von Drittanbietern einsehen kannst.

Dieser Guide behandelt das Setup, tägliche Nutzungsmuster, die Entscheidung zwischen Kanban und delegate_task sowie praktische Multi-Agent-Workflows.

![Hermes Kanban Setup-Guide](@assets/images/25/05/hermes-kanban-setup-guide.svg)

## Was ist Hermes Kanban?

Hermes Kanban ist ein **SQLite-basiertes Task-Management-System**, das neben dem Hermes-Gateway läuft. Es bietet:

- **Visuelle Task-Boards** mit Spalten für verschiedene Status (Backlog, Todo, In Progress, Review, Done)
- **Task-Übergaben zwischen Agenten** – weise Tasks bestimmten Agenten zu oder lass sie aus einer Queue wählen
- **Fortschritts-Tracking** – sieh, welcher Agent woran arbeitet und wie lange Tasks dauern
- **Persistenten Verlauf** – alle Statusänderungen werden mit Zeitstempel und Agent-IDs geloggt
- **Dashboard-Integration** – Boards in Hermes WebUI, Scarf, ClawdBoard und anderen ansehen und verwalten

Stell es dir wie Jira oder Trello vor, aber gebaut für KI-Agenten, die zusammenarbeiten.

**Hermes v0.1.2+**

Kanban wurde mit Hermes Agent v0.1.2 eingeführt. Stell sicher, dass du eine aktuelle Version laufen hast. Prüfen kannst du das mit `hermes --version`.

## Kanban vs. delegate_task: Wann welches?

**Schnellvergleich**

| Feature | Kanban-Board | delegate_task |
|---|---|---|
| **Am besten für** | Mehrstufige Projekte, Team-Koordination | Einzelne Tasks, schnelle Delegation |
| **Sichtbarkeit** | Visuelles Board, kompletter Verlauf | Chatbasiert, flüchtig |
| **Task-Tracking** | Persistent, zustandsbehaftet | Inline, nach der Session weg |
| **Multi-Agent** | Eingebaute Koordination | Manuelle Koordination |
| **Overhead** | Höher (Board-Setup) | Geringer (ein Befehl) |
| **Einsatz, wenn** | 3+ zusammenhängende Tasks, Überblick nötig | Einmal-Task, einfache Delegation |

**Nutze Kanban, wenn:**

- Du ein Projekt mit mehreren zusammenhängenden Tasks hast (z. B. „eine REST-API bauen" mit Auth, Endpoints, Tests, Docs)
- Mehrere Agenten koordinieren müssen (einer schreibt Code, ein anderer reviewed, ein dritter testet)
- Du den Fortschritt über die Zeit verfolgen und sehen willst, was fertig wurde
- Tasks Abhängigkeiten haben (kein Deploy, bevor die Tests grün sind)

**Nutze delegate_task, wenn:**

- Du eine schnelle Antwort oder eine einzelne Arbeitseinheit brauchst
- Der Task in sich abgeschlossen ist und kein Follow-up braucht
- Du mitten in einer Konversation bist und den Flow behalten willst

**Die beiden arbeiten zusammen**

Du kannst delegate_task nutzen, um einen Kanban-Task einem bestimmten Agenten zuzuschieben. Kanban ist die Planungsebene; delegate_task ist der Ausführungsmechanismus.

## Voraussetzungen

Bevor du Kanban einrichtest, stell sicher, dass du Folgendes hast:

- Hermes Agent v0.1.2 oder neuer installiert

- Hermes-Gateway läuft (`hermes gateway start`)

- Ein Dashboard installiert (optional, aber empfohlen) – siehe [Hermes Dashboard Guide](/hermes-dashboard-guide/)

- Ein kostenloses Modell konfiguriert, wenn du Kosten vermeiden willst – siehe [Beste günstige Modelle für Hermes Agent](/de/guenstige-hermes-agent-modelle/)

## Schritt 1: Kanban in der Gateway-Config aktivieren

Kanban ist in aktuellen Hermes-Versionen standardmäßig aktiviert. Prüfe, ob es aktiv ist:

```bash
# Check if Kanban is enabled
hermes kanban status
```

Falls nicht, füge es deiner Gateway-Config hinzu:

```yaml
# ~/.hermes/gateway.yaml
kanban:
  enabled: true
  default_board: "main"
  auto_archive: true
  archive_after_days: 30
```

Starte das Gateway neu, um die Änderung zu übernehmen:

```bash
hermes gateway restart
```

## Schritt 2: Dein erstes Board erstellen

```bash
# Create a new board
hermes kanban create-board "My Project"

# List all boards
hermes kanban boards

# Set default board
hermes kanban set-default "My Project"
```

Jedes Board hat Spalten, die Task-Status darstellen. Die Standardspalten sind:

| Spalte | Zweck |
|---|---|
| **Backlog** | Tasks, die noch nicht eingeplant sind |
| **Todo** | Tasks, die bereit zur Bearbeitung sind |
| **In Progress** | Wird gerade bearbeitet |
| **Review** | Wartet auf Review oder Test |
| **Done** | Abgeschlossene Tasks |

## Schritt 3: Tasks hinzufügen

```bash
# Add a task to the default board
hermes kanban add "Implement user authentication"

# Add with priority and assignee
hermes kanban add "Write API tests" --priority high --assignee "test-agent"

# Add to a specific column
hermes kanban add "Update README" --column backlog

# Add with description
hermes kanban add "Set up CI/CD pipeline" \
  --description "Configure GitHub Actions for automated testing and deployment" \
  --priority medium
```

### Task-Eigenschaften

Jeder Task unterstützt diese Eigenschaften:

- **title** – was zu tun ist
- **description** – detaillierte Anforderungen
- **priority** – low, medium, high, critical
- **assignee** – welcher Agent (oder welche Person) daran arbeiten soll
- **column** – in welcher Board-Spalte der Task startet
- **tags** – Labels zum Filtern (z. B. `backend`, `frontend`, `docs`)
- **due_date** – wann der Task fertig sein soll
- **depends_on** – Task-IDs, die zuerst abgeschlossen sein müssen

## Schritt 4: Tasks durchs Board bewegen

```bash
# Move a task to a different column
hermes kanban move "Implement user authentication" --to "In Progress"

# Move by task ID
hermes kanban move #12 --to "Review"

# Bulk move all tasks with a tag
hermes kanban move --tag backend --to "Done"
```

### Automatische Statusübergänge

Hermes Kanban kann Tasks automatisch verschieben, wenn Agenten Aktionen ausführen:

- Wenn ein Agent die Arbeit an einem Task beginnt → wechselt zu **In Progress**
- Wenn ein Agent Code zum Review einreicht → wechselt zu **Review**
- Wenn ein Reviewer approved → wechselt zu **Done**
- Wenn ein Reviewer Änderungen anfordert → zurück zu **In Progress**

Konfiguriert wird das im Profil des Agenten:

```yaml
# ~/.hermes/agents/coder.yaml
kanban:
  auto_move: true
  pick_from: "Todo"
  move_to_on_start: "In Progress"
  move_to_on_complete: "Review"
```

## Schritt 5: Das Board anzeigen

### CLI-Ansicht

```bash
# Show the board in terminal
hermes kanban show

# Show a specific board
hermes kanban show "My Project"

# Show only high-priority tasks
hermes kanban show --priority high

# Show tasks assigned to a specific agent
hermes kanban show --assignee "test-agent"
```

### Dashboard-Ansicht

Das Kanban-Board ist auch im [Hermes-Dashboard](/hermes-dashboard-guide/) verfügbar. Öffne dein Dashboard und wechsle zum Kanban-Tab, um Folgendes zu sehen:

- Drag-and-Drop-Task-Management
- Echtzeit-Updates, während Agenten Tasks verschieben
- Task-Details mit kompletter Historie
- Filter nach Agent, Priorität oder Tag

Für die beste visuelle Erfahrung haben sowohl [Hermes WebUI (EKKO)](/de/beste-hermes-dashboards/) als auch [Hermes WebUI (nesquena)](/de/beste-hermes-dashboards/) ausgezeichnete Kanban-Ansichten mit Drag-and-Drop-Support.

## Multi-Agent-Task-Workflows

Hier sind praktische Muster, um mehrere Agenten zu koordinieren.

### Muster 1: Code → Review → Deploy-Pipeline

Richte drei Agenten mit unterschiedlichen Rollen ein:

```yaml
# ~/.hermes/agents/coder.yaml
name: "Coder"
role: "Writes code based on task descriptions"
kanban:
  pick_from: "Todo"
  move_to_on_complete: "Review"

# ~/.hermes/agents/reviewer.yaml
name: "Reviewer"
role: "Reviews code quality and correctness"
kanban:
  pick_from: "Review"
  move_to_on_approve: "Ready to Deploy"
  move_to_on_reject: "Todo"

# ~/.hermes/agents/devops.yaml
name: "DevOps"
role: "Handles deployment and infrastructure"
kanban:
  pick_from: "Ready to Deploy"
  move_to_on_complete: "Done"
```

Füge Tasks zum Board hinzu und lass die Agenten sie sich holen:

```bash
hermes kanban add "Build login endpoint" --priority high
hermes kanban add "Build user profile endpoint" --priority medium
hermes kanban add "Add rate limiting" --priority high

# Agents automatically pick up and process tasks
hermes kanban watch  # Monitor progress in real-time
```

### Muster 2: Parallele Recherche mit Aggregation

Wenn mehrere Agenten verschiedene Aspekte eines Problems recherchieren sollen:

```bash
# Create research tasks
hermes kanban add "Research authentication best practices" --assignee "researcher-1" --tag research
hermes kanban add "Research database scaling patterns" --assignee "researcher-2" --tag research
hermes kanban add "Research caching strategies" --assignee "researcher-3" --tag research

# Create an aggregation task that depends on all research
hermes kanban add "Write technical design document" \
  --assignee "architect" \
  --depends-on "Research authentication best practices,Research database scaling patterns,Research caching strategies" \
  --priority high
```

Der Architect-Agent holt sich seinen Task erst, wenn alle drei Recherche-Tasks als erledigt markiert sind.

### Muster 3: Iterativer Entwicklungszyklus

Für Tasks, die mehrere Runden an Verbesserung brauchen:

```yaml
# ~/.hermes/agents/fullstack.yaml
kanban:
  pick_from: "Todo"
  move_to_on_complete: "Testing"
  max_iterations: 3
  on_test_failure: "Todo"
```

Das erzeugt eine Schleife: Todo → Testing → (bei fehlgeschlagenen Tests) → Todo, bis zu 3-mal. Nach 3 Fehlschlägen wandert der Task in eine „Blocked"-Spalte für menschliches Eingreifen.

## Erweiterte Features

### Task-Abhängigkeiten

Tasks können von anderen Tasks abhängen. Ein abhängiger Task ist nicht zuweisbar, bis seine Abhängigkeiten erledigt sind:

```bash
# Create a task with dependencies
hermes kanban add "Deploy to production" \
  --depends-on "Write tests,Code review pass,Security audit"

# View dependency graph
hermes kanban dependencies "Deploy to production"
```

### Filtern und Ansichten

```bash
# Filter by multiple criteria
hermes kanban show --priority high --assignee coder --tag backend

# Show only blocked tasks
hermes kanban show --status blocked

# Show tasks due this week
hermes kanban show --due-before "2026-05-10"

# Export board as JSON
hermes kanban export --format json > board.json
```

### Board-Templates

Für wiederkehrende Projekttypen erstellst du Board-Templates:

```bash
# Save current board as template
hermes kanban save-template "web-app" --board "My Project"

# Create new board from template
hermes kanban create-board "New App" --template "web-app"
```

Übliche Templates sind:
- **web-app**: Auth, API, Frontend, Tests, Deploy
- **data-pipeline**: Extract, Transform, Validate, Load, Monitor
- **bug-fix**: Reproduce, Diagnose, Fix, Test, Verify

### Benachrichtigungen

Lass dich benachrichtigen, wenn Tasks den Status wechseln:

```yaml
# ~/.hermes/gateway.yaml
kanban:
  notifications:
    on_task_complete: true
    on_task_blocked: true
    on_task_overdue: true
    channel: "slack"  # or "discord", "email"
```

## Praxisbeispiel: Eine REST-API bauen

Hier ist ein kompletter Workflow für den Bau einer REST-API mit Kanban:

```bash
# 1. Create the board
hermes kanban create-board "REST API Project"

# 2. Add all tasks
hermes kanban add "Design database schema" --priority high --tag design
hermes kanban add "Set up project structure" --priority high --tag setup
hermes kanban add "Implement user model" --priority high --tag backend --depends-on "Design database schema"
hermes kanban add "Implement auth endpoints" --priority high --tag backend --depends-on "Implement user model"
hermes kanban add "Implement CRUD endpoints" --priority medium --tag backend --depends-on "Implement user model"
hermes kanban add "Write unit tests" --priority medium --tag testing --depends-on "Implement auth endpoints,Implement CRUD endpoints"
hermes kanban add "Write integration tests" --priority medium --tag testing --depends-on "Implement auth endpoints,Implement CRUD endpoints"
hermes kanban add "Set up CI/CD" --priority low --tag devops
hermes kanban add "Write API documentation" --priority low --tag docs --depends-on "Implement CRUD endpoints"
hermes kanban add "Deploy to staging" --priority medium --tag devops --depends-on "Write unit tests,Write integration tests"

# 3. Assign agents
hermes kanban assign "backend" --tag backend
hermes kanban assign "tester" --tag testing
hermes kanban assign "devops" --tag devops

# 4. Watch progress
hermes kanban watch
```

Jeder Agent holt sich Tasks in Abhängigkeitsreihenfolge, arbeitet sie ab und schiebt sie weiter. Den Fortschritt prüfst du jederzeit mit `hermes kanban show` oder über das Dashboard.

## Tipps für effektive Kanban-Nutzung

- **Halte Tasks klein** – wenn ein Task mehr als 30 Minuten Agentenzeit braucht, zerlege ihn

- **Setze Abhängigkeiten mit Bedacht** – nicht überbeschränken; unabhängige Tasks sollen parallel laufen

- **Richte Auto-Archive ein** – halte das Board sauber, indem erledigte Tasks automatisch archiviert werden

- **Nutze Tags konsistent** – leg eine Tag-Taxonomie fest und bleib dabei

- **Beobachte blockierte Tasks** – prüfe regelmäßig `hermes kanban show --status blocked`

- **Nutze das Dashboard** – auf dem visuellen Board erkennst du Engpässe viel leichter als in der CLI-Ausgabe

- **Starte mit Templates** – bau Boards nicht jedes Mal von Grund auf neu

## Troubleshooting

**Kanban-Befehle nicht gefunden**

Stell sicher, dass du Hermes Agent v0.1.5 oder neuer laufen hast. Aktualisieren mit:

```bash
hermes update
hermes --version
```

Wenn Kanban immer noch nicht verfügbar ist, prüfe, ob es in deiner Gateway-Config aktiviert ist (`~/.hermes/gateway.yaml`).

**Tasks werden nicht von Agenten aufgegriffen**

Prüfe, ob:
1. Der Agent läuft und mit dem Gateway verbunden ist
2. Die `pick_from`-Spalte des Agenten zu der Spalte passt, in der die Tasks liegen
3. Die Kanban-Config des Agenten `auto_pick: true` enthält
4. Die Task-Abhängigkeiten erfüllt sind

Agent-Status prüfen mit:
```bash
hermes agents status
hermes kanban show --column "Todo"
```

**Board erscheint nicht im Dashboard**

Lade die Dashboard-Seite neu. Wenn der Kanban-Tab immer noch nicht auftaucht:
1. Stell sicher, dass dein Dashboard Kanban unterstützt (Hermes WebUI v0.3+, Scarf v1.2+)
2. Prüfe, ob das Gateway läuft: `hermes gateway status`
3. Versuche, den Dashboard-Dienst neu zu starten

**Wie lösche ich ein Board?**

```bash
# Archive a board (recommended — preserves history)
hermes kanban archive-board "My Project"

# Delete a board permanently
hermes kanban delete-board "My Project" --confirm
```

Archivieren ist besser als Löschen – ein archiviertes Board kannst du später jederzeit wiederherstellen.

## Wie geht es weiter?

Wenn Kanban eingerichtet ist, schau dir diese verwandten Guides an:

- [Hermes Agent Setup Guide](/hermes-agent-setup-guide/) – falls du Hermes noch nicht installiert hast, fang hier an
- [Hermes Dashboard Guide](/hermes-dashboard-guide/) – konfiguriere das integrierte Dashboard, um deine Kanban-Boards visuell zu sehen
- [Beste Hermes-Dashboards](/de/beste-hermes-dashboards/) – Drittanbieter-Dashboards mit Kanban-Support (Hermes WebUI, Scarf etc.)
- [Beste günstige Modelle für Hermes Agent](/de/guenstige-hermes-agent-modelle/) – kostenlose und bezahlbare Modelle für deine Agenten

Nach dem initialen Board-Setup übernimmt Kanban den Großteil der Koordination von allein. Fang einfach an – ein Board mit ein paar Tasks – und bau von dort aus weiter, während du ein Gefühl dafür bekommst, wie Agenten Arbeit aufnehmen und weiterschieben.

[Mehr KI-Tool-Guides](/categories/ai/)