Heim

Skill

Produktivität und Workflow

team-builder

affaan-m/ECC

Sehen Sie sich die verfügbaren Agentenprofile an und stellen Sie Ad-hoc-Teams mit bis zu fünf Agenten zusammen, die parallel an einer Aufgabe arbeiten, und führen Sie anschließend deren Ergebnisse zusammen.

...Alle erweitern

Zeit aktualisiert 2. Oktober 2026

# parallel agents # agent personas # claude agents # markdown files # team composition

Team Builder

Interaktives Menü zum Durchsuchen und Zusammenstellen von Agenten-Teams nach Bedarf. Funktioniert mit flachen oder in Domänen-Unterverzeichnissen organisierten Agenten-Sammlungen.

Anwendungsfälle

Sie verfügen über mehrere Agenten-Profile (Markdown-Dateien) und möchten auswählen, welche davon für eine Aufgabe verwendet werden sollen
Sie möchten ein Ad-hoc-Team aus verschiedenen Domänen zusammenstellen (z. B. Sicherheit + SEO + Architektur)
Sie möchten sich einen Überblick über die verfügbaren Agenten verschaffen, bevor Sie eine Entscheidung treffen

Voraussetzungen

Agentendateien müssen Markdown-Dateien sein, die eine Agentenbeschreibung (Identität, Regeln, Arbeitsablauf, Ergebnisse) enthalten. Die erste #-Überschrift wird als Agentenname und der erste Absatz als Beschreibung verwendet.

Es werden sowohl flache als auch Unterverzeichnis-Layouts unterstützt:

Unterverzeichnis-Layout – der Fachbereich wird aus dem Ordnernamen abgeleitet:

agents/
├── engineering/
│   ├── security-engineer.md
│   └── software-architect.md
├── marketing/
│   └── seo-specialist.md
└── sales/
    └── discovery-coach.md

Flache Struktur – Die Domäne wird anhand gemeinsamer Dateinamenpräfixe abgeleitet. Ein Präfix gilt als Domäne, wenn es von mindestens zwei Dateien gemeinsam verwendet wird. Dateien mit eindeutigen Präfixen werden dem Ordner „General“ zugeordnet. Hinweis: Der Algorithmus trennt am ersten „-“, daher sollten Domänen, die aus mehreren Wörtern bestehen (z. B. „product-management“), stattdessen das Unterverzeichnis-Layout verwenden:

agents/
├── engineering-security-engineer.md
├── engineering-software-architect.md
├── marketing-seo-specialist.md
├── marketing-content-strategist.md
├── sales-discovery-coach.md
└── sales-outbound-strategist.md

Konfiguration

Agenten werden über zwei Methoden erkannt, zusammengeführt und anhand des Agentennamens dedupliziert:

Befehl„claude agents“ (primär) – Führen Sie „claude agents“ aus, um alle der CLI bekannten Agenten abzurufen, einschließlich Benutzeragenten, Plugin-Agenten (z. B. „everything-claude-code:architect“) und integrierter Agenten. Dies deckt automatisch ECC-Marketplace-Installationen ab, ohne dass eine Pfadkonfiguration erforderlich ist.
Datei-Glob (Fallback, zum Lesen von Agenteninhalten) – Markdown-Dateien der Agenten werden aus folgenden Verzeichnissen gelesen:
- ./agents/**/*.md + ./agents/*.md – projektlokale Agenten
- ~/.claude/agents/**/*.md + ~/.claude/agents/*.md — globale Benutzer-Agenten

Bei Namenskonflikten haben die früher genannten Quellen Vorrang: Benutzer-Agenten > Plugin-Agenten > integrierte Agenten. Stattdessen kann ein benutzerdefinierter Pfad verwendet werden, wenn der Benutzer einen angibt.

So funktioniert es

Schritt 1: Verfügbare Agenten ermitteln

Führen Sie „claude agents“ aus, um die vollständige Agentenliste zu erhalten. Analysieren Sie jede Zeile:

Plugin-Agenten sind mit dem Präfix „plugin-name:“ versehen (z. B. „everything-claude-code:security-reviewer“). Verwende den Teil nach dem Doppelpunkt (:) als Agentennamen und den Plugin-Namen als Domäne.
Benutzer-Agenten haben kein Präfix. Lesen Sie die entsprechende Markdown-Datei aus ~/.claude/agents/ oder ./agents/ ein, um den Namen und die Beschreibung zu extrahieren.
Integrierte Agenten (z. B. „Explore“, „Plan“) werden übersprungen, sofern der Benutzer nicht ausdrücklich darum bittet, sie einzubeziehen.

Für Benutzeragenten, die aus Markdown-Dateien geladen werden:

Verzeichnisstruktur: Extrahieren Sie die Domäne aus dem Namen des übergeordneten Ordners
Flache Struktur: Sammle alle Dateinamenpräfixe (Text vor dem ersten „-“). Ein Präfix gilt nur dann als Domäne, wenn es in mindestens zwei Dateinamen vorkommt (z. B. beginnen sowohl „engineering-security-engineer.md“ als auch „engineering-software-architect.md“ mit „engineering“ → Domäne „Engineering“). Dateien mit eindeutigen Präfixen (z. B. „code-reviewer.md“, „tdd-guide.md“) werden unter „Allgemein“ zusammengefasst
Den Agenten-Namen aus der ersten #-Überschrift extrahieren. Wird keine Überschrift gefunden, den Namen aus dem Dateinamen ableiten ( “.md“ entfernen, Bindestriche durch Leerzeichen ersetzen, Groß-/Kleinschreibung anpassen)
Extrahieren Sie eine einzeilige Zusammenfassung aus dem ersten Absatz nach der Überschrift

Wenn nach dem Ausführen von „claude agents“ und dem Durchsuchen der Dateispeicherorte keine Agenten gefunden werden, informiere den Benutzer: „Keine Agenten gefunden. Führe ‚claude agents‘ aus, um deine Konfiguration zu überprüfen.“ Beende dann den Vorgang.

Schritt 2: Menü „Domänen“ anzeigen

Verfügbare Agenten-Domänen:
1. Technik — Softwarearchitekt, Sicherheitsingenieur
2. Marketing — SEO-Spezialist
3. Vertrieb — Discovery-Coach, Outbound-Stratege

Wähle Domänen aus oder gib bestimmte Agenten an (z. B. „1,3“ oder „security + seo“):

Überspringe Domänen ohne Agenten (leere Verzeichnisse)
Anzahl der Agenten pro Domäne anzeigen

Schritt 3: Auswahl verarbeiten

Flexible Eingabe zulassen:

Zahlen: „1,3“ wählt alle Agenten aus den Bereichen Technik und Vertrieb aus
Namen: „security + seo“ führt eine unscharfe Suche nach erkannten Agenten durch
„alle aus der Technik“ wählt jeden Agenten in dieser Domäne aus

Wenn mehr als 5 Agenten ausgewählt wurden, listen Sie diese alphabetisch auf und bitten Sie den Benutzer, die Auswahl einzugrenzen: „Sie haben N Agenten ausgewählt (max. 5). Wählen Sie aus, welche Sie behalten möchten, oder sagen Sie ‚die ersten 5‘, um die ersten fünf in alphabetischer Reihenfolge zu verwenden.“

Auswahl bestätigen:

Ausgewählt: Sicherheitsingenieur + SEO-Spezialist
Woran sollen sie arbeiten? (Beschreiben Sie die Aufgabe):

Schritt 4: Agenten parallel starten

Lies die Markdown-Datei jedes ausgewählten Agenten
Fragen Sie nach der Aufgabenbeschreibung, falls diese noch nicht angegeben wurde
Alle Agenten mithilfe des Agent-Tools parallel starten:
- subagent_type: „general-purpose“
- prompt: "{Inhalt der Agentendatei}\n\nAufgabe: {Aufgabenbeschreibung}"
- Jeder Agent läuft unabhängig – es ist keine Kommunikation zwischen den Agenten erforderlich
Falls ein Agent fehlschlägt (Fehler, Timeout oder leere Ausgabe), vermerken Sie den Fehler direkt im Text (z. B. „Sicherheitsingenieur: fehlgeschlagen – [Grund]“) und fahren Sie mit den Ergebnissen der erfolgreichen Agenten fort

Schritt 5: Ergebnisse zusammenfassen

Sammeln Sie alle Ausgaben und erstellen Sie einen einheitlichen Bericht:

Nach Agenten gruppierte Ergebnisse
Hervorhebung im Zusammenfassungsabschnitt:
- Übereinstimmungen zwischen den Agenten
- Widersprüche oder Spannungen zwischen den Empfehlungen
- Empfohlene nächste Schritte

Wenn nur ein Akteur ausgewählt wurde, überspringen Sie die Zusammenfassung und präsentieren Sie das Ergebnis direkt.

Regeln

Ausschließlich dynamische Erkennung. Agentenlisten dürfen niemals fest codiert werden. Neue Dateien im Verzeichnis erscheinen automatisch im Menü.
Maximal 5 Agenten pro Team. Bei mehr als 5 sinkt der Nutzen und es kommt zu übermäßigem Token-Verbrauch. Dies muss bei der Auswahl durchgesetzt werden.
Parallele Verteilung. Alle Agenten laufen gleichzeitig – verwende das Muster für den parallelen Aufruf des Agent-Tools.
Parallele Agent-Aufrufe, kein „TeamCreate“. Diese Fertigkeit nutzt parallele Aufrufe des Agent-Tools für unabhängige Arbeit. „TeamCreate“ (ein Claude-Code-Tool für Multi-Agenten-Dialoge) wird nur benötigt, wenn Agenten miteinander diskutieren oder aufeinander reagieren müssen.

Beispiele

Benutzer: Team-Builder

Claude:
Verfügbare Agenten-Domänen:
1. Technik (2) – Softwarearchitekt, Sicherheitsingenieur
2. Marketing (1) – SEO-Spezialist
3. Vertrieb (4) – Discovery-Coach, Outbound-Stratege, Angebotsstratege, Vertriebsingenieur
4. Support (1) – Zusammenfassung

Wähle Domänen aus oder nenne bestimmte Agenten:

Benutzer: Sicherheit + SEO

Claude:
Ausgewählt: Sicherheitsingenieur + SEO-Spezialist
Woran sollen sie arbeiten?

Benutzer: Überprüfe meine Next.js-E-Commerce-Website vor dem Start

[Beide Agenten werden parallel gestartet und wenden jeweils ihr Fachwissen auf den Code an]

Claude:
## Ergebnisse des Sicherheitsingenieurs
- [Ergebnisse...]

## Ergebnisse des SEO-Spezialisten
- [Ergebnisse...]

## Zusammenfassung
Beide Agenten sind sich einig über: [...]
Konflikt: Der Sicherheitsingenieur empfiehlt CSP, das Inline-Stile blockiert; der SEO-Spezialist benötigt Inline-Schema-Markup. Lösung: [...]
Nächste Schritte: [...]

Auf GitHub ansehen

---
name: team-builder
description: Browse available agent personas and compose ad-hoc teams of up to 5 agents to work in parallel on a task, then synthesize their results.
---

# Team Builder

Interactive menu for browsing and composing agent teams on demand. Works with flat or domain-subdirectory agent collections.

## When to Use

- You have multiple agent personas (markdown files) and want to pick which ones to use for a task
- You want to compose an ad-hoc team from different domains (e.g., Security + SEO + Architecture)
- You want to browse what agents are available before deciding

## Prerequisites

Agent files must be markdown files containing a persona prompt (identity, rules, workflow, deliverables). The first `# Heading` is used as the agent name and the first paragraph as the description.

Both flat and subdirectory layouts are supported:

**Subdirectory layout** — domain is inferred from the folder name:

```
agents/
├── engineering/
│   ├── security-engineer.md
│   └── software-architect.md
├── marketing/
│   └── seo-specialist.md
└── sales/
    └── discovery-coach.md
```

**Flat layout** — domain inferred from shared filename prefixes. A prefix counts as a domain when 2+ files share it. Files with unique prefixes go to "General". Note: the algorithm splits at the first `-`, so multi-word domains (e.g., `product-management`) should use the subdirectory layout instead:

```
agents/
├── engineering-security-engineer.md
├── engineering-software-architect.md
├── marketing-seo-specialist.md
├── marketing-content-strategist.md
├── sales-discovery-coach.md
└── sales-outbound-strategist.md
```

## Configuration

Agents are discovered via two methods, merged and deduplicated by agent name:

1. **`claude agents` command** (primary) — run `claude agents` to get all agents known to the CLI, including user agents, plugin agents (e.g. `everything-claude-code:architect`), and built-in agents. This automatically covers ECC marketplace installs without any path configuration.
2. **File glob** (fallback, for reading agent content) — agent markdown files are read from:
   - `./agents/**/*.md` + `./agents/*.md` — project-local agents
   - `~/.claude/agents/**/*.md` + `~/.claude/agents/*.md` — global user agents

Earlier sources take precedence when names collide: user agents > plugin agents > built-in agents. A custom path can be used instead if the user specifies one.

## How It Works

### Step 1: Discover Available Agents

Run `claude agents` to get the full agent list. Parse each line:
- **Plugin agents** are prefixed with `plugin-name:` (e.g., `everything-claude-code:security-reviewer`). Use the part after `:` as the agent name and the plugin name as the domain.
- **User agents** have no prefix. Read the corresponding markdown file from `~/.claude/agents/` or `./agents/` to extract the name and description.
- **Built-in agents** (e.g., `Explore`, `Plan`) are skipped unless the user explicitly asks to include them.

For user agents loaded from markdown files:
- **Subdirectory layout:** extract the domain from the parent folder name
- **Flat layout:** collect all filename prefixes (text before the first `-`). A prefix qualifies as a domain only if it appears in 2 or more filenames (e.g., `engineering-security-engineer.md` and `engineering-software-architect.md` both start with `engineering` → Engineering domain). Files with unique prefixes (e.g., `code-reviewer.md`, `tdd-guide.md`) are grouped under "General"
- Extract the agent name from the first `# Heading`. If no heading is found, derive the name from the filename (strip `.md`, replace hyphens with spaces, title-case)
- Extract a one-line summary from the first paragraph after the heading

If no agents are found after running `claude agents` and probing file locations, inform the user: "No agents found. Run `claude agents` to verify your setup." Then stop.

### Step 2: Present Domain Menu

```
Available agent domains:
1. Engineering — Software Architect, Security Engineer
2. Marketing — SEO Specialist
3. Sales — Discovery Coach, Outbound Strategist

Pick domains or name specific agents (e.g., "1,3" or "security + seo"):
```

- Skip domains with zero agents (empty directories)
- Show agent count per domain

### Step 3: Handle Selection

Accept flexible input:
- Numbers: "1,3" selects all agents from Engineering and Sales
- Names: "security + seo" fuzzy-matches against discovered agents
- "all from engineering" selects every agent in that domain

If more than 5 agents are selected, list them alphabetically and ask the user to narrow down: "You selected N agents (max 5). Pick which to keep, or say 'first 5' to use the first five alphabetically."

Confirm selection:
```
Selected: Security Engineer + SEO Specialist
What should they work on? (describe the task):
```

### Step 4: Spawn Agents in Parallel

1. Read each selected agent's markdown file
2. Prompt for the task description if not already provided
3. Spawn all agents in parallel using the Agent tool:
   - `subagent_type: "general-purpose"`
   - `prompt: "{agent file content}\n\nTask: {task description}"`
   - Each agent runs independently — no inter-agent communication needed
4. If an agent fails (error, timeout, or empty output), note the failure inline (e.g., "Security Engineer: failed — [reason]") and continue with results from agents that succeeded

### Step 5: Synthesize Results

Collect all outputs and present a unified report:
- Results grouped by agent
- Synthesis section highlighting:
  - Agreements across agents
  - Conflicts or tensions between recommendations
  - Recommended next steps

If only 1 agent was selected, skip synthesis and present the output directly.

## Rules

- **Dynamic discovery only.** Never hardcode agent lists. New files in the directory auto-appear in the menu.
- **Max 5 agents per team.** More than 5 produces diminishing returns and excessive token usage. Enforce at selection time.
- **Parallel dispatch.** All agents run simultaneously — use the Agent tool's parallel invocation pattern.
- **Parallel Agent calls, not TeamCreate.** This skill uses parallel Agent tool calls for independent work. TeamCreate (a Claude Code tool for multi-agent dialogue) is only needed when agents must debate or respond to each other.

## Examples

```
User: team builder

Claude:
Available agent domains:
1. Engineering (2) — Software Architect, Security Engineer
2. Marketing (1) — SEO Specialist
3. Sales (4) — Discovery Coach, Outbound Strategist, Proposal Strategist, Sales Engineer
4. Support (1) — Executive Summary

Pick domains or name specific agents:

User: security + seo

Claude:
Selected: Security Engineer + SEO Specialist
What should they work on?

User: Review my Next.js e-commerce site before launch

[Both agents spawn in parallel, each applying their specialty to the codebase]

Claude:
## Security Engineer Findings
- [findings...]

## SEO Specialist Findings
- [findings...]

## Synthesis
Both agents agree on: [...]
Tension: Security recommends CSP that blocks inline styles, SEO needs inline schema markup. Resolution: [...]
Next steps: [...]
```