Wer sollte den Agenten-Loop besitzen: Laufzeit-Harnesses gegen komponierte Frameworks

Von weitem wirken die Werkzeuge zur Erstellung von KI-Agenten austauschbar. Jedes davon stellt Ihnen ein Modell, eine Möglichkeit zur Aufrufung von Werkzeugen sowie Mechanismen zur Aufrechterhaltung der Modellfunktion bis zur Erledigung einer Aufgabe bereit – mit jedem dieser Werkzeuge können Sie bereits am Nachmittag einen funktionsfähigen Agenten betreiben. Die Unterschiede zwischen ihnen bleiben verborgen, solange man sich noch im Demo-Modus befindet und erst in der Produktionsumgebung werden sie grundlegend: Wer besitzt den循环, der den Agenten antreibt? Eine Werkzeugfamilie liefert Ihnen einen Laufzeitumfeld und tritt anschließend in den Hintergrund; die andere bietet Abstraktionen an und verlangt von Ihnen, diese selbst zusammenzusetzen. Dieser Artikel zieht genau die Grenze zwischen diesen beiden Philosophien und gibt Ihnen anschließend eine Methode an die Hand, um zu entscheiden, auf welche Seite ein bestimmtes Projekt gehört. Das Ziel ist es nicht, einen Gewinner zu küren, sondern die jeweiligen Kompromisse klar hervorzuheben.

Auf der einen Seite befinden sich Frameworks: Laufzeiten, die den gesamten Send-Vorgang, die Tool-Nutzung, das Ergebnis-Handling sowie den Wiederholungszyklus steuern. Sie müssen diesen Zyklus nicht selbst schreiben; Sie konfigurieren und erweitern ihn lediglich. Auf der anderen Seite gibt es Frameworks wie LangGraph, CrewAI und LangChain, die Ihnen explizite Bausteine, Graphen sowie Strukturen bieten und von Ihnen erwarten, dass Sie den Kontrollfluss selbst zusammenfügen. Obwohl dies oft als Kontrast zwischen Node und Python dargestellt wird, ist die Programmiersprache dabei nur ein Nebeneffekt. Die eigentliche Variable ist, wie viel von der Infrastruktur Sie selbst kontrollieren möchten.

Zwei Definitionen, die unter Druck standhalten

Bestimmen Sie zuerst die beiden Schlüsselbegriffe, bevor Sie sich auf sie stützen. Ein Harness ist eine Laufzeitumgebung, die die Kontrolle über den Agentenzyklus übernimmt. Sie führt diesen Zyklus für Sie aus: Sie sendet die Anfrage, sammelt die vom Modell gewünschten Toolaufrufe ein, führt diese aus, gibt die Ergebnisse zurück und wiederholt diesen Vorgang, bis das Modell keine weiteren Anfragen mehr stellt. Zudem übernimmt sie in der Regel auch die damit verbundenen schwierigen Aufgaben, wie den Umgang mit Kontext und Speicher, die Komprimierung der Historie, wenn das Tokenbudget erschöpft ist, Wiederholungsversuche sowie die Aufrechterhaltung der Sitzung. Sie steuern sie über Konfigurationen – also Systemanweisungen, Modellwahl, erlaubte Tools sowie Grenzwerte – sowie über Hooks und Erweiterungspunkte, niemals indem Sie den Zyklus manuell programmieren. Ein Harness in diesem Bereich, Pi – eine Laufzeitumgebung für Node und TypeScript – fasst diese Philosophie als „Primitiven statt Funktionen“ zusammen: Sie passen die Laufzeitumgebung an Ihren Arbeitsablauf an, anstatt Ihren Arbeitsablauf umzustellen, damit er zu ihr passt.

Ein Framework oder SDK ist vielmehr eine Sammlung expliziter Abstraktionen, die man im Code zusammenstellt. LangGraph bietet ein Graph aus Knoten, die durch Kanten miteinander verbunden sind. CrewAI bietet Gruppen von Rollenspiel-Agenten. LangChain bietet Ketten. In jedem dieser Ansätze sind Sie der Schöpfer des Steuerflusses, und die Bibliothek liefert lediglich die Komponenten und ermöglicht es Ihnen, sie miteinander zu verbinden. Der wirklich wichtige Unterschied besteht darin: In einem Harness ist der Schleifenmechanismus versteckt und gehört zum Laufzeitumfeld, während im Framework der Schleifenmechanismus, die Struktur des Graphen oder die Anordnung der Agentengruppen offen sichtbar sind und Ihnen gehören.

Es handelt sich dabei um ein Spektrum statt um einen Schalter. Am einen Ende steuern Sie eine Laufzeitumgebung durch Konfigurationen und Hooks, wobei diese das Schleifenverhalten kontrolliert; am anderen Ende erstellen Sie jeden Knoten, jede Kante, jede Agentengruppe oder jede Kette selbst, und der Schleifenmechanismus ist buchstäblich Ihr eigener Code.

HARNESS    you → [config + hooks] → ╔═══ runtime owns the loop ═══╗ → result
                                    ║ prompt → tools → results → ↺║
FRAMEWORK  you author every node / edge / crew / chain → the loop IS your code

Behalten Sie diese Achse im Hinterkopf, denn alles Weitere hängt davon ab, wo sich ein Tool darauf befindet.

Der Harness-Ansatz: Übergeben Sie den Loop an die Laufzeitumgebung

Pi ist ein minimaler, node-eigener Harness, der als schichtweise Struktur organisiert ist, und Sie nutzen nur die Schicht, die Sie benötigen. Ganz unten befindet sich eine Abstraktion für Anbieter, die viele Modellanbieter umfasst; in der Mitte liegt der Agent-Loop sowie die Tool-Verteilung; darüber befindet sich eine vollständige Laufzeitumgebung mit Sitzungspersistenz; an der Oberfläche liegt eine Terminal-Oberfläche. Für die meisten Ingenieure ist die mittlere Schicht, der Loop, die interessante. Das Starten eines Agents bedeutet, zu beschreiben, wie er aussehen soll, und anschließend die Kontrolle abzugeben. Ein kleiner Forschungsagent, der auf der Session-API basiert, sieht so aus.

import { getModel } from "@mariozechner/pi-ai";
import { createAgentSession, SessionManager } from "@mariozechner/pi-coding-agent";

const { session } = await createAgentSession({
  model: getModel("anthropic", "claude-sonnet-4-6"),
  cwd: process.cwd(),
  sessionManager: SessionManager.open("./session.jsonl"),
  tools: ["read", "grep", "bash", "search_docs"], // built-ins + your custom tools, by name
  customTools: [searchDocsTool],                   // your typed tools
});

// You steer the runtime with config, not loop code:
session.agent.state.systemPrompt = "You are a research assistant. Always cite sources.";

// A single call runs the entire prompt → tools → results → repeat cycle:
await session.prompt("Summarize the latest on agent frameworks and cite sources.");

Achten Sie darauf, was fehlt. Es gibt keinen while-Schleifen, keine Abzweigung mit der Anweisung „Wenn das Modell Toolaufrufe zurückgibt, führe sie aus und rufe das Modell erneut auf“, und auch keine Token-Verwaltung, um zu entscheiden, wann die Historie komprimiert werden sollte. Der Laufzeitumgebung übernimmt all das. Alles, was Sie bereitgestellt haben, war ein Modell, die Tools, die es verwenden kann, sowie eine Systemanweisung, gefolgt von einem einzigen Aufruf der Prompt-Methode. Ein benutzerdefiniertes Tool ist ebenfalls ein kleines, typisiertes Objekt: ein Name, eine für das Modell bestimmte Beschreibung, ein Schema für seine Parameter sowie eine Ausführungsfunktion.

const searchDocsTool = {
  name: "search_docs",
  description: "Search the internal docs and return matching passages.",
  parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
  async execute(_id: string, params: { query: string }, signal?: AbortSignal) {
    const passages = await search(params.query, signal);
    return { content: [{ type: "text", text: passages }], details: {} };
  },
};

Bis jetzt wirkt das wie eine praktische Lösung, nichts weiter. Die Komplexität zeigt sich erst dann, wenn man die Funktionsweise der Schleife ändern muss – schließlich kann man keine Schleife umschreiben, die nicht einem selbst gehört. Stattdessen greift man über Ereignisse und Hooks darauf zu. Das Abonnieren von Ereignissen ermöglicht es, den Ablauf zu beobachten und einzugreifen, zum Beispiel indem man die Anzahl der Durchläufe zählt und bei Erreichen einer Obergrenze eingreift.

let turns = 0;
const MAX_TURNS = 20;

const unsubscribe = session.agent.subscribe((event) => {
  if (event.type === "turn_end" && ++turns >= MAX_TURNS) {
    session.agent.abort(); // pull the cord on a loop you didn't write
  }
});

Dieselbe Struktur wird auch für eine Kostenobergrenze verwendet: Die Kosten pro Nachricht werden gesammelt, sobald sie eintrifft, und das Verfahren wird abgebrochen, sobald eine Schwellenwert überschritten wird. Der Laufzeitmechanismus setzt die Schleife weiter in Gang, während man beobachtet und entscheidet, wann sie gestoppt werden soll. Hooks gehen einen Schritt weiter und ermöglichen es, eine Entscheidung noch vor ihrer Umsetzung abzufangen – unsichtbar für das Modell. Ein Hook vor einem Toolaufruf kann einen ausstehenden Aufruf überprüfen und ihn ablehnen.

session.agent.beforeToolCall = async (ctx) => {
  if (ctx.toolCall.name === "bash" && isDangerous(ctx.args.command)) {
    return { block: true, reason: "blocked by policy" };
  }
  return undefined; // allow
};

Das Modell „bat“ darum, einen Shell-Befehl auszuführen; der Hook lehnte stillschweigend ab und gab einen Grund an, wobei die Schleife so weiterlief, als wäre nichts geschehen. Sie haben das Verhalten des Agents um eine Schleife herum gestaltet, die Sie nicht selbst erstellt haben. Das ist der Kompromiss, den ein Harness bietet: Sie geben die Möglichkeit auf, den Kontrollfluss neu zu schreiben, und im Gegenzug erhalten Sie schnell einen funktionsfähigen Agenten, starke Standardwerte für die wirklich schwierigen Bereiche wie Kontextverwaltung, Komprimierung und Persistenz sowie eine übersichtliche Struktur aus Schnittstellen, Konfigurationen, Ereignissen und Hooks zur Anpassung des Verhaltens. Es handelt sich dabei um einen hervorragenden Deal – insbesondere dann, wenn die Ansichten der Laufzeit mit Ihren übereinstimmen.

Der Framework-Ansatz: Den Kontrollfluss selbst zusammenstellen

Das Python-Ökosystem setzt auf das Gegenteil. Anstelle einer Laufzeit, die die Schleife kontrolliert, stellt es Abstraktionen bereit, die Sie selbst zusammenstellen können, wobei drei davon eine dominante Rolle spielen.

LangChain: Erstellung einer Kette

LangChain ist das älteste und umfassendste der drei. Es entstand ursprünglich als Methode, mehrere LLM-Aufrufe miteinander zu verknüpfen, und entwickelte sich zu einer umfangreichen Plattform: mit mehr als tausend Integrationen, einer Schnittstelle, die nicht darauf achtet, welches Modell dahintersteckt, sowie einem begleitenden Produkt für die Überwachung. Für Agenten bietet es einen ReAct-ähnlichen Tool-Aufruf-Zyklus, und sein Kompositionsansatz verknüpft ein Element nach dem anderen miteinander. Seine große Stärke liegt in der Reichweite: Wenn es ein Modell, einen Vektorlagers oder ein externes Tool gibt, existiert vermutlich auch eine LangChain-Integration dafür. Seine Schwäche ist der Preis für diese Allgemeingültigkeit. Tiefe Abstraktionsebenen können das Debuggen zu einer schwierigen Aufgabe machen, und da LangChain standardmäßig zustandslos ist, muss die Zuverlässigkeit extra eingebaut werden, anstatt automatisch gegeben zu sein. LangChain eignet sich für standardmäßige, größtenteils lineare Workflows mit einem einzelnen Agenten, bei denen die Vielfalt der Integrationen am wichtigsten ist.

LangGraph: Modellierung einer Zustandsmaschine

LangGraph geht eine klare, entschiedene These ein: Agentensysteme sind Zustandsmaschinen, und man sollte jede Übergangshandlung steuern. Der Agent wird als Graph modelliert, dessen Knoten die Schritte und dessen Kanten die Übergänge darstellen – alles arbeitet mit einem typisierten Zustandsobjekt.

from langgraph.graph import StateGraph, MessagesState, START, END

def call_model(state: MessagesState):
    return {"messages": [llm.invoke(state["messages"])]}
graph = StateGraph(MessagesState)
graph.add_node(call_model)
graph.add_edge(START, "call_model")
graph.add_edge("call_model", END)
app = graph.compile()
app.invoke({"messages": [{"role": "user", "content": "hi"}]})

Wo ein Framework den Schleifenverlauf verbirgt, verwandelt LangGraph ihn in das von Ihnen erstellte Artefakt. Bedingte Branching-Strukturen werden explizit dargestellt.

graph.add_conditional_edges("call_model", should_continue, {"tools": "tools", "end": END})

Diese continue-or-stop-Funktion ist genau die Abzweigung, die ein Harness hinter einem einzigen Prompt-Aufruf für Sie ausführt. Hier haben Sie sie: sichtbar, testbar und versionierbar. Die Belohnung für diese zusätzliche Ausführlichkeit ist LangGraphs herausragendes Merkmal – die native Checkpoint-Funktion bei jeder Übergangssituation. Da der Zustand im Laufe der Ausführung des Graphen auf die Festplatte geschrieben wird, ist die Ausführung auch nach Neustarts oder nach einem Absturz weiterhin verfügbar, es besteht die Möglichkeit, frühere Zustände zurückzuspulen und zu überprüfen, sowie Pausen einlegen, während auf eine menschliche Eingabe gewartet wird. Die Nachteile sind eine steile Lernkurve sowie ein Design, das absichtlich nicht für serverlose Deployment-Szenarien geeignet ist. LangGraph eignet sich für langlaufende, zyklische, absturzresistente und Zustandsbasierte Workflows.

CrewAI: Ein Team zusammenstellen

CrewAI ist der Ansicht, dass sich die meisten Probleme mit mehreren Agenten ordentlich in Teams von Spezialisten aufteilen lassen. Jeder Agent wird durch eine Rolle, ein Ziel und eine Hintergrundgeschichte definiert, und anschließend werden sie zu einer Crew zusammengefasst, der Aufgaben übertragen werden.

from crewai import Agent, Task, Crew

researcher = Agent(role="Researcher", goal="Find key insights on {topic}",
                   backstory="A meticulous analyst.")
writer = Agent(role="Writer", goal="Summarize the research clearly",
               backstory="A concise technical writer.")

research = Task(description="Research {topic}.", expected_output="3 insights.", agent=researcher)
summary = Task(description="Write a summary.", expected_output="A short summary.", agent=writer)

Crew(agents=[researcher, writer], tasks=[research, summary]).kickoff(inputs={"topic": "agent frameworks"})

Das mentale Modell ist intuitiv und der Weg zu einem funktionsfähigen Multi-Agenten-Pipeline ist kurz, weshalb es bei Unternehmen stark verbreitet ist. Die Kehrseite ist, dass die Abstraktion von Rollen und Zielen zunächst praktisch erscheint – bis etwas schiefgeht, dann wird sie zu einer Black Box; die Delegation zwischen Agenten kann in Schleifen geraten; und man muss eigene Maßnahmen gegen unkontrollierte Kosten einbauen. CrewAI eignet sich für rollenbasierte Multi-Agentensysteme und schnelles Prototyping. Der gemeinsame Nenner aller drei Aspekte ist, dass man den Ablauf selbst gestaltet. Das sind sowohl die Kosten – mehr Code, mehr Entscheidungen, mehr Wartungsaufwand – als auch der Vorteil, da man jeden Übergang sehen, testen und anpassen kann. Pythons Bedeutung im Bereich Daten- und Maschinelles Lernen ist hier ein echter Vorteil, denn die Agenten arbeiten direkt neben den Bibliotheken und Notebooks, mit denen man bereits arbeitet.

Die Aspekte, in denen die Entscheidung tatsächlich getroffen wird

Wenn diese Ansätze nebeneinander aufgereiht werden, unterscheiden sie sich in nur wenigen Aspekten voneinander, wobei einige von ihnen in der Praxis den größten Einfluss ausüben.

Das Eigentum am Laufzyklus ist der übergeordnete Aspekt; alles Weitere leitet sich davon ab. Ein Framework behält den Zyklus für sich, während ein Harness ihn Ihnen überlässt – LangGraph repräsentiert den Ansatz, bei dem man alles selbst schreibt, Pi den Ansatz, bei dem der Laufzeitumgebung alles vorgegeben wird, und die übrigen Ansätze liegen dazwischen.

Die Langlebigkeit ist LangGraphs entscheidender Vorteil. Durch das Speichern eines Checkpoints bei jeder Übergangssituation erhalten Sie eine Krash-Wiederherstellung sowie die Möglichkeit zum Wiederspielen ohne nennenswerte zusätzliche Anstrengung. Die Sitzungspersistenz, die ein Harness bietet, sowie die Speichertypen, die CrewAI bereitstellt, sind nützlich, doch keines davon entspricht einem Zustand, den man dauerhaft wiederspielen kann. Wenn ein Prozess mitten in einer Ausführung beendet wird, nimmt ein geparkter Graph den letzten Übergang wieder auf, während ein Sitzungsalbum in der Regel nur ermöglicht, im Nachhinein herauszufinden, was geschehen ist.

Die Orchestrierung mehrerer Agenten ist bei CrewAI über Rollen und bei LangGraph über Subgraphen integriert. Ein Harness erreicht dieses Ziel auf andere Weise – sei es durch Unteragenten, Erweiterungen oder von Ihnen bereitgestellte Koordinationslogik.

Das umgebende Sprachökosystem entscheidet in der Regel stillschweigend. Die Wahl von Python bringt den Agenten in den Bereich von Datenverarbeitung und Machine Learning – er arbeitet dort zusammen mit Ihren Dataframes, Trainingscode-Dateien und Notebooks. Die Wahl von TypeScript lenkt ihn hingegen in Richtung Web und Edge-Technologien – er wird dort eingesetzt zusammen mit Ihren API-Schnittstellen, gemeinsamen Frontend-Typen sowie an allen Stellen, an denen serverlose Funktionen bereitgestellt werden. Diese „Anziehungskraft“ überwiegt oft alle einzelnen Eigenschaften auf einer Vergleichstabelle, und es lohnt sich, ehrlich zu sein darüber, in welcher Welt Ihr Team bereits tätig ist.

Eine letzte Einschränkung sorgt für eine ehrliche Vergleichbarkeit: Das Muster „Node mit Harness“ bzw. „Python mit Framework“ ist eher eine Tendenz als eine Regel. Es gibt Harness-basierte Laufzeiten, die in Python geschrieben sind, sowie graphbasierte Orchestrierungsbibliotheken, die in TypeScript entwickelt wurden. Entscheiden Sie sich auf der Grundlage des Paradigmas sowie Ihrer tatsächlichen Einschränkungen – niemals allein aufgrund der Sprache, die auf dem Paket angegeben ist.

Eine Aufgabe aus jeder Perspektive

Stellen Sie sich eine einfache, alltägliche Aufgabe vor: Ein Agent, der etwas mithilfe eines Tools abruft und anschließend eine Zusammenfassung davon erstellt. Was jedes Paradigma von Anfang an zur Sprache bringt, ist der entscheidende Aspekt. Bei diesem Ansatz besteht die Arbeit fast ausschließlich aus Konfigurationen. Nachdem Sie ein Suchtool sowie eine Systemanweisung definiert haben, senden Sie einen Aufruf – der Laufzeitmechanismus übernimmt anschließend die Kontrolle, ruft das Modell auf, stellt fest, dass eine Suche erforderlich ist, führt diese aus, gibt die Ergebnisse zurück, ermöglicht es dem Modell, die Zusammenfassung zu erstellen, und beendet den Vorgang selbstständig. Der Rahmen fragt Sie im Grunde nur eine einzige Sache: Welche Fähigkeiten sollte dieser Agent haben?

In einem Framework wie LangGraph besteht die Arbeit fast ausschließlich aus der Strukturierung. Man definiert das Zustandsobjekt, einen Knoten, der das Modell aufruft, einen Knoten, der das Tool ausführt, sowie eine bedingte Kante, die entscheidet, ob man zum Modell zurückkehrt oder beendet. Solange dieser Graph nicht vollständig erstellt ist, wird überhaupt nichts ausgeführt. LangGraph stellte eine andere Frage: Was genau ist der Kontrollfluss?

Die Erkenntnis, mit der man umgehen muss, ist, dass keine der Versionen schwierig ist; die Aufgabe fällt in beiden Fällen leicht. Was sie voneinander unterscheidet, ist nicht die Anstrengung, sondern was man im Voraus entscheiden muss und was später noch überprüft oder wiederhergestellt werden kann. Ein Harness lässt die erste Frage verschwinden und liefert Ihnen schnell einen ordentlichen Agenten. Ein Framework weigert sich, sie verschwinden zu lassen, und kompensiert dies mit einem Ablauf, den Sie Schritt für Schritt nachverfolgen können, wenn das System zu unpassender Zeit Fehler macht. Dieser Kompromiss wird umso bedeutender, je größer das System wird. Wenn Sie einen Programmierassistenten oder einen Agenten innerhalb einer Anwendung entwickeln, ist die Frage nach den Fähigkeiten entscheidend und der Harness eine Erleichterung. Wenn Sie einen Workflow entwickeln, der lange laufen muss, Krach überstehen und Audits standhalten soll, ist die Frage nach dem Kontrollfluss entscheidend – jede zusätzliche Zeile des expliziten Graphen lohnt sich dabei.

Die passende Werkzeugwahl für Ihr eigenes Schlauchsystem

Die Heuristiken ergeben sich direkt aus all dem oben Genannten. Wählen Sie ein Harness, wenn die Geschwindigkeit eines arbeitenden Agents Priorität hat, wenn die integrierten Optionen der Laufzeitumgebung bereits ausreichen, wenn das Ziel ein Code- oder Entwicklerwerkzeug-Agent ist, oder wenn Sie einen Agent in eine TypeScript-Anwendung einbetten und Typsicherheit sowie Nähe zum Frontend wünschen. Wählen Sie LangGraph, wenn ein Verlust von Fortschritten inakzeptabel ist – das gilt für langanhaltende oder zyklische Workflows, die Krashs überdauern müssen, eine genaue Kontrolle über den Zustand und jede Übergangssituation benötigen oder pausiert werden müssen, bis eine Person eingreift. Wählen Sie CrewAI, wenn das Problem tatsächlich in eine Reihe von Spezialistenrollen zerfallen kann und Sie schnell einen mehragentigen Pipeline aufbauen möchten. Wählen Sie LangChain, wenn die Vielfalt an verfügbaren Integrationen für einen herkömmlichen Einzel-Agent-Flow mit Toolaufrufen alle anderen Aspekte überwiegt, insbesondere innerhalb einer etablierten Python-Codebasis. Und nochmals

Mit Gefühl sind die Grenzen fließend: Man entscheidet sich für ein Paradigma und Einschränkungen, nicht dafür, welche Sprache auf der Dose gedruckt ist.

Die Schleife war von Anfang an die Frage

Die Debatte drehte sich nie wirklich um Node gegen Python oder um ein Paket gegen seinen Konkurrenten. Es ging vielmehr darum, ob der Laufzeitumgebung die Steuerungsschleife gehören sollte oder man selbst. Ein Harness opfert die Freiheit, den Ablauf neu zu schreiben, um schnell einen funktionsfähigen Agenten zu erstellen und das Verhalten durch Konfiguration, Ereignisse und Hooks zu verändern – und zwar in einer Schleife, die man selbst nicht entwickelt hat. Ein Framework tauscht Geschwindigkeit gegen explizite Befehle, Langlebigkeit und Orchestrierung ein und verlangt zudem die kontinuierlichen Kosten für das Schreiben und Warten des Ablaufs. Für die meisten Teams ist eine sinnvolle Ausgangslage ein Harness für Prototypen, das Programmieren von Agenten sowie alles, was in einem Produkt integriert ist – dort zählt die Geschwindigkeit als Vorteil. Man wechselt zu LangGraph, sobald eine langlebige Zustandsverwaltung zu einer festen Anforderung wird, und wendet sich CrewAI zu, wenn die Arbeit tatsächlich von einem Team von Spezialisten erledigt werden muss. Da diese Tools ständig die besten Ideen voneinander übernehmen, ist die anhaltende Fähigkeit nicht die Beherrschung eines einzigen Tools.

API – doch die Entscheidung liegt darin, den Agenten vor sich anzusehen und zu wissen, wer dessen Schleife besitzen sollte.

Verwandte Artikel