Startseite / Artikel

Warum gekoppelte Agentenfähigkeiten versagen und die dreischichtige Lösung, die funktioniert

Tiefgehende Fähigkeitsketten überlasten den Kontext eines Agenten. Bauen Sie stattdessen mit Atomen, Molekülen und Verbindungen – mit Beispielen für Claude Code, LangGraph, CrewAI und Agno.

Verlag: REACTAPP.TOP9 Min. Lesezeit1996 Wörter

Quellen: Why AI Agent Skills Break When We Chain Them and the Three-Layer Fix

Je mehr Ebenen eine Kette von Agentenfähigkeiten hat, desto mehr vergisst der Agent. Ein dreistufiges Kompositionsmuster sorgt dafür, dass die Fähigkeiten in jeder Tiefe zuverlässig bleiben, und ist in Claude Code, LangGraph, CrewAI sowie Agno anwendbar.

Warum flache Fähigkeitsgraphen versagen

Auf dem Papier wirkt der Fähigkeitsgraph attraktiv: Man verbindet Fähigkeiten miteinander, lässt den Agenten den Graphen durchlaufen und baut nach Bedarf Fähigkeiten zusammen. Eine Marketingfähigkeit ruft eine Forschungsfähigkeit auf, diese wiederum eine Scraping-Fähigkeit – so entsteht ein automatisierter Ablauf.

In der Praxis versagt dieser Ansatz in Claude Code, Codex, Cursor sowie allen anderen Agenten mit begrenztem Kontextfenster.

Hier ist der Mechanismus. Der Agent lädt zunächst nur die Beschreibungen der Fähigkeiten, was ausreicht, um zu wissen, was vorhanden ist. Der vollständige Inhalt einer Fähigkeit wird geladen, sobald sie aufgerufen wird, und bleibt anschließend in der Sitzung, wodurch der Kontext verbraucht wird. Claude Code dokumentiert seine Grenzen offen: Sobald eine Sitzung komprimiert wird, darf eine einzelne Fähigkeit maximal 5.000 Token beinhalten, und alle Fähigkeiten zusammen haben insgesamt 25.000 Token zur Verfügung. Schon fünf vollständige Fähigkeiten erreichen diese Obergrenze. Wenn zehn geladen werden, wird ohne Vorwarnung etwas weggelassen. Andere Agenten stoßen bei unterschiedlichen Zahlen auf ähnliche Grenzen.

Entwickler in verschiedenen Frameworks beschreiben denselben Trend. Ein direkter Aufruf von B funktioniert zuverlässig. Ein Weg über B zu C ist unzuverlässig. Ein Weg über B zu C zu D ist eher Hoffnung als durchdachte Ingenieurskunst. Der Agent endet schließlich mit zu vielen Anweisungen, die um die Aufmerksamkeit konkurrieren, und zu wenig Platz, um sie alle zu speichern.

Die Fähigkeit zur Komposition an sich ist keine schlechte Idee – doch ihre Darstellung als flacher Graph ist es. Die hier gezeigten Beispiele verwenden das SKILL.md-Format von Claude Code, weil dessen Dokumentation am klarsten ist, doch das Muster aus Atomen, Molekülen und Verbindungen gilt für jeden Agenten mit Fähigkeiten, Werkzeugen oder Plugins.

Drei Ebenen, die der tatsächlichen Komposition entsprechen

Die meisten Agent-Frameworks strukturieren bereits Inhalte in Schichten: direkte Werkzeuge, gekoppelte Workflows sowie Delegation an Unteragenten. Claude Code macht dies durch seine Hierarchie aus Befehlen, Fähigkeiten und Aufgaben explizit. Die drei unten aufgeführten Ebenen entsprechen Codex (Fähigkeiten und Befehle), Cursor (Regeln und Werkzeuge) sowie allen Systemen, die die Aufrufung von Werkzeugen und Unterprozessen unterstützen.

Atome: eine Fähigkeit, eine Aufgabe

Ein Atom ist ein SKILL.md-Datei für eine spezifische, eng gefasste Aufgabe mit nahezu deterministischem Verhalten. Es ruft keine anderen Fähigkeiten auf und trifft keine Entscheidungen. Es verfügt über eine klare Eingabe und eine klare Ausgabe.

---
name: verify-email
description: Verify an email address using Hunter.io API.
  Use when validating email deliverability before outreach.
allowed-tools: Bash
---
## Verify Email
1. Read the Hunter API key from $HUNTER_API_KEY
2. Call the Hunter email-verifier endpoint
3. Return: status (deliverable/risky/undeliverable), score, smtp_check
4. If the API errors, report the error. Do not guess.

Ein einfacher Test: Wenn Sie die gesamte Fähigkeit in einem Satz beschreiben können, ohne „und“ zu verwenden, handelt es sich um ein Atom. Weitere Beispiele sind das Umwandeln einer URL in Markdown, das Ausführen eines Testsets, das Überprüfen einer Datei auf Fehler, das Herunterladen eines Pull-Request-Diffs oder das Abfragen von DNS-Einträgen.

Moleküle: ausgeschriebene Ketten von Atomen

Ein Molekül löst ein größeres Problem, indem es zwei bis zehn Atome in einer festgelegten Reihenfolge ausführt. Was es von einem Fähigkeitsgraphen unterscheidet, ist, dass die Orchestrierung schriftlich festgehalten wird. Das Molekül hängt nicht davon ab, dass das Modell im Laufzeitbetrieb herausfindet, welche Atome vorhanden sind, und die Reihenfolge errät.

---
name: qualify-lead
description: Research a company, find the right contact, verify
  their email, output a qualified lead card.
allowed-tools: Bash Read Write
---

## Qualify Lead
Execute these steps IN ORDER.
### Step 1: Company Research
Use /research-company. Capture: size, industry, funding, tech stack.
### Step 2: Find Contact
Use /find-contact. Target: VP Eng, CTO, Head of Platform.
### Step 3: Find & Verify Email
Use /find-email, then /verify-email.
If undeliverable, return to Step 2 (max 3 attempts).
### Step 4: Output Lead Card
Write structured markdown to leads/{company-slug}.md

Achten Sie darauf, was in der Datei weggelassen wird. Sie weist den Agenten niemals an, herauszufinden, welche Fähigkeiten er benötigt. Stattdessen nennt sie die Reihenfolge: das Unternehmen recherchieren, die Kontaktdaten finden, die E-Mail herausfinden und anschließend diese überprüfen – in dieser Reihenfolge.

Genau diese Klarheit ist die Quelle der Zuverlässigkeit. Eine vage Anweisung wie „Recherchieren Sie das Unternehmen und finden Sie die beste Möglichkeit, mit ihnen in Kontakt zu treten“ lässt das Modell zur Laufzeit selbst entscheiden, welche Schritte ausgeführt werden, wodurch es manchmal einen Schritt überspringt oder einen Workflow improvisiert, der Ihre ursprünglichen Anweisungen völlig ignoriert.

Komplexe Aufgaben: Koordination von Unteragenten

Komplexe Aufgaben kommen dann ins Spiel, wenn ein einzelnes Kontextfenster nicht alles aufnehmen kann. Dabei wird das Task-Tool von Claude Code genutzt, um Unteragenten zu starten, von denen jeder sein eigenes Kontextfenster sowie eigene vorgeladene Fähigkeiten besitzt.

---
name: outbound-playbook
description: Run the full outbound playbook for a target segment.
  Spawns parallel agents to qualify leads and draft emails.
disable-model-invocation: true
allowed-tools: Bash Read Write Task Teammate
---

## Outbound Playbook
### Phase 1: Build Lead List
Ask the user for: target segment, company size range, geography.
Use /scrape-directory to pull matching companies.
### Phase 2: Parallel Lead Qualification (Task tool)
For each company (batch of 5):
- Spawn a subagent with qualify-lead preloaded
- Each subagent qualifies one company independently
### Phase 3: Draft Emails (Task tool)
For each qualified lead:
- Spawn a subagent with draft-email preloaded
### Phase 4: Human Review Checkpoint
STOP. Present sample drafts. Ask: "Review these. Adjust or proceed?"
Do NOT proceed without explicit user approval.
### Phase 5: Campaign Summary
Compile results to outbound/{segment}/campaign-summary.md

Zwei Eigenschaften heben Compounds hervor. Erstens erhalten die Unteragenten separate Kontextfenster, sodass die Lead-Qualifizierung nicht um Platz mit der Erstellung von E-Mails konkurriert. Deshalb können Compounds über die Grenze hinaus skalieren, die tiefe Ketten blockiert.

Zweitens bedeutet disable-model-invocation: true, dass nur eine Person das Playbook starten kann. Das Modell kann nicht selbst entscheiden, eine Ausgangskampagne zu starten. Compounds lösen reale Aktionen aus, daher sollte ein Mensch die Kontrolle haben.

Ordnerstruktur

.claude/skills/
  # ATOMS — single purpose, near-deterministic
  verify-email/SKILL.md
  find-email/SKILL.md
  find-contact/SKILL.md
  research-company/SKILL.md
  scrape-url/SKILL.md


# MOLECULES - explicit chains of atoms
  qualify-lead/SKILL.md
  review-and-test/SKILL.md
  draft-blog-post/SKILL.md
  # COMPOUNDS - subagent orchestration, human-driven
  outbound-playbook/SKILL.md
  feature-build-ship/SKILL.md

Die Namen sind flexibel. Entscheidend ist die Trennung.

Dieselbe Idee anderswo

Es gibt nichts hier, was speziell für SKILL.md ist. Jedes große Agentenframework bietet Äquivalente, und die Syntax ändert sich, während die Kompositionslogik gleich bleibt.

LangGraph: Werkzeuge, Ketten, Untergraphen

In LangGraph sind Atome Funktionen, die mit @tool markiert sind, Moleküle sind sequenzielle Graphen mit expliziter Knotenreihenfolge, und Verbindungen sind Untergraphen mit eigenem Zustand.

from langgraph.graph import StateGraph
from langchain_core.tools import tool

# ATOM: a single tool
@tool
def verify_email(email: str) -> dict:
    """Verify email deliverability via Hunter.io."""
    response = requests.get(f"https://api.hunter.io/v2/email-verifier?email={email}")
    return response.json()

# MOLECULE: explicit sequential graph
workflow = StateGraph(LeadState)
workflow.add_node("research", research_company)
workflow.add_node("find_contact", find_contact)
workflow.add_node("verify", verify_email)
workflow.add_edge("research", "find_contact")
workflow.add_edge("find_contact", "verify")
graph = workflow.compile()

# COMPOUND: subgraph composition
parent = StateGraph(CampaignState)
parent.add_node("qualify", qualify_subgraph)   # each is a compiled graph
parent.add_node("draft", email_subgraph)       # with its own state
parent.add_node("review", human_review_node)

Der Unterschied zu Claude Code besteht darin, dass eine LangGraph-Molekül eine Graphstruktur mit expliziten Kanten ist statt einer Liste von Anweisungen, wodurch die Orchestrierung strukturell und nicht textbasiert erfolgt. Bedingungen, Schleifen und parallele Pfade lassen sich auf diese Weise natürlicher umsetzen, erfordern jedoch mehr Code für die Einrichtung.

CrewAI: Werkzeuge, Aufgaben, Teams innerhalb von Flüssen

CrewAI bietet eine klare Strukturierung. Atome sind Werkzeuge, Moleküle sind Aufgaben, die durch context-Abhängigkeiten miteinander verbunden sind, und Verbindungen sind Teams, die von Flüssen gesteuert werden.

from crewai import Agent, Task, Crew, Flow
from crewai.tools import tool


# ATOM: a tool
@tool
def verify_email(email: str) -> str:
    """Verify email deliverability."""
    return requests.get(f"https://api.hunter.io/v2/email-verifier?email={email}").text


# MOLECULE: tasks chained via context
researcher = Agent(role="Researcher", goal="Find company info", tools=[search_tool])
verifier = Agent(role="Verifier", goal="Verify contacts", tools=[verify_email])
research_task = Task(description="Research {company}", agent=researcher)
verify_task = Task(description="Verify the contact", agent=verifier, context=[research_task])
crew = Crew(agents=[researcher, verifier], tasks=[research_task, verify_task])


# COMPOUND: Crews inside a Flow
class OutboundFlow(Flow):
    @start()
    def qualify_leads(self):
        return qualify_crew.kickoff(inputs={"segment": self.state.segment})
    @listen(qualify_leads)
    def draft_emails(self, qualified):
        return email_crew.kickoff(inputs={"leads": qualified})
    @listen(draft_emails)
    def human_review(self, drafts):
        return drafts  # pause for human approval

Der Parameter context=[research_task] stellt die explizite Verbindung her. Dieser Parameter weist die Überprüfungsaufgabe an, zu warten, bis die Forschungsaufgabe abgeschlossen ist, und das Ergebnis dieser Aufgabe zu lesen. Wenn man ihn weglässt, läuft jede Aufgabe unabhängig, wodurch die Kette unterbrochen wird.

Agno: Werkzeuge, Agenten, Teams

Agno verfügt über die einfachste Klassifizierung. Atome sind @tool-Funktionen, eine Molekül ist ein Agent, der mehrere Werkzeuge sowie eine Beschreibung enthält, die die Ausführungsreihenfolge festlegt, und Verbindungen nutzen den Team-Construct.

from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools import tool


# ATOM
@tool
def verify_email(email: str) -> str:
    """Verify email deliverability via Hunter.io."""
    return requests.get(f"https://api.hunter.io/v2/email-verifier?email={email}").text


# MOLECULE: agent with ordered tools
qualify_agent = Agent(
    model=Claude(id="claude-sonnet-4-6"),
    description="Qualify a lead: research company, find contact, verify email. Execute in that order.",
    tools=[research_company, find_contact, find_email, verify_email],
)


# COMPOUND: team of agents
from agno.team import Team
outbound_team = Team(
    agents=[qualify_agent, email_drafter, campaign_reporter],
    description="Run the full outbound playbook for a target segment.",
)

Weil die Anordnung in der Beschreibung festgelegt ist, ähnelt Agnos Molekül eher dem Ansatz von SKILL.md als den strukturellen Kanten von LangGraph. Es ist einfacher zu schreiben und weist eine etwas geringere Determiniertheit bezüglich der Reihenfolge auf.

Eine Architektur, viele Syntaxen

Die Implementierungsdetails unterscheiden sich, doch die Grundstruktur bleibt dieselbe. Jedes Framework, das über einfache Demonstrationen hinauswächst, weist letztendlich dieselben drei Schichten auf, da die Einschränkungen überall identisch sind: begrenzter Kontext, unzuverlässige automatische Verknüpfung sowie die Notwendigkeit menschlicher Überwachung bei kritischen Aufgaben.

Wo es immer noch versagt

  • Schwache Atome ruinieren alles, was über ihnen liegt. Wenn ein verify-email-Atom Erfolg meldet, obwohl die API tatsächlich fehlschlägt, erzeugen alle darauf angewiesenen Moleküle und Verbindungen Unsinniges. Testen Sie die Atome nacheinander, bevor Sie sie kombinieren.
  • Moleküle mit mehr als zehn Atomen sind unzuverlässig. In Claude Code gibt es eine feste Obergrenze für das kombinierte Post-Compaction-Budget, und andere Agenten haben ihre eigenen Grenzen. Beschränken Sie sich auf Moleküle mit zwei bis zehn Atomen und platzieren Sie kritische Schritte früh im Ablauf.
  • Verbindungen mit acht bis zehn Molekülen erreichen ebenfalls ihre eigene Obergrenze. Der Orchestrator muss überwachen, welche Subagenten ihre Aufgaben abgeschlossen haben, was sie erzeugt haben und was als Nächstes kommt; ab einer bestimmten Größe verliert er den Überblick. Teilen Sie größere Verbindungen in zwei Teile auf und setzen Sie einen menschlichen Kontrollpunkt dazwischen.
  • Automatische Aufrufe sind weniger zuverlässig als explizite Aufrufe. In den veröffentlichten Agent-Bewertungen von Vercel wurden Fälle festgestellt, in denen bestimmte Fähigkeiten in einem großen Anteil der Testfälle nicht aufgerufen wurden – dieses Muster gilt vermutlich auch außerhalb von Claude Code. Bei Atomen ist das noch akzeptabel. Bei Molekülen und Verbindungen sollten Sie die automatische Aufruffunktion deaktivieren und sie selbst auslösen.

Sie sind der Fahrer und der Agent ist der Motor.

Warum das wichtig ist

Die knappe Ressource sind weder Rechenleistung noch Tokens – es ist Ihre Aufmerksamkeit. Das Eingeben von „Diesen E-Mail-Adresse überprüfen“ sowie das Eingeben von „Ausgehende Anfragen für den Fintech-Sektor starten“ erfordern ungefähr denselben mentalen Aufwand zur Initiierung und Überwachung, doch die Ergebnisse unterscheiden sich um Größenordnungen.

Kurz gesagt: Atome liefern dem Agenten vorhersehbare Arbeitseinheiten, Moleküle verbinden diese Einheiten zu Sequenzen, die etwas erreichen, und Verbindungen führen mehrere Sequenzen gleichzeitig in separaten Kontextfenstern aus. Jeder Ebene kommt ein Ergebnis hinzu, während Ihre eigene Aufmerksamkeit im Großen und Ganzen konstant bleibt.

Die Architektur wird bereits unterstützt – explizit in Claude Code sowie durch äquivalente Konstruktionen anderswo. Das Kompositionsmuster ist es jedoch, das die meisten Entwickler noch nicht umgesetzt haben.

Die Dokumentation zu den Fähigkeiten von Claude Code befindet sich unter code.claude.com/docs/en/skills, und das SKILL.md-Format folgt dem offenen Agent Skills-Standard, der in verschiedenen KI-Tools funktioniert. Atome, Moleküle und Verbindungen stellen ein vorgeschlagenes Muster dar, und der angezeigte Code ist Pseudocode, der dazu dient, die Konzepte zu erklären.