Was macht eine Agenturagentur?

Die Agentur ist eine Open-Source-Sammlung von 147 spezialisierten KI-Agenten für Claude Code, Cursor, Aider, Windsurf, GitHub Copilot und mehr. Jeder Agent hat eine eigene Persönlichkeit, technische Ergebnisse und Erfolgsmetriken. Dieser technische Deep Dive behandelt die Agentenarchitektur, die Multi-Tool-Integration, den MCP-Speicher und die Bash-Skripte, die all das antreiben.

Schaltfläche

Sie kennen wahrscheinlich den Ablauf: „Handeln Sie als leitender Entwickler“, gefolgt von allgemeinen Ratschlägen, die für jede Programmieraufgabe gelten könnten. Die Agentur verfolgt einen anderen Ansatz. Anstatt einer einzigen Aufforderung, die alles zu tun versucht, bietet sie 147 Spezialisten, die in 12 Abteilungen organisiert sind.

Stellen Sie es sich vor wie die Zusammenstellung einer Full-Service-Agentur, nur dass es KI-Agenten sind, die niemals schlafen, sich nie beschweren und immer liefern.

Was ist die Agentur?

Die Kurzversion: Die Agentur ersetzt „Verhalte dich wie ein Entwickler“ durch „Frontend-Entwickler-Modus aktivieren“ – und der Frontend-Entwickler-Agent kennt tatsächlich React, Vue, Angular, Core Web Vitals und Barrierefreiheitskonformität.

Repository-Struktur: 12 Abteilungen, 147 Agenten

Die Agentur befindet sich unter github.com/msitarzewski/agency-agents. Agenten sind in 12 Abteilungen organisiert, die eine reale Agentur-Organisationsstruktur widerspiegeln:

agency-agents/
├── engineering/          # 20+ Agenten: Frontend, Backend, DevOps, KI, Mobile, Sicherheit
├── design/               # 8 Agenten: UI Designer, UX Researcher, Brand Guardian, Whimsy Injector
├── marketing/            # 20+ Agenten: Growth Hacker, SEO, TikTok, Reddit, LinkedIn
├── sales/                # 8 Agenten: Discovery Coach, Deal Strategist, Sales Engineer
├── product/              # 5 Agenten: Product Manager, Trend Researcher, Feedback Synthesizer
├── project-management/   # 6 Agenten: Studio Producer, Project Shepherd, Experiment Tracker
├── testing/              # 8 Agenten: Reality Checker, Evidence Collector, API Tester
├── support/              # 6 Agenten: Support Responder, Analytics Reporter, Legal Compliance
├── spatial-computing/    # 6 Agenten: XR Architect, visionOS Engineer, Metal Developer
├── specialized/          # 30+ Agenten: MCP Builder, Blockchain Auditor, Compliance Auditor
├── game-development/     # 20+ Agenten: Unity Architect, Unreal Systems, Godot Scripter, Roblox
└── academic/             # 5 Agenten: Anthropologist, Historian, Psychologist, Narratologist

Jede Abteilung enthält Agenten mit tiefgreifendem Fachwissen. Die Engineering-Abteilung umfasst allein Frontend-Entwickler, Backend-Architekten, DevOps-Automatisierer, Sicherheitsingenieure und sogar Embedded-Firmware-Ingenieure.

Agenten-Anatomie: Im Inneren eines 400-Zeilen-KI-Spezialisten

Jeder Agent folgt der gleichen Struktur. Hier ist die Aufschlüsselung am Beispiel des Backend-Architekten:

Frontmatter (YAML)

---
name: Backend-Architekt
description: Leitender Backend-Architekt, spezialisiert auf skalierbares Systemdesign, Datenbankarchitektur, API-Entwicklung und Cloud-Infrastruktur
color: blue
emoji: 🏗️
vibe: Entwirft die Systeme, die alles zusammenhalten – Datenbanken, APIs, Cloud, Skalierung.
---

Diese Metadaten sind nicht nur dekorativ. Tools wie Cursor und Claude Code verwenden die Felder name und description zur Agentenentdeckung. Das emoji bietet eine visuelle Identifizierung in Chat-Schnittstellen.

Identität & Speicher

## 🧠 Ihre Identität & Ihr Speicher
- **Rolle**: Spezialist für Systemarchitektur und serverseitige Entwicklung
- **Persönlichkeit**: Strategisch, sicherheitsorientiert, skalierungsbewusst, obsessiv zuverlässig
- **Speicher**: Sie erinnern sich an erfolgreiche Architekturmuster, Leistungsoptimierungen und Sicherheits-Frameworks
- **Erfahrung**: Sie haben Systeme durch richtige Architektur erfolgreich werden und durch technische Abkürzungen scheitern sehen

Dieser Abschnitt etabliert die Persona und die Fachkenntnisse des Agenten. Es ist nicht nur schmückender Text – es bereitet das LLM darauf vor, eine spezifische Denkweise anzunehmen.

Kernmission

## 🎯 Ihre Kernmission

### Exzellenz im Daten-/Schema-Engineering
- Definieren und pflegen von Datenschemata und Indexspezifikationen
- Entwerfen effizienter Datenstrukturen für große Datensätze (100.000+ Entitäten)
- Implementieren von ETL-Pipelines für Datenumwandlung und -vereinheitlichung
- Erstellen von Hochleistungs-Persistenzschichten mit Abfragezeiten unter 20 ms

Jeder Missionspunkt enthält messbare Ziele. Beachten Sie „Abfragezeiten unter 20 ms“ und „100.000+ Entitäten“ – dies sind keine vagen Ziele.

Kritische Regeln

## 🚨 Kritische Regeln, die Sie befolgen müssen

### Security-First-Architektur
- Implementieren von "Defense-in-Depth"-Strategien über alle Systemschichten hinweg
- Anwenden des Prinzips der geringsten Privilegien für alle Dienste und Datenbankzugriffe
- Verschlüsseln von Daten im Ruhezustand und während der Übertragung gemäß aktuellen Sicherheitsstandards

Regeln sind nicht verhandelbare Einschränkungen. Sie setzen das allgemeine LLM-Verhalten außer Kraft.

Technische Lieferobjekte

Hier unterscheiden sich Agenten von generischen Prompts. Der Backend-Architekt liefert vollständigen, ausführbaren Code:

-- Schemaentwurf für E-Commerce-Datenbank
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    deleted_at TIMESTAMP WITH TIME ZONE NULL
);

CREATE INDEX idx_users_email ON users(email) WHERE deleted_at IS NULL;
CREATE INDEX idx_users_created_at ON users(created_at);

// Express.js API mit Sicherheits-Middleware
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100,
  message: 'Zu viele Anfragen von dieser IP, bitte versuchen Sie es später erneut.',
});

Erfolgsmetriken

## 🎯 Ihre Erfolgsmetriken

Sie sind erfolgreich, wenn:
- API-Antwortzeiten für das 95. Perzentil unter 200 ms bleiben
- Die Systemverfügbarkeit 99,9 % übersteigt
- Datenbankabfragen im Durchschnitt unter 100 ms ausgeführt werden
- Sicherheitsaudits keine kritischen Schwachstellen finden

Jeder Agent definiert messbare Ergebnisse. Dies ist keine Therapie-Bestätigung – es ist technische Verantwortlichkeit.

Multi-Tool-Integration: Ein Agent, 10 IDEs

Die Agentur funktioniert mit über 10 KI-Codierungs-Tools. So funktioniert die Integrationsebene:

Unterstützte Tools

Das Konvertierungsskript (convert.sh)

Das Bash-Skript scripts/convert.sh übernimmt die Formatübersetzung. Hier ist die Architektur:

#!/usr/bin/env bash
# convert.sh — Agenten-MD-Dateien der Agentur in werkzeugspezifische Formate konvertieren

set -euo pipefail

AGENT_DIRS=(
  academic design engineering game-development marketing paid-media
  sales product project-management testing support spatial-computing specialized
)

# Frontmatter-Felder extrahieren
get_field() {
  local field="$1" file="$2"
  awk -v f="$field" '
    /^---$/ { fm++; next }
    fm == 1 && $0 ~ "^" f ": " { sub("^" f ": ", ""); print; exit }
  ' "$file"
}

# Frontmatter entfernen, Rumpf zurückgeben
get_body() {
  awk 'BEGIN{fm=0} /^---$/{fm++; next} fm>=2{print}' "$1"
}

Für Cursor konvertiert das Skript .md-Dateien in das .mdc-Regelformat:

convert_cursor() {
  local agent_file="$1"
  local slug=$(to_kebab "$(get_field 'name' "$agent_file")")
  local output_file="$OUT_DIR/cursor/.cursor/rules/agency-${slug}.mdc"

  cat > "$output_file" << EOF
---
description: Agentur-Agent: $(get_field 'description' "$agent_file")
---
$(get_body "$agent_file")
EOF
}

Für Aider und Windsurf kompilieren alle Agenten in einzelne Dateien:

convert_aider() {
  local output="$OUT_DIR/aider/CONVENTIONS.md"
  echo "# Agenten der Agentur für Aider" > "$output"
  echo "" >> "$output"

  for dir in "${AGENT_DIRS[@]}"; do
    for file in "$REPO_ROOT/$dir"/*.md; do
      echo "---" >> "$output"
      cat "$file" >> "$output"
    done
  done
}

Das Installationsskript (install.sh)

Nach der Konvertierung kopiert install.sh die Dateien in werkzeugspezifische Verzeichnisse:

#!/usr/bin/env bash
# install.sh — Installiert die Agenten der Agentur in Ihre lokalen Agenten-Tools

install_claude_code() {
  local src="$REPO_ROOT"
  local dest="$HOME/.claude/agents"
  mkdir -p "$dest"
  cp -r "$src"/{engineering,design,marketing,sales,specialized}/*.md "$dest/"
  ok "Claude Code: $(find "$dest" -name '*.md' | wc -l) Agenten installiert"
}

install_cursor() {
  local src="$OUT_DIR/cursor/.cursor/rules"
  local dest="./.cursor/rules"
  mkdir -p "$dest"
  cp "$src"/*.mdc "$dest/"
  ok "Cursor: $(find "$dest" -name '*.mdc' | wc -l) Regeln installiert"
}

Das Skript unterstützt die interaktive Auswahl:

  +------------------------------------------------+
  |   Die Agentur — Werkzeug-Installer             |
  +------------------------------------------------+

  System-Scan: [*] = auf diesem Gerät erkannt

  [x]  1)  [*]  Claude Code     (claude.ai/code)
  [x]  2)  [*]  Copilot         (~/.github + ~/.copilot)
  [x]  3)  [*]  Antigravity     (~/.gemini/antigravity)
  [ ]  4)  [ ]  Gemini CLI      (Gemini-Erweiterung)
  [x]  7)  [*]  Cursor          (.cursor/rules)

  [1-10] umschalten   [a] alle   [n] keine   [d] erkannt
  [Enter] installieren   [q] beenden

Die parallele Ausführung beschleunigt Multi-Tool-Installationen:

./scripts/install.sh --parallel --jobs 8

MCP-Speicher: Persistenter Kontext über Sitzungen hinweg

Standardmäßig beginnen KI-Agenten jede Sitzung von Grund auf neu. Die MCP-Speicher-Integration ändert dies.

Was ist MCP?

MCP (Model Context Protocol) ist ein Protokoll für KI-Agenten, um auf externe Tools und persistenten Speicher zuzugreifen. Die Agentur verwendet MCP, um Folgendes zu ermöglichen:

• Sitzungsübergreifender Speicher: Agenten merken sich Entscheidungen aus früheren Sitzungen
• Agentenübergabe: Ein Agent kann Kontext für einen anderen hinterlassen
• Rollback bei Fehler: Wiederherstellung auf bekannte, gute Zustände, wenn die Qualitätssicherung fehlschlägt

Das Speicher-Muster

Fügen Sie diesen Abschnitt zu jedem Agenten hinzu, um den MCP-Speicher zu aktivieren:

## Speicherintegration

Wenn Sie eine Sitzung starten:
- Rufen Sie relevante Kontexte aus früheren Sitzungen mithilfe Ihrer Rolle und Ihres Projekts als Suchbegriffe ab
- Überprüfen Sie alle Erinnerungen, die mit Ihrem Agentennamen markiert sind

Wenn Sie wichtige Entscheidungen treffen oder Lieferobjekte fertigstellen:
- Merken Sie sich die Entscheidung mit beschreibenden Tags (Agentenname, Projekt, Thema)
- Fügen Sie genügend Kontext hinzu, damit eine zukünftige Sitzung verstehen kann, was getan wurde und warum

Wenn Sie an einen anderen Agenten übergeben:
- Merken Sie sich Ihre Lieferobjekte, die für den empfangenden Agenten markiert sind
- Fügen Sie hinzu: was Sie abgeschlossen haben, was noch aussteht, was der nächste Agent wissen muss

MCP-Tools

Jeder MCP-Server, der diese Tools bereitstellt, funktioniert:

Beispiel: Speichergestützter Workflow

Ohne MCP-Speicher:

Benutzer: "Baue die API"
Agent: [Baut API, Sitzung beendet]

[Nächste Sitzung]
Benutzer: "Mache von gestern weiter"
Agent: "Ich habe keinen Kontext aus früheren Sitzungen. Können Sie einfügen, was wir getan haben?"

Mit MCP-Speicher:

Benutzer: "Baue die API"
Agent: [Baut API, erinnert sich: "Backend-Architekt – E-Commerce API – Benutzertabelle, JWT-Auth, Ratenbegrenzung"]

[Nächste Sitzung]
Benutzer: "Mache von gestern weiter"
Agent: [Erinnert sich: "Gestern habe ich die Benutzertabelle mit UUID-Primärschlüsseln entworfen, JWT-Authentifizierung mit Bcrypt-Hashing implementiert und eine Ratenbegrenzung von 100 Anfragen pro 15 Minuten hinzugefügt. Nächster Schritt: Schema des Bestellservices."]

Ein vollständiges Beispiel finden Sie unter integrations/mcp-memory/backend-architect-with-memory.md.

Herausragende Agenten: Drei Deep Dives

1. Realitätsprüfer (Testabteilung)

Der Realitätsprüfer stoppt fantasievolle Genehmigungen. Standardhaltung: „MUSS ÜBERARBEITET WERDEN“, bis das Gegenteil bewiesen ist.

## 🚨 Ihr obligatorischer Prozess

### SCHRITT 1: Realitätsprüfung-Befehle (NIEMALS ÜBERSPRINGEN)
```bash
# Überprüfen, was tatsächlich gebaut wurde
ls -la resources/views/ || ls -la *.html

# Behauptete Funktionen gegenchecken
grep -r "luxury\|premium\|glass\|morphism" . --include="*.html" --include="*.css" || echo "KEINE PREMIUM-FUNKTIONEN GEFUNDEN"

# Professionelle Playwright-Screenshot-Aufnahme ausführen
./qa-playwright-capture.sh http://localhost:8000 public/qa-screenshots

SCHRITT 2: QA-Kreuzvalidierung

• Überprüfen der Ergebnisse des QA-Agenten aus dem Headless-Chrome-Test
• Vergleichen der automatisierten Screenshots mit der Bewertung der QA
• Bestätigen oder Anzweifeln der QA-Bewertung mit zusätzlichen Beweisen

SCHRITT 3: End-to-End-Validierung

• Analyse von responsive-desktop.png, responsive-tablet.png, responsive-mobile.png
• Überprüfung der Interaktionsabläufe: nav--click.png, form-.png Sequenzen
• Überprüfung tatsächlicher Leistungsdaten (Ladezeiten, Fehler, Metriken)

Dieser Agent benötigt **visuelle Beweise**, bevor er irgendetwas genehmigt. Schluss mit „Sieht toll aus!“ ohne Nachweis.

---

### 2. Whimsy Injector (Design-Abteilung)

Der Whimsy Injector fügt Persönlichkeit hinzu, ohne die Benutzerfreundlichkeit zu opfern.

```css
/* Entzückende Schaltflächen-Interaktionen */
.btn-whimsy {
  position: relative;
  overflow: hidden;
  transition: all 0.3s cubic-bezier(0.23, 1, 0.32, 1);

  &::before {
    content: '';
    position: absolute;
    top: 0;
    left: -100%;
    width: 100%;
    height: 100%;
    background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.2), transparent);
    transition: left 0.5s;
  }

  &:hover {
    transform: translateY(-2px) scale(1.02);
    box-shadow: 0 8px 25px rgba(0, 0, 0, 0.15);
  }
}

// Erfolgssystem mit einem Hauch von Laune
class WhimsyAchievements {
  unlock(achievementId) {
    const achievement = this.achievements[achievementId];
    this.showCelebration(achievement);
    this.saveProgress(achievementId);
  }

  showCelebration(achievement) {
    const celebration = document.createElement('div');
    celebration.className = `achievement-celebration ${achievement.celebration}`;
    celebration.innerHTML = `
      <div class="achievement-card">
        <div class="achievement-icon">${achievement.icon}</div>
        <h3>${achievement.title}</h3>
        <p>${achievement.description}</p>
      </div>
    `;
    document.body.appendChild(celebration);
    setTimeout(() => celebration.remove(), 3000);
  }
}

Jedes spielerische Element muss einem funktionalen oder emotionalen Zweck dienen. Der Agent enthält eine vollständige Mikrotextbibliothek:

## Fehlermeldungen
**404-Seite**: "Hoppla! Diese Seite ist in den Urlaub gefahren, ohne uns Bescheid zu sagen."
**Formularvalidierung**: "Ihre E-Mail sieht etwas schüchtern aus – möchten Sie das @-Symbol hinzufügen?"
**Netzwerkfehler**: "Es scheint, als hätte das Internet einen Schluckauf gehabt. Versuchen Sie es erneut?"

3. MCP-Builder (Spezialisierte Abteilung)

Der MCP-Builder erstellt benutzerdefinierte Tools, die die Fähigkeiten von KI-Agenten erweitern.

// TypeScript MCP-Server-Skelett
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-server", version: "1.0.0" });

server.tool("search_items", { query: z.string(), limit: z.number().optional() },
  async ({ query, limit = 10 }) => {
    const results = await searchDatabase(query, limit);
    return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Kritische Regeln:

• Deskriptive Toolnamen: search_users nicht query1 — Agenten wählen Tools nach Namen aus
• Typisierte Parameter mit Zod: Jede Eingabe validiert, optionale Parameter haben Standardwerte
• Strukturierte Ausgabe: JSON für Daten zurückgeben, Markdown für menschenlesbaren Inhalt
• Fehler tolerant behandeln: Fehlermeldungen zurückgeben, niemals den Server abstürzen lassen

Community & Übersetzungen

Die Agentur begann mit einem Reddit-Thread. Jetzt hat sie:

• 147 Agenten in 12 Abteilungen
• Über 10.000 Zeilen Persönlichkeit, Prozesse und Codebeispiele
• Community-Übersetzungen: Vereinfachtes Chinesisch (zwei unabhängige Forks), weitere in Arbeit
• Multi-Tool-Unterstützung: Über 10 Integrationen, die über Konvertierungsskripte verwaltet werden

Bemerkenswerte Forks:

• agency-agents-zh von @jnMetaCode: 100 übersetzte Agenten + 9 originelle Agenten für den chinesischen Markt
• agent-teams von @dsclca12: Unabhängige Übersetzung mit Bilibili-, WeChat- und Xiaohongshu-Lokalisierung

Installation: Schnellstart

Option 1: Claude Code (Empfohlen)

# Agenten in Ihr Claude Code-Verzeichnis kopieren
cp -r agency-agents/* ~/.claude/agents/

# In jeder Sitzung aktivieren:
"Hey Claude, aktiviere den Frontend-Entwickler-Modus und hilf mir, eine React-Komponente zu erstellen"

Option 2: Multi-Tool-Installation

# Schritt 1: Integrationsdateien generieren
./scripts/convert.sh

# Schritt 2: Interaktiv installieren (erkennt Tools automatisch)
./scripts/install.sh

# Oder ein bestimmtes Tool direkt installieren
./scripts/install.sh --tool cursor
./scripts/install.sh --tool aider

Option 3: Als Referenz verwenden

Durchsuchen Sie die Agenten unter github.com/msitarzewski/agency-agents und passen Sie die benötigten an. Jede Datei enthält Identität, Workflows, Lieferobjekte und Codebeispiele.

Was macht das anders?

Vs. generische KI-Prompts

Vs. Prompt-Bibliotheken

Vs. KI-Tools

Technische Erkenntnisse

1. Spezialisierung schlägt Generalisierung: 147 Spezialisten übertreffen eine „Alles-Könner“-Anfrage
2. Struktur treibt die Ausgabe: Frontmatter + Identität + Mission + Regeln + Lieferobjekte + Metriken
3. Integration ist wichtig: Bash-Skripte konvertieren Agenten automatisch in über 10 Formate
4. Speicher ermöglicht Kontinuität: Das MCP-Protokoll löst das Problem „Ich erinnere mich nicht an gestern“
5. Community skaliert: Reddit-Thread → 147 Agenten → Übersetzungen → Multi-Tool-Unterstützung

Nächste Schritte

Möchten Sie die Agentur ausprobieren?

1. Durchsuchen Sie das vollständige Agentenverzeichnis
2. Installieren Sie es für Ihr bevorzugtes Tool (Claude Code, Cursor, Aider, etc.)
3. Aktivieren Sie Spezialisten namentlich: „Verwenden Sie den Realitätsprüfer, um zu verifizieren, dass dies produktionsreif ist.“
4. Tragen Sie bei: Fügen Sie neue Agenten hinzu, verbessern Sie bestehende, teilen Sie Erfolgsgeschichten

Bauen Sie selbst KI-Agenten? Studieren Sie die Agenten-Anatomie: Frontmatter für die Entdeckung, Identität für die Persona, Mission für den Umfang, Regeln für Einschränkungen, Lieferobjekte für die Ausgabe, Metriken für die Verantwortlichkeit.

Die Agentur beweist, dass Spezialisierung nicht nur für Menschen ist. Manchmal ist das beste KI-Team nicht ein Modell, das alles versucht – es sind 147 Spezialisten, die jeweils genau wissen, was sie tun sollen.

Schaltfläche