Praktische Hinweise: Ein Leitfaden zu Multi-Agent-Architekturen
Schritt-für-Schritt-Anleitung zu den Praktischen Notizen: Ein Feldführer für Mehr-Agenten-Architekturen – Verträge, Überprüfungen sowie Code-Blöcke für Teams, die dieses Muster einsetzen.
Dieser Leitfaden erstellt erneut den Weg von Rohstoffen bis zu einem funktionsfähigen System für: Ein Feldführer zu Multi-Agent-Architekturen. Der Schwerpunkt liegt auf ausführbaren Schritten, expliziten Überprüfungen sowie Code, den man ohne Rätseln über die Absicht direkt in ein Repository einfügen kann. In der Übersichtsphase sollten Eingaben, Verantwortliche für die Schritte sowie Abbruchkriterien definiert werden, bevor Code geändert wird. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.
1. Hierarchische Multi-Agent-Systeme
Beim Arbeiten an der Stufe 1 „Hierarchische Mehr-Agentensysteme“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsame Umgebungen übergeht. Erstellen Sie einen Checkpoint nach aufwändigen Schritten. Das Wiederaufnehmen des Prozesses sollte keine erneuten Gebühren für denselben LLM-Aufruf verursachen, wenn ein Operator einen späteren Knoten erneut ausführt.
from fundamental_analysis_tools import evaluate_fundamentals
from langchain.agents import create_agent
from technical_analysis_tools import technical_analysis
agent = create_agent(
model=llm,
tools=[technical_analysis, evaluate_fundamentals]
)
Supervisor
├── Technical Analysis Tool
└── Fundamental Analysis Tool
Supervisor
├── Technical Analyst Agent
│ ├── Tool A
│ ├── Tool B
│ └── ...
└── Fundamental Analyst Agent
├── Tool C
├── Tool D
└── ...
from langchain.tools import tool
from langgraph_supervisor import create_supervisor
@tool
def get_weather(city: str) -> str:
"""Use this tool to get the weather of a city or location"""
return f"The weather is sunny in {city}"
weather_expert = create_agent(
model=llm,
tools=[get_weather],
name="weather_expert"
)
technical_analyst_agent = create_agent(
model=llm,
tools=[technical_analysis],
name="technical_analyst"
)
fundamental_analyst_agent = create_agent(
model=llm,
tools=[evaluate_fundamentals],
name="fundamental_analyst"
)
analysis_squad = create_supervisor(
[technical_analyst_agent, fundamental_analyst_agent],
model=llm,
supervisor_name="analysis_supervisor",
prompt=(
"You are a team supervisor managing a fundamental analyst and a "
"technical analyst..."
)
)
analysis_app = analysis_squad.compile(
name="fundamental_and_technical_analyst"
)
supervisor_graph = create_supervisor(
[analysis_app, weather_expert],
model=llm,
prompt=(
"You are a team supervisor managing a fundamental analyst, a "
"technical analyst and a weather expert..."
)
)
supervisor = supervisor_graph.compile()
Wann sollten Sie eine hierarchische Architektur verwenden?
Wenn Sie den Abschnitt „Wann sollten Sie die Stage-Funktion verwenden?“ bearbeiten, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreuer ohne das Durchlesen des gesamten Systems überprüfen können. Erstellen Sie nach kostspieligen Schritten einen Checkpoint. Das System sollte bei einer Wiederholung eines späteren Schritts nicht denselben LLM-Aufruf erneut berechnen.
2. Explizite Multi-Agent-Workflows
Beim Arbeiten an der Stufe „2 Explicit Multi Agent“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Wiederherstellungsprozess gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Legen Sie nach aufwändigen Schritten einen Checkpoint an – das Wiederaufnehmen des Vorgangs sollte keine erneute Abrechnung für denselben LLM-Aufruf veranlassen, wenn ein Operator einen späteren Knoten erneut versucht. Behandeln Sie diese Stufe als Vertrag zwischen Eingaben und validierten Ausgaben: Nennen Sie die Ergebnisdokumente, definieren Sie Erfolgsprüfungen und lehnen Sie stille, teilweise abgeschlossene Vorgänge ab.
def execute_plan(
plan: Plan,
state: State,
) -> Command[
Literal[
"fundamental_analysis_agent",
"technical_analysis_agent",
"respond",
]
]:
gotos = [
Send(
step.action.agent_to_use,
{"query": step.action.query_to_send},
)
for step in plan.steps
]
if not gotos:
gotos.append(
Send("respond", {"messages": state["messages"]})
)
return Command(goto=gotos)
def router(state: State) -> Command[
Literal["fundamental_analysis_agent", "technical_analysis_agent", "respond"]
]:
# Get plan
query = state['messages'][-1].content
response = llm_planner.invoke(query) #invoke planner
return execute_plan(response, state)
Wann explizite Multi-Agent-Workflows verwendet werden
Die Methode „Wann explizite Phasen verwenden“ funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn sich der Einsatzbereich von einer Demo auf gemeinsame Umgebungen verschiebt. Halten Sie den Zustand der Grafik einfach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Verarbeitung.
3. Agent Swarm
Die Phase „3 Agent Swarm“ funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein goldenes Transkript, einen Fehlerfall sowie die Rollback-Anmerkung. Bewahren Sie Konfigurationen außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher sowie Feature-Flags sollten an einem Ort gesammelt sein, den Betreuer ohne Durchsicht des gesamten Graphen prüfen können. Halten Sie den Zustand des Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Wiederaufnehmen der Ausführung.
from langgraph_swarm import (
create_handoff_tool,
create_swarm,
)
## We'll have to redefine our all agents to include the handoff tool
weather_expert = create_agent(
model=llm,
tools=[
get_weather,
create_handoff_tool(
agent_name="technical_analyst",
description="Transfer for technical analysis related questions"
),
create_handoff_tool(
agent_name="fundamental_analyst",
description="Transfer for fundamental analysis related questions"
),
],
name="weather_expert"
)
technical_analyst_agent = ...
fundamental_analyst_agent = ...
swarm_workflow = create_swarm(
[fundamental_analyst_agent, technical_analyst_agent, weather_expert],
default_active_agent="weather_expert" #a default agent must be specified.
)
swarm = swarm_workflow.compile()
Wann sollten Sie einen Schwarm verwenden?
„When should you use stage“ funktioniert am besten, wenn es als messbare Ebene betrachtet wird. Erfassen Sie ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Dokumentieren Sie gleichzeitig den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Halten Sie den Zustand der Graphen flach und typisiert – verschachtelte Strukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen des Ablaufs. „When should you use stage“ funktioniert am besten, wenn es als messbare Ebene betrachtet wird. Erfassen Sie ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.
4. Blackboard-Multi-Agentensysteme
Für die 4. Blackboard-Multi-Agenten-Phase sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erfassen Sie neben den funktionalen Ergebnissen auch die Laufzeiten sowie die Kosten für Token oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung wechselt. Setzen Sie menschliche Freigabe für Schritte voraus, die Geld kosten oder Produktionsdaten ändern. Eine Verkabelung zur Kompilierzeit bedeutet nicht automatisch vollständige Geschäftsabdeckung.
a. Das Blackboard
Für die Blackboard-Phase sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Operator:innen sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Bewahren Sie Konfigurationen außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Operator:innen überprüfen können, ohne den gesamten Ablauf durchzulesen. Setzen Sie menschliche Freigabe für Kanten voraus, die Geld ausgeben oder Produktionsdaten ändern. Eine Verkabelung zur Kompilierzeit bedeutet nicht automatisch vollständige Geschäftsabdeckung.
class Blackboard(TypedDict, total=False):
query: str
# Problem frame
problem_framed: bool
ticker: str | None
location: str | None
wants_technical: bool
wants_fundamental: bool
# Specialist panels
technical: dict | None
fundamental: dict | None
environmental: dict | None
# Integrated solution
synthesis: str | None
# Control state
next_knowledge_source: str | None
cycles: int
b. Wissensquellen
In der Phase der Wissensquellen sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Bediener sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen. Setzen Sie menschliche Freigabe für Schritte voraus, die Geld kosten oder Produktionsdaten ändern. Eine Verkabelung zur Kompilierzeit bedeutet noch nicht vollständige Geschäftsabdeckung. In der Phase der Wissensquellen sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Bediener sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Vorgänge ab.
def can_analyse_technicals(board: Blackboard) -> bool:
return (
board.get("ticker") is not None
and board.get("wants_technical", False)
and board.get("technical") is None
)
c. Der Steuerelement-Komponente
Während der Phase „c. Die Steuerelement-Komponente“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Legen Sie nach aufwändigen Schritten einen Kontrollpunkt an. Das Wiederaufnehmen des Vorgangs sollte keine erneute Abrechnung für denselben LLM-Aufruf veranlassen, wenn ein Operator einen späteren Knoten erneut ausführt.
def control_component(board: Blackboard) -> dict:
eligible = [
source
for source in KNOWLEDGE_SOURCES #these are subagents
if source.precondition(board)
]
if not eligible:
return {"next_knowledge_source": None}
chosen = max(
eligible,
key=lambda source: source.priority,
)
return {
"next_knowledge_source": chosen.name,
"cycles": board.get("cycles", 0) + 1,
}
inspect → identify eligible specialists → activate one
→ contribute → inspect again
Die Ausführung ist absichtlich sequenziell
Wenn Sie die absichtlich sequenzielle Ausführungsphase durchlaufen, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreuer ohne das Durchlesen des gesamten Graphen überprüfen können. Erstellen Sie Zwischenchecks nach aufwändigen Schritten. Das Wiederaufnehmen der Ausführung sollte keine doppelte Abrechnung für denselben LLM-Aufruf verursachen, wenn ein Betreuer einen späteren Knoten erneut ausführt.
Wann sollten Sie eine Blackboard-Architektur verwenden?
Beim Bearbeiten des Abschnitts „Wann sollten Sie diese Phase verwenden?“, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Legen Sie nach aufwändigen Schritten einen Kontrollpunkt an – das Resume sollte bei erneuten Versuchen eines Operators keine doppelten Abrechnungen für denselben LLM-Aufruf erstellen. Behandeln Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben: Nennen Sie die Artefakte, definieren Sie Erfolgsprüfungen und lehnen Sie stille, teilweise abgeschlossene Vorgänge ab.
5. Actor-Critic (Adversarial) Multi-Agenten-Systeme
Das 5-Actoren-Kritiker-basierte adversäre Mehrphasenverfahren funktioniert am besten, wenn es als messbare Struktur betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein gelungenes Beispiel, einen Fehlerfall sowie die Notizen zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn sich der Ablauf von einer Demo in gemeinsam genutzte Umgebungen verschiebt. Halten Sie den Graphenzustand flach und typisiert – eingebettete Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Wiederaufnehmen des Ablaufs.
actor → critic → judge
↑ |
└──── revise ─────┘
a. Der Akteur
The a The Actor-Modell funktioniert am besten, wenn es als messbare Struktur betrachtet wird. Erfassen Sie einen erfolgreichen Fall, einen Fehlerfall sowie die Notizen zur Rücksetzung, bevor Sie den Umfang erweitern. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreuer ohne Durchsicht des gesamten Graphen überprüfen können. Halten Sie den Zustand des Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Störungen bei Unterbrechungen.
def actor(state: AdversarialState) -> dict:
if state.get("latest_critique") is None:
prompt = f"Produce a first draft.\n\nTASK: {state['task']}"
else:
prompt = (
"Revise the current draft.\n\n"
f"TASK:\n{state['task']}\n\n"
f"CURRENT DRAFT:\n{state['draft']}\n\n"
f"CRITIQUE:\n{state['latest_critique']}\n\n"
f"JUDGE'S PRIORITY:\n{state['latest_verdict']['focus']}"
)
draft = llm.invoke(prompt).content
return {
"draft": draft,
"round": state.get("round", 0) + 1,
}
b. Der Kritiker
The b Kritikphase funktioniert am besten, wenn sie als messbare Ebene betrachtet wird. Erfassen Sie ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Halten Sie den Zustand der Graphen flach und typisiert – verschachtelte Datenstrukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Verarbeitung. The b Kritikphase funktioniert am besten, wenn sie als messbare Ebene betrachtet wird. Erfassen Sie ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die relevanten Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.
class Issue(BaseModel):
severity: Literal["blocking", "major", "minor"]
description: str
class Critique(BaseModel):
issues: list[Issue]
summary: str
def weighted_issue_score(issues: list[dict]) -> int:
weights = {
"blocking": 5,
"major": 2,
"minor": 1,
}
return sum(
weights[issue["severity"]]
for issue in issues
)
c. Der Richter
Zur Judge-Phase sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Zeiten sowie Kosten für Token oder Abfragen sollten neben den funktionalen Ergebnissen aufgezeichnet werden. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Bei Schritten, die Geld kosten oder Produktionsdaten ändern, sollte eine menschliche Freigabe erforderlich sein. Eine Verkabelung zur Kompilierzeit bedeutet nicht automatisch vollständige Geschäftsabdeckung.
class Verdict(BaseModel):
decision: Literal["accept", "revise"]
reasoning: str
focus: str
def judge(state: AdversarialState) -> dict:
verdict = llm.with_structured_output(Verdict).invoke(
[
HumanMessage(
content=(
"Evaluate the critic's findings on their merits. "
"Accept if only minor issues remain. "
"Request revision only for blocking or material problems.\n\n"
f"DRAFT:\n{state['draft']}\n\n"
f"CRITIQUE:\n{state['latest_critique']}"
)
)
]
)
return {
"latest_verdict": verdict.model_dump(),
}
Warum ein Watchdog weiterhin notwendig ist
Für die Frage, warum ein Watchdog-System notwendig ist, sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den jeweiligen Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher sowie Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können, ohne den gesamten Ablaufverlauf durchlesen zu müssen. Menschliche Freigabe sollte für Schritte erforderlich sein, die Geld ausgeben oder Produktionsdaten ändern. Eine Verkabelung zur Kompilierzeit bedeutet nicht automatisch vollständige Geschäftsabdeckung.
round 1: 12
round 2: 8
round 3: 8
round 4: 9
def watchdog(state: AdversarialState) -> dict:
round_number = state.get("round", 0)
scores = state.get("issue_counts", [])
if round_number >= HARD_ROUND_CAP:
return {
"halt_reason": "hard round cap reached",
}
if len(scores) >= STALEMATE_WINDOW:
window = scores[-STALEMATE_WINDOW:]
if window[-1] >= window[0]:
return {
"halt_reason": (
f"stalemate detected: {window}"
),
}
return {}
Die Abschlussprüfung muss Erfolg von Misserfolg unterscheiden
Zur Abschlussphase muss die Erfolgsstufe unterschieden werden, die Eingaben definiert, der Verantwortliche für den Schritt sowie die Abbruchkriterien festgelegt werden, bevor Code geändert wird. Die Bediener sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen. Setzen Sie menschliche Freigabe für Schritte voraus, die Geld kosten oder Produktionsdaten ändern. Kompilierzeitbezogene Verbindungen entsprechen nicht der vollständigen Geschäftsabwicklung. Zur Abschlussphase muss die Erfolgsstufe unterschieden werden, die Eingaben definiert, der Verantwortliche für den Schritt sowie die Abbruchkriterien festgelegt werden, bevor Code geändert wird. Die Bediener sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Vorgänge ab.
Wann sollten Sie eine adversarische Architektur verwenden?
Beim Bearbeiten der Frage „Wann sollten Sie eine adversarische Architektur verwenden?“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie was bei teilweiser Fehlermeldung geschieht. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo in gemeinsame Umgebungen wechselt. Erstellen Sie Zwischenprüfungen nach teuren Schritten. Das Wiederaufnehmen des Vorgangs sollte keine erneute Abrechnung für denselben LLM-Aufruf verursachen, wenn ein Operator einen späteren Knoten erneut ausführt.
Architektur wählen
Während der Phase „Architektur auswählen“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreuer ohne das Durchlesen des gesamten Systems prüfen können. Erstellen Sie nach aufwändigen Schritten einen Checkpoint. Das Wiederaufnehmen des Vorgangs sollte keine doppelte Abrechnung für denselben LLM-Aufruf verursachen, wenn ein Betreuer einen späteren Knoten erneut ausführt.
Fazit
Während der Phase „Abschließende Überlegungen“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikator sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Wiederherstellungsprozess gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Legen Sie nach aufwändigen Schritten Zwischenkontrollpunkte an – das System sollte bei erneuten Versuchen eines Operators keine doppelten Abrechnungen für denselben LLM-Aufruf tätigen. Während der Phase „Abschließende Überlegungen“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikator sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgsprüfungen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab.
Operative Checkliste
Die Phase der Betriebskontrollliste funktioniert am besten, wenn sie als messbarer Rahmen betrachtet wird. Erfassen Sie eine „goldene“ Transkription, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern.
Wählen Sie kleine, testbare Einheiten statt umfangreicher Skripte. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufverfahren.
Halten Sie den Zustand des Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen dazu, dass der Ablauf nach Unterbrechungen nicht fortgesetzt werden kann.
Fügen Sie immer dann, wenn das Budget es zulässt, einen Smoke-Test hinzu, der den kritischen Pfad in CI mit Fixtures und nicht mit live genutzten, bezahlten APIs testet.
Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Ergebnisse ab.
Halten Sie den Zustand des Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen dazu, dass der Ablauf nach Unterbrechungen nicht fortgesetzt werden kann.
Vor der Einführung des Stacks sollten Versionen eingefroren werden, ein „goldener“ Transkript für den kritischen Pfad erstellt und die Rollback-Schritte bestätigt werden. Gemeinsam genutzte Umgebungen benötigen Rate Limits, Überprüfungen der Nutzerrechte sowie einen klaren Verantwortlichen für die Rotation von Geheimnissen. Man sollte langweilige Zuverlässigkeit vor cleveren, einmaligen Demonstrationen bevorzugen.
Batch-Hinweis für f6f8c689c406: Halten Sie die Anbieter-Schlüssel außerhalb des Repositories, legen Sie eine Obergrenze für Tokens pro Sitzung fest und speichern Sie die Transkripte neben den Evaluierungs-Dateien, damit spätere Modellwechsel vergleichbar bleiben.