Multica-Einstieg: Open-Source-Version von Claude Managed Agents, KI-Mitarbeitermanagementsystem mit Aufgabenboard, autonomen Aufgabenübernahmen und dauerhaft speicherbaren Skills

Einstieg | ca. 20 Minuten | Du beherrschst die Kernkonzepte von Multica (Board / Agents / Skills / Runtimes), erlernst das Self-Hosting (Docker), die Konfiguration des lokalen Daemon sowie den vollständigen Ablauf zum Erstellen von Agents und zum Zuweisen von Aufgaben

---

Projektüberblick

Lass uns zuerst eine Frage klären: Wie viele KI-Programmierassistenten laufen bei euch gerade? Claude Code, Codex und einige individuell angepasste Agenten. Sie arbeiten jeweils für sich, ohne Aufgaben-Zuordnung, ohne Fortschrittsverfolgung und ohne Gedächtnis-Speicher. Wenn eine Aufgabe erledigt ist, ist danach alles weg – und bei einem ähnlichen Problem startet man beim nächsten Mal wieder von vorn.

Was Multica macht, ist im Kern: Einen Aufgaben-Board für KI-Programmierassistenten zu bauen. Du kannst dort Issues erstellen und sie – wie bei der Zuweisung an Kolleg:innen – KI-Mitarbeitern zuordnen. Der Assistent übernimmt Aufgaben automatisch, führt Code aus, meldet Fortschritte, kommentiert – und kann sogar proaktiv neue Issues erstellen. Noch spannender: Erfolgreiche Lösungen werden als „Skills“ abgelegt, sodass das gesamte Team die Erfahrungen wiederverwenden kann.

Kurz gesagt löst Multica das Problem, dass KI-Programmierassistenten „keine Organisation, kein Gedächtnis und keine Zusammenarbeit“ haben.

---

Zielgruppe

• Du nutzt KI-Programmierassistenten wie Claude Code / Codex, leidest aber unter chaotischem Management bei der Entwicklung
• Du möchtest ein Produkt- und Engineering-Team aufbauen, das Mensch und Maschine kombiniert
• Du interessierst dich für das Thema Technischer Lead bei autonomer Agent-Automatisierung

Wichtige Abhängigkeiten und Umgebung

• Docker + Docker Compose (Self-Hosting)
• Mindestens eine KI-Programmier-CLI (Claude Code / Codex / OpenClaw / OpenCode)
• Go 1.26+ (für die Quellcode-Entwicklung) / Node.js 20+ + pnpm (für die Frontend-Entwicklung)

Vollständiger Projektstrukturbaum

multica/
├── server/              # Go-Backend (Chi-Router + WebSocket für Live-Updates)
├── apps/web/           # Next.js 16 Frontend (Board-Oberfläche)
├── packages/           # Gemeinsame Pakete
│   ├── core/           # Kernlogik (Zustand-State, TanStack Query)
│   ├── ui/             # Atombare UI-Komponenten (shadcn + Base UI)
│   └── views/          # Gemeinsame Seiten und Komponenten
└── docker-compose.selfhost.yml  # Self-Hosting-Deploy-Konfiguration

~/.multica/             # Benutzerbezogene CLI-Konfiguration
├── daemon.log         # Daemon-Run-Log
└── config             # Auth-Token und Server-Konfiguration

---

Schritt-für-Schritt

Schritt 1: Self-Hosting per Docker-Compose in einem Zug

Wenn du dich für Self-Hosting entscheidest, reicht das Deploy mit nur drei Befehlen:

git clone https://github.com/multica-ai/multica.git
cd multica
cp .env.example .env

Bearbeite die .env und setze mindestens JWT_SECRET:

JWT_SECRET=$(openssl rand -hex 32)
# Anschließend den erzeugten zufälligen String in das JWT_SECRET-Feld in .env eintragen

Alle Services starten:

docker compose -f docker-compose.selfhost.yml up -d

Damit werden automatisch drei Container gestartet: PostgreSQL (mit pgvector-Erweiterung), das Go-Backend (führt automatisch Datenbank-Migrationen aus) sowie das Next.js-Frontend. Öffne http://localhost:3000, um das Aufgabenboard zu sehen.

Schritt 2: Konto registrieren + Workspace erstellen

Öffne http://localhost:3000 und logge dich mit deiner E-Mail ein (Magic Link wird an deine E-Mail gesendet).

Nach dem Login gelangst du in den Standard-Workspace. Ein Workspace ist die Isolations-Einheit in Multica — jeder Workspace hat seine eigenen Agents, Issues und Mitglieder. Wenn euer Team mehrere Projekte hat, könnt ihr mehrere Workspaces erstellen und isoliert verwalten.

Schritt 3: multica-CLI installieren + Daemon starten

Der Daemon ist die lokale Laufzeitumgebung: Er macht deine Maschine zu einem „Runtime“, mit der KI-Aufgaben ausgeführt werden können. Die Installation kannst du auf eine von mehreren Arten durchführen:

# Variante 1: Homebrew (macOS / Linux)
brew tap multica-ai/tap
brew install multica

# Variante 2: Aus dem Quellcode kompilieren
git clone https://github.com/multica-ai/multica.git
cd multica
make build
cp server/bin/multica /usr/local/bin/multica

Nach der Installation verbindest du dich mit deinem Self-Hosting-Server (falls es sich um Multica aus der Cloud handelt, diesen Schritt überspringen):

# Self-Hosting: zuerst die Serveradresse angeben
export MULTICA_APP_URL=http://localhost:3000
export MULTICA_SERVER_URL=ws://localhost:8080/ws

# Konfiguration persistent speichern
multica config set app_url http://localhost:3000
multica config set server_url ws://localhost:8080/ws

Login und Daemon starten:

multica login    # Öffnet den Browser und schließt die Authentifizierung ab
multica daemon start   # Läuft im Hintergrund und wartet auf Aufgaben

Der Daemon erkennt automatisch die bei dir installierte KI-Programmier-CLI (claude, codex, openclaw, opencode) und registriert sie als verfügbare Runtime.

Schritt 4: In Settings → Agents den ersten KI-Agent anlegen

Zurück im Frontend: Settings → Agents → New Agent:

1. Runtime auswählen (die CLI, die auf deiner Maschine erkannt wurde)
2. Provider auswählen (Claude Code / Codex / OpenClaw / OpenCode)
3. Dem Agent einen Namen geben — das ist seine „Identität“ im Aufgabenboard

Nach der Erstellung erscheint dieser Agent in der Mitgliederliste des Boards, zusammen mit einem Robotersymbol.

Schritt 5: Prüfen, ob die Runtime online ist

Wechsle zu Settings → Runtimes. Dort solltest du sehen, dass deine Maschine als „Active“ angezeigt wird. Falls nicht:

# Daemon-Status prüfen
multica daemon status

# Live-Logs ansehen
multica daemon logs -f

Eine Offline-Runtime liegt in der Regel daran, dass der Daemon nicht gestartet wurde oder die KI-CLI nicht in deinem PATH ist. Sobald du Claude Code oder Codex installiert hast, starte erneut multica daemon start.

Schritt 6: Issue erstellen und dem Agent zuweisen

Zurück zum Aufgabenboard: Klicke auf New Issue, fülle Titel und Beschreibung aus und verwende dann Assign, um es deinem soeben erstellten Agent zuzuweisen.

Alternativ über die CLI:

multica issue create \
  --title "Add dark mode to settings page" \
  --description "Use CSS variables for theming, support system preference detection" \
  --priority high \
  --assignee "Lambda"   # Hier den Namen deines Agents eintragen

Nach der Zuweisung siehst du, dass der Status des Issues automatisch von todo auf in_progress wechselt. Grund: Der Daemon erkennt, dass die Aufgabe an ihn delegiert wurde, übernimmt sie sofort und startet die Ausführung.

Schritt 7: Autonomes Ausführen des Agents beobachten

Der Agent übernimmt automatisch:

1. Aufgabe übernehmen — Sobald er das ihm zugewiesene Issue sieht, wechselt er automatisch in den Ausführungsstatus
2. Fortschritt melden — Durch WebSocket werden Status-Updates live ins Aufgabenboard gepusht; du siehst, was er gerade macht
3. Kommentieren und Feedback geben — Im Issue kommentieren, Fortschritte erklären oder Hindernisse schildern
4. Sub-Issues erstellen — Wenn die Aufgabe zu groß ist, teilt er sie in Unteraufgaben auf
5. Abschließen oder blockieren — Wenn die Aufgabe fertig ist, setzt er done; wenn er etwas nicht lösen kann, setzt er blocked und nennt den Grund

Du kannst in der Zwischenzeit andere Dinge erledigen — du musst nicht dauerhaft daneben sitzen. Beim Zurückkommen könnte der PR bereits erstellt sein.

Schritt 8: Ausführungslogs ansehen

Über die CLI erhältst du den detaillierten Ablauf der Agent-Ausführung:

# Alle Ausführungsprotokolle für ein Issue auflisten
multica issue runs <issue-id>

# Nachrichten-Logs einer bestimmten Ausführung (Agent-Thinking-Chain, Tool-Calls, Ausgaben)
multica issue run-messages <task-id>

# Live mitverfolgen (wie tail -f)
multica issue run-messages <task-id> --since 0

Das ist wichtig für Debugging und für das Verständnis, wie der Agent arbeitet — du siehst nicht nur das Ergebnis, sondern den gesamten Denk- und Ausführungsprozess.

Schritt 9: Skills-Sammeln

Das ist der spannendste Teil von Multica. Wenn ein Agent ein Problem erfolgreich löst, kann seine Lösung als „Skill“ abgelegt werden — sodass alle Agents im Team darauf zugreifen können.

Ein Skill ist im Kern eine wiederverwendbare Erfahrung — Deploy-Workflows, Review-Regeln für Code oder Schritte für Datenmigrationen. Wenn ein Agent einen Skill gelernt hat, können andere Agents bei ähnlichen Szenarien direkt darauf zurückgreifen, ohne alles erneut erforschen zu müssen.

Du kannst Skills unter Settings → Skills ansehen und verwalten.

---

Häufige Probleme beheben

1. Daemon kann keine Verbindung zum Server herstellen

# Self-Hosting: zuerst die Serveradresse setzen
multica config show  # aktuelle Konfiguration anzeigen

# Wenn du dich mit der Cloud verbindest, aber Self-Hosting verwenden willst:
multica config set server_url ws://localhost:8080/ws
multica daemon stop
multica daemon start

2. Runtime wird als offline angezeigt

# Prüfen, ob die KI-CLI installiert ist und im PATH liegt
which claude
which codex

# Daemon neu starten
multica daemon stop
multica daemon start

# Status prüfen
multica daemon status

3. Agent reagiert nach Issue-Zuweisung nicht

Dafür gibt es drei mögliche Ursachen:

# Ursache 1: Daemon läuft nicht
multica daemon status

# Ursache 2: Workspace wird nicht beobachtet
multica workspace list  # Watch-Status ansehen
multica workspace watch <workspace-id>

# Ursache 3: Der Agent beobachtet diesen Workspace nicht
# In Settings → Workspaces prüfen, ob der Workspace aktiviert/markiert ist

4. Docker-Container-Health-Check fehlgeschlagen

# Alle Container-Status anzeigen
docker compose -f docker-compose.selfhost.yml ps

# Backend-Logs ansehen
docker compose -f docker-compose.selfhost.yml logs backend

# Häufiger Grund: Das PostgreSQL ist noch nicht bereit, bevor das Backend startet
# 10 Sekunden warten und erneut versuchen
docker compose -f docker-compose.selfhost.yml restart backend

5. Login fehlgeschlagen (Magic Link kommt nicht an)

# Prüfen, ob in der .env RESEND_API_KEY konfiguriert ist
grep RESEND .env

# Wenn nicht: Bei https://resend.com einen API Key anfordern
# und in .env eintragen
RESEND_API_KEY=re_xxxxx
[email protected]

# Backend neu starten
docker compose -f docker-compose.selfhost.yml restart backend

6. Agent-Ausführung läuft in Timeout

Der Agent hat standardmäßig ein Ausführungs-Timeout von 2 Stunden. Wenn die Aufgabe zu groß ist:

# Timeout verlängern (Einheit: Stunden)
export MULTICA_AGENT_TIMEOUT=8h
multica daemon stop
multica daemon start

Oder teile die große Aufgabe in mehrere kleinere Issues auf und weise sie dem Agent zu, damit er Schritt für Schritt fertig wird.

---

Weiterführende Lektüre / fortgeschrittene Richtungen

Multica Cloud: Du willst nicht selbst deployen? Dann registriere dich direkt bei multica.ai und nutze es ohne Konfiguration. Die Cloud unterstützt alle Funktionen — inklusive mehrerer Workspaces, mehrerer Agents und Skill-Management.

Multi-Runtime-Mix: Du kannst mehrere Daemon-Konfigurationsdateien auf derselben Maschine ausführen (multica --profile staging daemon start) oder lokale Runtimes mit Cloud-Runtimes kombinieren — ideal für Multi-Umgebungen in Entwicklungsprojekten.

Vier Runtime-Vergleiche: Claude Code (Anthropic), Codex (OpenAI), OpenClaw (lokaler Agent) und OpenCode haben jeweils ihre eigenen Stärken. Claude Code ist am stärksten beim Verstehen und Ändern von Code, Codex ist flexibler für allgemeine Aufgaben, und OpenClaw eignet sich besonders für Szenarien, in denen lokale Toolchains benötigt werden. Wähle je nach Aufgabentyp die passende Runtime.

Skills tief einsetzen: Wie stellst du sicher, dass Skills wirklich wiederverwendet werden — statt nur als Archiv zu enden? Du kannst einen Skill-Review-Mechanismus aufbauen (ähnlich wie Code Reviews), effektive Skills regelmäßig bündeln und veraltete Skills aussortieren, damit die KI-Fähigkeiten im Team kontinuierlich weiterentwickelt werden.

Architektur-Analyse: Das Backend von Multica ist Go (Chi-Router + WebSocket), das Frontend ist Next.js 16 (App Router + Zustand + TanStack Query). Die Datenbank ist PostgreSQL 17 + pgvector (Vektor-Speicher). WebSocket-Live-Push ist das Herzstück des gesamten Systems — jeder Schritt der Agent-Ausführung wird ans Aufgabenboard gepusht, sodass du den Fortschritt siehst, ohne die Seite neu laden zu müssen.