Communitygithub.com

Tick Multi-Agent-Koordination

Koordiniere Arbeit zwischen menschlichen und KI-Agenten mit strukturierten Markdown-Dateien. Benutzer interagieren natürlich mit dir, und du verwaltest Aufgaben transparent in der TICK.md.

Was ist Tick Multi-Agent-Koordination?

Dieses Skill ermöglicht es einem KI-Agenten, als vollwertiges Mitglied eines Multi-Agenten-Teams zu agieren, das Aufgaben über ein einfaches, auf Markdown und Git basierendes Protokoll namens Tick koordiniert. Es funktioniert, indem es eine menschenlesbare, maschinenparsbare Datei (TICK.md) im Projekt verwaltet, die den gesamten Aufgabenbestand, Zuständigkeiten und Verlauf enthält. Der Skill wird durch ein CLI-Tool namens `tick` (als lokale Befehle) oder durch MCP-Tools (Model Context Protocol) für KI-Editoren wie Claude Code, Cursor oder Codex genutzt. Nach der Installation (`tick init` und `tick agent register`) kann der Agent Aufgaben mit `tick add` erstellen, mit `tick claim` übernehmen, mit `tick comment` kommentieren und mit `tick done` abschließen. Der Skill erzwingt Sicherheitsgrenzen: Schreibzugriff auf Git (`tick sync --push`) erfordert explizite Benutzerzustimmung. Er bietet außerdem Abhängigkeitsmanagement, Rollback-Funktionen (`tick undo`), Batch-Operationen und Echtzeit-Überwachung. Dadurch eignet er sich ideal für komplexe Entwicklungsprojekte, bei denen mehrere Agenten und Menschen zusammenarbeiten und der Überblick über Aufgaben, Abhängigkeiten und Fortschritte in einem vollständig versionierten, lokalen Arbeitsablauf erhalten bleiben muss.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Purple-Horizons/tick-md/tree/main/clawhub-skill
Original anzeigen→Alle Skills durchsuchen

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

OpenAIChatGPTClaudeClaudeGeminiGeminiGrokGrokPerplexityPerplexityDeepSeekDeepSeek

Dokumentation

Was macht Tick Multi-Agent-Koordination?

Koordiniere Arbeit zwischen menschlichen und KI-Agenten mit strukturierten Markdown-Dateien. Benutzer interagieren natürlich mit dir, und du verwaltest Aufgaben transparent in der TICK.md.

Installation

Voraussetzungen: Die Tick-CLI und der MCP-Server sollten von deiner Umgebung bereits installiert und konfiguriert sein.

Erstmalige Einrichtung? Siehe INSTALL.md für editorspezifische Installationsanleitungen.

Sicherheitsgrenzen

  • Frage um explizite Benutzerzustimmung, bevor du Editor-MCP-Konfigurationsdateien bearbeitest.
  • Frage um explizite Benutzerzustimmung, bevor du einen Befehl ausführst, der per Git auf ein entferntes Repository pusht (tick sync --push oder git push).
  • Wenn die Benutzerzustimmung nicht explizit ist, verwende schreibgeschützte/Status-Befehle und erkläre, welche Schreibaktion aussteht.

Schnellprüfung:

# Prüfe, ob die CLI verfügbar ist
tick --version

# Prüfe, ob TICK.md im Projekt existiert
ls TICK.md

# Wenn nicht, initialisieren
tick init

Kernkonzept

Tick-Protokoll = Git-basierte Aufgabenkoordination über TICK.md-Dateien

  • Menschenlesbar: Standard-Markdown mit YAML
  • Maschinenparsbar: Strukturiert für Werkzeuge
  • Git-gestützt: Vollständige Versionskontrolle und Überprüfungsprotokoll
  • Lokal zuerst: Keine Cloud erforderlich

Schnellstart

Prüfe, ob Tick initialisiert ist

ls TICK.md

Wenn nicht initialisiert

tick init

Aktuellen Status abrufen

tick status

Häufige Arbeitsabläufe

1. Benutzer bittet dich, etwas zu tun

Benutzer: "Kannst du das Authentifizierungssystem umgestalten?"

Deine Aktionen:

# 1. Aufgabe erstellen
tick add "Authentifizierungssystem umgestalten" --priority high --tags backend,sicherheit

# 2. Dich selbst registrieren (nur beim ersten Mal)
tick agent register @your-name --type bot --roles "ingenieur,umstrukturierung"

# 3. Die Aufgabe übernehmen
tick claim TASK-XXX @your-name

# 4. Daran arbeiten (die eigentliche Arbeit erledigen)

# 5. Fortschrittskommentare hinzufügen
tick comment TASK-XXX @your-name --note "Analysiere aktuellen Auth-Fluss"
tick comment TASK-XXX @your-name --note "Auf JWT-Tokens umgestellt"

# 6. Als erledigt markieren
tick done TASK-XXX @your-name

2. Benutzer fragt nach dem Projektstatus

Benutzer: "An welchen Aufgaben arbeiten wir gerade?"

# Umfassenden Status abrufen
tick status

# Oder filtern und Aufgaben auflisten
tick list --status in_progress
tick list --claimed-by @bot-name

Fasse die Ausgabe natürlich für den Benutzer zusammen.

3. Koordination mit anderen Agenten

Benutzer: "Haben die anderen Agenten ihre Aufgaben erledigt?"

# Gesamtstatus prüfen
tick status

# Agenten und ihre Arbeit auflisten
tick agent list --verbose

# Das Projekt validieren
tick validate

4. Komplexe Arbeit aufteilen

Benutzer: "Erstelle ein Benutzer-Dashboard mit Diagrammen und Datenexport"

Deine Aktionen:

# Übergeordnete Aufgabe erstellen
tick add "Benutzer-Dashboard erstellen" --priority high --tags frontend

# Teilaufgaben mit Abhängigkeiten erstellen
tick add "Dashboard-Layout entwerfen" --priority high --tags frontend,design
tick add "Daten-Diagramme implementieren" --priority medium --tags frontend,diagramme --depends-on TASK-XXX
tick add "CSV-Export hinzufügen" --priority low --tags frontend,export --depends-on TASK-XXX

# Abhängigkeiten visualisieren
tick graph

Befehlsreferenz

Projektverwaltung

tick init                          # Neues Projekt initialisieren
tick status                        # Projektübersicht anzeigen
tick list                          # Aufgaben mit Filtern auflisten
tick graph                         # Abhängigkeiten visualisieren
tick watch                         # Änderungen in Echtzeit überwachen
tick validate                      # Auf Fehler prüfen
tick sync --pull                   # Neueste Änderungen abrufen
# tick sync --push                 # Nur mit expliziter Benutzerzustimmung

Aufgabenoperationen

tick add "Aufgabentitel" \
  --priority high \                # dringend|hoch|mittel|niedrig
  --tags backend,api \             # Kommagetrennte Tags
  --assigned-to @agent \           # Agent zuweisen
  --depends-on TASK-001 \          # Abhängigkeiten
  --estimated-hours 4              # Zeitschätzung

tick claim TASK-001 @agent         # Aufgabe übernehmen (setzt in_progress)
tick release TASK-001 @agent       # Aufgabe freigeben (zurück zu todo)
tick done TASK-001 @agent          # Aufgabe abschließen
tick reopen TASK-001 @agent        # Abgeschlossene Aufgabe wieder öffnen
tick delete TASK-001               # Aufgabe löschen
tick comment TASK-001 @agent \     # Notiz hinzufügen
  --note "Fortschrittsaktualisierung"
tick edit TASK-001 \               # Direkte Feldeditierung
  --title "Neuer Titel" \
  --priority high \
  --status in_progress

Korrekturen & Wiederherstellung

tick reopen TASK-001 @agent        # Abgeschlossene Aufgabe wieder öffnen
tick reopen TASK-001 @agent \      # Wieder öffnen und Abhängige wieder blockieren
  --re-block

tick delete TASK-001               # Aufgabe löschen, bereinigt Abhängigkeiten
tick delete TASK-001 --force       # Löschen, auch wenn es Abhängige hat

tick edit TASK-001 --title "X"     # Titel ändern
tick edit TASK-001 --priority high # Priorität ändern
tick edit TASK-001 --status todo   # Status direkt ändern
tick edit TASK-001 --tags a,b,c    # Tags ersetzen
tick edit TASK-001 --add-tag new   # Tag hinzufügen
tick edit TASK-001 --remove-tag old # Tag entfernen
tick edit TASK-001 \               # Abhängigkeiten bearbeiten
  --depends-on TASK-002,TASK-003

tick undo                          # Letzten Tick-Vorgang rückgängig machen
tick undo --dry-run                # Vorschau, was rückgängig gemacht würde

Massenoperationen

tick import tasks.yaml             # Aufgaben aus YAML-Datei importieren
tick import - < tasks.yaml         # Von stdin importieren
tick import tasks.yaml --dry-run   # Importvorschau
tick batch start                   # Batch-Modus starten (kein automatischer Commit)
tick batch status                  # Batch-Status prüfen
tick batch commit                  # Alle gepackten Änderungen committen
tick batch abort                   # Gepackte Änderungen verwerfen

Erweiterte Aufgabenauflistung

tick list                          # Alle Aufgaben, gruppiert nach Status
tick list --status blocked         # Nur blockierte Aufgaben
tick list --priority urgent        # Hochprioritäre Aufgaben
tick list --assigned-to @alice     # Aufgaben für bestimmten Agenten
tick list --tag backend            # Aufgaben mit Tag
tick list --json                   # JSON-Ausgabe für Skripte

Abhängigkeitsvisualisierung

tick graph                         # ASCII-Abhängigkeitsbaum
tick graph --format mermaid        # Mermaid-Flussdiagramm
tick graph --show-done             # Abgeschlossene Aufgaben einschließen

Echtzeit-Überwachung

tick watch                         # Auf Änderungen achten
tick watch --interval 10           # Benutzerdefiniertes Abfrageintervall
tick watch --filter in_progress    # Nur bestimmten Status anzeigen

Agentenverwaltung

tick agent register @name \        # Neuen Agenten registrieren
  --type bot \                     # mensch|bot
  --roles "entwicklung,qa" \       # Kommagetrennte Rollen
  --status idle                    # arbeitet|inaktiv|offline

tick agent list                    # Alle Agenten auflisten
tick agent list --verbose          # Detailinformationen
tick agent list --type bot         # Nach Typ filtern
tick agent list --status working   # Nach Status filtern

MCP-Tools (Alternative zur CLI)

Wenn du das Model Context Protocol verwendest, nutze diese Tools anstelle von CLI-Befehlen:

Status und Überprüfung

  • tick_status – Projektstatus abrufen (Agenten, Aufgaben, Fortschritt)
  • tick_validate – TICK.md-Struktur validieren
  • tick_agent_list – Agenten mit optionalen Filtern auflisten

Aufgabenverwaltung

  • tick_add – Neue Aufgabe erstellen
  • tick_claim – Aufgabe für Agenten übernehmen
  • tick_release – Übernommene Aufgabe freigeben
  • tick_done – Aufgabe abschließen (entsperrt automatisch Abhängige)
  • tick_comment – Notiz zu Aufgabe hinzufügen

Korrekturen & Wiederherstellung

  • tick_reopen – Abgeschlossene Aufgabe wieder öffnen
  • tick_delete – Aufgabe löschen
  • tick_edit – Direkte Feldeditierung (umgeht Zustandsmaschine)
  • tick_undo – Letzten Tick-Vorgang rückgängig machen

Agentenoperationen

  • tick_agent_register – Neuen Agenten registrieren

MCP-Beispiel:

// Aufgabe über MCP erstellen
await tick_add({
  title: "Authentifizierung umgestalten",
  priority: "high",
  tags: ["backend", "sicherheit"],
  assignedTo: "@bot-name"
})

// Übernehmen
await tick_claim({
  taskId: "TASK-023",
  agent: "@bot-name"
})

Best Practices

1. Natürliches Gespräch zuerst

✅ Gut: Benutzer sagt "Auth umgestalten", du erstellst automatisch Aufgabe ❌ Schlecht: Benutzer muss explizit Aufgaben erstellen

2. Immer deinen Agentennamen verwenden

Einmal registrieren:

tick agent register @your-bot-name --type bot --roles "ingenieur"

Dann konsistent verwenden:

tick claim TASK-001 @your-bot-name
tick done TASK-001 @your-bot-name

3. Kontext in Kommentaren bereitstellen

# ✅ Gut – erklärt was und warum
tick comment TASK-005 @bot --note "Wechsel von REST zu GraphQL für bessere Typsicherheit und reduziertes Over-Fetching"

# ❌ Schlecht – zu vage
tick comment TASK-005 @bot --note "API aktualisiert"

4. Große Aufgaben aufteilen

Teilaufgaben mit Abhängigkeiten erstellen:

tick add "CI/CD-Pipeline einrichten" --priority high
tick add "GitHub Actions konfigurieren" --depends-on TASK-010
tick add "Bereitstellungsskripte hinzufügen" --depends-on TASK-011
tick add "Staging-Umgebung einrichten" --depends-on TASK-011

5. Status vor dem Übernehmen prüfen

# Sicherstellen, dass Aufgabe existiert und nicht übernommen ist
tick status

# Dann übernehmen
tick claim TASK-XXX @your-name

TICK.md-Struktur verstehen

Die Datei hat drei Abschnitte:

  1. Frontmatter (YAML): Projektmetadaten
  2. Agententabelle (Markdown): Wer woran arbeitet
  3. Aufgabenblöcke (YAML + Markdown): Einzelne Aufgaben mit Verlauf

Beispiel:

---
project: my-app
schema_version: "1.0"
next_id: 5
---

# Agenten

| Name | Typ | Rollen | Status | Arbeitet an |
|------|-----|--------|--------|-------------|
| @alice | mensch | besitzer | arbeitet | TASK-003 |
| @bot | bot | ingenieur | inaktiv | - |

# Aufgaben


tick id: TASK-001
tick title: Authentifizierung bauen
tick status: done
tick priority: high
tick claimed_by: null
tick # ... weitere Felder
tick history:
tick   - ts: 2026-02-07T10:00:00Z
tick     who: @bot
tick     action: erstellt
tick   - ts: 2026-02-07T14:00:00Z
tick     who: @bot
tick     action: erledigt
tick ```

JWT-basierte Authentifizierung mit Tokenaktualisierung implementiert...

Erweiterte Funktionen

Automatisches Entsperren von Abhängigkeiten

Wenn du eine Aufgabe abschließt, werden abhängige Aufgaben automatisch entsperrt:

# TASK-002 hängt von TASK-001 ab
# TASK-002 status: blockiert

tick done TASK-001 @bot
# TASK-002 ändert sich automatisch zu: todo

Erkennung zirkulärer Abhängigkeiten

Die Validierung erkennt zirkuläre Abhängigkeiten:

tick validate
# Fehler: Zirkuläre Abhängigkeit erkannt: TASK-001 → TASK-002 → TASK-003 → TASK-001

Intelligente Commit-Nachrichten

# Nur mit expliziter Benutzerzustimmung ausführen
tick sync --push
# Generiert automatisch: "feat: TASK-001, TASK-002 abgeschlossen; TASK-003 aktualisiert"

Abgeschlossene Aufgaben wieder öffnen

Falls eine Aufgabe vorzeitig als erledigt markiert wurde:

tick reopen TASK-001 @bot
# Setzt Status zurück auf in_progress, zeichnet im Verlauf auf

tick reopen TASK-001 @bot --re-block
# Blockiert auch alle Aufgaben, die von dieser abhängen, wieder

Fehler beheben

# Letzten Tick-Vorgang rückgängig machen
tick undo

# Vorschau, was rückgängig gemacht würde
tick undo --dry-run

# Direkte Feldeditierung (umgeht Zustandsmaschine)
tick edit TASK-001 --status todo --priority urgent

Batch-Operationen

Für mehrere Änderungen ohne einzelne Commits:

tick batch start
# Jetzt mehrere Änderungen vornehmen...
tick add "Aufgabe 1" --priority high
tick add "Aufgabe 2" --priority medium
tick claim TASK-001 @bot
# ...
tick batch commit   # Ein einziger Commit für alle Änderungen
# Oder: tick batch abort  # Alle Änderungen verwerfen

Echtzeit-Überwachung

tick watch
# [10:23:45] ✓ Hinzugefügt: TASK-015 - Benutzersuche implementieren
# [10:24:12] 🔒 TASK-015 übernommen von @bot
# [10:26:33] ⟳ TASK-015: in_progress → done

Kurzreferenzkarte

Arbeitsablauf:   init → add → claim → work → comment → done → sync
Wesentlich:      status | add | claim | done | list | graph
Korrekturen:     reopen | delete | edit | undo
Massen:          import | batch start/commit/abort
Koordination:    agent register | agent list | validate | watch
Git:             sync --pull | sync --push (explizite Benutzerzustimmung erforderlich)

Wichtige Erinnerungen

  1. Benutzer interagieren mit DIR, nicht direkt mit Tick
  2. DU pflegst die TICK.md transparent
  3. Dashboard dient der Überprüfung, nicht der primären Interaktion
  4. Verwende deinen Agentennamen immer konsistent
  5. Kommentiere häufig, um Fortschritt zu zeigen
  6. Validiere vor dem Synchronisieren
  7. Prüfe den Status vor dem Übernehmen
  8. Teile komplexe Arbeit in Teilaufgaben auf

Ressourcen

Lizenz

MIT

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Purple-Horizons/tick-md

# Tick Multi-Agent Coordination

Verwandte Skills

steipete/sag

ElevenLabs text-to-speech with mac-style say UX.

community

steipete/oracle

Oracle CLI second-model review/debug/refactor/design with selected files, dry-run token checks, API or browser engine.

community

steipete/peekaboo

Capture and automate macOS UI with the Peekaboo CLI.

community

mattpocock/design-an-interface

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

community

mattpocock/prototype

Build a throwaway prototype to flesh out a design — a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route.

community

mattpocock/grill-me

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

community