Enterprise LLM Architecture: Multi-Agent Systems

Das Problem: Token Costs skalieren exponentiell

Du baust ein Research-System mit drei Agenten: Financial Agent, News Agent, Patent Agent. Du chainst die Outputs naiv: A → B → C → Synthesis.

Die Rechnung:
Agent A Output: 5.000 Tokens
Agent B Input: 5.000 (von A) + eigene Arbeit
Agent C Input: 5.000 (A) + 8.000 (B) + eigene Arbeit
Synthesis Input: 5.000 + 8.000 + 12.000 = 25.000+ Tokens

Bei 12 Agenten: 100.000+ Tokens. Pro Request. Noch schlimmer: Wenn Agent C crashed, verlierst du alles.

Pattern 1: Shared Memory Architecture

Das Anti-Pattern: Daisy-Chaining Full Conversation Logs

Jeder Agent gibt seinen kompletten Output an den naechsten. Token Costs skalieren exponentiell. Kein State Persistence bei Failures.

Das Pattern: Shared Vector Store

Alle Subagents schreiben ihre Findings in einen zentralen Vector Store. Der Synthesis Agent holt nur relevante Findings per Semantic Search.

class SharedVectorStore:
def write_finding(self, agent_id, finding):
# Index claim + source + confidence
self.index(agent_id, finding)

def read_findings(self, query, top_k=10):
# Semantic Search statt Full Log
return self.search(query, top_k)

Der Effekt:
1. State persists. Wenn Agent C crashed, sind Findings von A und B noch im Store.
2. Token efficiency. Synthesis Agent holt nur Relevantes, nicht alles.
3. Decoupled execution. Agents koennen parallel laufen.

Pattern 2: Parallelization & Caching

Das Problem: Sequentielle Verarbeitung = inakzeptable Latency

12 Legal Precedents, jedes braucht ~15 Sekunden. Sequentiell: 180 Sekunden. Fuer einen interaktiven Use Case inakzeptabel.

Die Loesung: Subagent Parallelism + Prompt Caching

Parallelisierung mit asyncio.gather:

async def process_precedents_parallel(precedents):
tasks = [analyze_single(p) for p in precedents]
return await asyncio.gather(*tasks)

Ergebnis: ~20s statt 180s.

Fuer Synthesis mit 80K+ Tokens akkumulierter Findings: Prompt Caching aktivieren.

messages=[{"type": "text", "text": cached_context, "cache_control": {"type": "ephemeral"}}]

Prompt Caching reduziert Transfer Overhead um bis zu 90% bei Follow-up Queries.

Pattern 3: Structured Intermediate Representations

Das Problem: Format Loss bei Agent-to-Agent Communication

Financial Agent gibt JSON, News Agent Prosa, Patent Agent Listen. Der Synthesis Agent bekommt Mischmasch – Struktur und Attributionen gehen verloren.

Die Loesung: Format Conversion Layer

Alle Subagent-Outputs werden in ein gemeinsames Format konvertiert:

class IntermediateRepresentation:
claim: str # Die Aussage
evidence: str # Begruendung
source: str # Herkunft
confidence: float

Citation Rule: Der Synthesis Prompt muss explizit verlangen:
'When synthesizing findings, ALWAYS preserve source attributions.
Each claim must reference its original source: [Claim] (Source: [source_field])'

Pattern 4: Forcing Execution Order

Problem: Agent ruft Tools in falscher Reihenfolge auf.
Du willst: Erst extract_metadata, dann lookup_citations.
Der Agent macht manchmal das Gegenteil.

Loesung: tool_choice Enforcement:

response = client.messages.create(
tools=tools,
tool_choice={"type": "tool", "name": "extract_metadata"} # FORCE first tool
)

tool_choice ist deterministisch. Der Agent kann nicht anders – die API erzwingt das erste Tool.

Wann einsetzen:
• Pipeline-Steps muessen in bestimmter Reihenfolge laufen
• Enrichment braucht Output von Extraction
• Validation muss vor Submission passieren

Pattern 5: Goal-Oriented Delegation

Das Anti-Pattern: Procedural Micromanagement

Du gibst dem Subagent exakte Steps: "Search X, Read Y, Extract Z."
Wenn sich das Topic aendert oder Step 2 nichts liefert – der Agent folgt stur den Steps und verpasst bessere Alternativen.

Das Pattern: Goals + Quality Criteria

Statt:
"Step 1: Search for AI regulation 2024. Step 2: Read top 3 results."

Besser:
"GOAL: Comprehensive coverage of recent AI regulatory developments

QUALITY CRITERIA:
- Recency: Prioritize sources from the last 6 months
- Coverage: Include EU, US, and APAC perspectives
- Depth: Focus on policy implications

You determine the search strategy. Adapt based on what you find."

Der Effekt: Der Subagent passt seine Strategie an. Findet er eine primäre Policy-Quelle, geht er tiefer. Adaptiv statt rigide.

Die Production Architecture Blueprint

Drei Ebenen:

1. Pattern Router
Entscheidet Real-time vs. Batch (Intelligence at the edges)

2. Execution Layer
Granular Tools + Application Intercepts (Strict typing in the middle)

3. State Management
Pruning Logic + Shared Vector Store (Shared memory sustaining the lifecycle)

Takeaways fuer dein Multi-Agent-System

1. Shared Memory, nicht Daisy Chaining. Vector Store + Semantic Search skaliert linear, nicht exponentiell.

2. Parallelize unabhaengige Arbeit. 12 Precedents parallel = 20s statt 180s.

3. Prompt Caching fuer Synthesis. Bei 80K+ Tokens akkumulierter Findings: Cache einschalten.

4. Intermediate Format standardisieren. {claim, evidence, source, confidence} – egal welcher Agent.

5. tool_choice fuer kritische Reihenfolgen. API Constraints > Prompt Begging.

6. Goals + Criteria statt Steps. Lass Subagents ihre Strategie selbst bestimmen.

7. Blueprint-Architektur: Router → Execution (Tools + Intercepts) → State Management.

Dies war der letzte Artikel der Serie. Die vier Domaenen – Structured Data Extraction, Customer Support Orchestration, Developer Productivity, Multi-Agent Systems – bilden zusammen das Enterprise LLM Architecture Playbook.