Zum Hauptinhalt springen

Lokale Coding-Agenten (und wie sie mit Claude zusammenspielen)

Fortgeschritten

Ein lokaler Coding-Agent ist ein Programm, das auf deinem eigenen Rechner läuft, dein Repository liest und deine Dateien für dich bearbeitet. Du beschreibst eine Änderung in natürlicher Sprache; der Agent plant sie, schreibt Code über mehrere Dateien hinweg, führt deine Tests aus, liest die Fehlschläge und versucht es erneut — eine Schleife, keine einzelne Antwort. Der Chat-Assistent in einem Browser-Tab reicht dir ein Snippet zum Einfügen; ein Coding-Agent übernimmt das Einfügen, Ausführen und Korrigieren selbst, direkt in deinem Repo.

Die zentrale Erkenntnis, die diese Seite lesenswert macht: Fast alle dieser Tools sind modellagnostisch. Der Agent (die Schleife, die deine Dateien anfasst) ist getrennt vom Modell (das Gehirn, das entscheidet, was geschrieben wird). Dasselbe Tool kann also auf Claude für die beste Codequalität gerichtet werden — oder auf ein lokales Open-Weight-Modell über Ollama, damit dein Code deinen Laptop nie verlässt. Du wählst den Agenten danach, wie er zu deinem Workflow passt, und das Modell nach dem Kompromiss zwischen Qualität und Datenschutz — unabhängig voneinander.

What you'll learn
  • Den Coding-Agent-Archetyp verstehen: eine Agentenschleife, die dein Repo liest, plant, Dateien bearbeitet, Tests ausführt und iteriert
  • Die echten offenen Tools kennen — Aider, Cline, Continue, OpenHands — und wie sich Anthropics eigenes Claude Code einfügt
  • Begreifen, warum 'modellagnostisch' wichtig ist: einen Agenten auf Claude für Qualität ODER auf ein lokales Modell für Datenschutz richten
  • Den Datenschutzaspekt verstehen — ein lokales Modell bedeutet, dass dein Code deinen Rechner nie verlässt
  • Entlang zweier Achsen wählen: IDE-integriert vs. CLI vs. autonom, und Claude-betrieben vs. vollständig lokal

Der Archetyp: eine Agentenschleife, kein Chatfenster​

Jedes Tool auf dieser Seite ist eine Variation derselben Schleife. Sobald du die Schleife siehst, ist jedes Tool nur eine andere Form drumherum:

  1. Lesen — der Agent sammelt Kontext: die Dateien, auf die du ihn richtest, die Repo-Struktur, manchmal Testausgaben oder Fehlerprotokolle.
  2. Planen — er entscheidet, was in welchen Dateien geändert werden soll, und schlägt oft einen Plan vor, bevor er etwas anfasst.
  3. Bearbeiten — er schreibt Änderungen in echte Dateien auf der Festplatte (meist als Diff angezeigt, das du genehmigst).
  4. Ausführen — er führt Befehle aus: deine Testsuite, einen Build, einen Linter, ein Skript.
  5. Beobachten und iterieren — er liest, was passiert ist (Tests bestanden? ein Stacktrace?), und springt zurück zu Schritt 2, bis die Aufgabe erledigt ist oder er die Kontrolle wieder an dich übergibt.

Das ist dieselbe Form wie agentische Tool-Nutzung: Das Modell erhält Werkzeuge (Datei lesen, Datei bearbeiten, Befehl ausführen) und entscheidet, wann es sie aufruft. Der Unterschied zwischen den Tools liegt vor allem darin, wie viel Autonomie die Schleife hat und wo sie lebt — in deinem Terminal, deinem Editor oder einer abgeschotteten Umgebung, die für sich allein läuft.

Das Modell in der Mitte dieser Schleife ist austauschbar. Das ist der ganze Grund, warum ein einziger Agent zwei sehr unterschiedliche Nutzer bedienen kann: jemanden, der den bestmöglichen Code will (richte ihn auf Claude), und jemanden, der aus rechtlichen Gründen keinen Code aus seinem Netzwerk lassen darf (richte ihn auf ein lokales Modell).

Warum Modellagnostik das wichtigste Merkmal ist​

Der Agent und das Modell sind getrennte Teile. Der Agent besitzt die Schleife — Dateien lesen, Diffs anwenden, Tests ausführen. Das Modell besitzt das Urteilsvermögen — was geschrieben wird, warum und wann gestoppt wird. Sie zu entkoppeln gibt dir zwei unabhängige Regler:

  • Qualitätsregler → Claude. Für anspruchsvolles Reasoning, Refactorings über mehrere Dateien und Arbeit mit langem Kontext liefert ein Frontier-Modell wie Claude deutlich bessere Bearbeitungen und erholt sich zuverlässiger von Fehlschlägen. Die meisten dieser Tools dokumentieren Claude als empfohlene oder voreingestellte Wahl. (Welche Claude-Stufe du wählst, ist eine eigene Entscheidung — siehe Ein Modell wählen.)
  • Datenschutzregler → ein lokales Modell. Richte denselben Agenten auf ein Open-Weight-Modell, das unter Ollama läuft, und dein Code, deine Prompts und deine Diffs verlassen deinen Rechner nie — kein API-Aufruf, kein Dritter, nichts auf der Leitung. Das ist der entscheidende Faktor für regulierte, vom Netz getrennte oder vertrauliche Codebasen. Der ehrliche Kompromiss: Ein Modell, das klein genug ist, um auf einem Laptop zu laufen, spielt bei den schwersten Aufgaben nicht in derselben Liga wie ein Frontier-Modell. Du tauschst etwas Leistungsfähigkeit gegen vollständige Datenkontrolle.
What you'll learn
  • Modellagnostisch heißt nicht, dass jedes Modell gleich gut ist. Die Schleife läuft gleich, aber ein schwaches Modell macht schlechtere Bearbeitungen, missdeutet Testfehlschläge und dreht unproduktive Schleifen. Datenschutz und Leistungsfähigkeit stehen wirklich in einem Zielkonflikt — wähle pro Aufgabe, nicht ein für alle Mal.

Die echten Tools (verifiziert)​

Fünf Tools, die man kennen sollte. Die ersten vier sind Open Source und modellagnostisch; das fünfte ist Anthropics eigener Agent, aufgenommen, damit du siehst, wo eine Claude-native Erfahrung einzuordnen ist.

Aider — der CLI-Pair-Programmer​

Aider läuft in deinem Terminal und ist rund um Git aufgebaut: Es bearbeitet Dateien in deinem Repo und committet jede Änderung automatisch mit einer sinnvollen Nachricht, sodass jede KI-Bearbeitung ein Diff ist, das du überprüfen, rückgängig machen oder zurücksetzen kannst. Es ist modellagnostisch — am besten funktioniert es mit Frontier-Modellen wie Claude, und es verbindet sich auch mit lokalen Modellen über Ollama (aider --model ollama_chat/<model>). Wenn du im Terminal lebst und straffe Git-Hygiene willst, ist Aider die kanonische CLI-Wahl.

Cline — der Agent in deiner IDE​

Cline ist ein Open-Source-Coding-Agent, der in deinem Editor lebt (VS Code und JetBrains) und außerdem eine Terminal-/CLI-Oberfläche mitbringt. Er erstellt Dateien, führt Befehle aus und nutzt Werkzeuge mit Human-in-the-Loop-Freigabe — du siehst und genehmigst jeden Schritt. Er ist modellagnostisch und unterstützt ausdrücklich Claude sowie lokale Modelle über Ollama oder LM Studio. Greif zu Cline, wenn du einen quasi-autonomen Agenten willst, ohne deinen Editor zu verlassen.

Roo Code ist ein bekannter Fork von Cline, der eigene "Modi" hinzugefügt hat (z. B. einen Architect-Modus zum Planen, einen Coder-Modus für Bearbeitungen). Er war ebenfalls modellagnostisch. Beachte seinen Status weiter unten — er ist nicht mehr die sichere Voreinstellung, die er einmal war.

Continue — der offene IDE-Assistent​

Continue ist ein Open-Source-Assistent für VS Code und JetBrains (plus eine CLI), der Chat, Bearbeitung, Autovervollständigung und einen Agentenmodus abdeckt. Er ist durch und durch modellagnostisch: Seine Doku listet Anthropic (Claude), Ollama für lokale Modelle und viele weitere Anbieter, wobei sich verschiedene Modelle verschiedenen Rollen zuweisen lassen (Chat, Bearbeitung, Autovervollständigung). Er ist eine starke Wahl, wenn du einen konfigurierbaren Assistenten willst, bei dem du genau verdrahtest, welches Modell was macht.

OpenHands — der autonome Agent​

OpenHands (ehemals OpenDevin) ist der autonomste der vier: eine Plattform für KI-Softwareentwicklungs-Agenten, die in einer abgeschotteten Umgebung arbeiten, eine Aufgabe zerlegen (z. B. ein GitHub-Issue) und sie mit weniger schrittweiser Freigabe von Anfang bis Ende durchführen. Er ist modellagnostisch — "use with any LLM", Claude inbegriffen — und kann selbst gehostet werden. Wähle OpenHands, wenn du eine ganze Aufgabe übergeben und später nachsehen willst, statt jede Bearbeitung zu genehmigen.

Claude Code — Anthropics eigener Agent​

Claude Code ist Anthropics offizielles agentisches Coding-Tool: Es liest deine Codebasis, bearbeitet Dateien, führt Befehle und Tests aus und arbeitet über dein Terminal, deine IDE, die Desktop-App und das Web hinweg. Anders als die vier oben ist es nicht "richte es auf irgendein Modell" — es ist rund um Claude gebaut und darauf abgestimmt, was genau der Grund ist, warum sich die Schleife straffer anfühlt und die Bearbeitungen bei schweren Aufgaben öfter sitzen. Wenn deine Priorität die beste Claude-betriebene Coding-Erfahrung statt maximaler Modell-Austauschbarkeit ist, ist dies der native Weg. Alle Details unter Was ist Claude Code.

Wie man wählt​

Zwei Achsen entscheiden fast alles:

Achse 1 — wo der Agent lebt:

  • CLI / Terminal (Aider, Claude Code) — skriptbar, Git-freundlich, in andere Tools pipebar. Am besten, wenn du in der Shell lebst.
  • IDE-integriert (Cline, Continue, die Editor-Oberfläche von Claude Code) — Diffs und Freigaben in deinem Editor, mit deinem Code direkt daneben. Am besten für die tägliche Bearbeitung.
  • Autonom / abgeschottet (OpenHands) — eine ganze Aufgabe übergeben und das Ergebnis prüfen. Am besten für Batch- oder Hands-off-Arbeit.

Achse 2 — Claude-betrieben vs. vollständig lokal:

  • Claude-betrieben — beste Qualität, besonders bei schweren Aufgaben über mehrere Dateien oder mit langem Kontext. Dein Code wird an die Modell-API gesendet. Wähle dies, wenn Qualität am wichtigsten ist und dein Code an einen Anbieter gesendet werden darf.
  • Vollständig lokal (Ollama) — dein Code verlässt den Rechner nie; kostenlos zu betreiben; funktioniert offline. Wähle dies, wenn Datenschutz, Regulierung oder Netztrennung nicht verhandelbar sind — unter Inkaufnahme, dass ein laptop-großes Modell bei den schwersten Aufgaben schwächer ist.

Der nachhaltige Zug: Wähle den Agenten nach der Oberfläche, die zu deinem Workflow passt, und dann das Modell pro Aufgabe. Nichts hindert dich daran, einen IDE-Agenten für das vertrauliche Repo auf einem lokalen Modell laufen zu lassen und denselben Agenten für alles andere auf Claude.

Einen Coding-Agenten auswählen und einrichten​

Guided walkthrough1 of 5
  1. CLI (Aider, Claude Code), IDE-integriert (Cline, Continue) oder autonom (OpenHands). Passe sie dorthin an, wo du bereits arbeitest — Terminal vs. Editor vs. Übergeben-und-Prüfen.

Ein konkreter erster Lauf mit Aider, gerichtet auf ein lokales Modell (privat, kostenlos, offline) — zieh zuerst das Modell mit Ollama, dann:

Aider auf einem lokalen Ollama-Modell ausführen (Code bleibt auf deinem Rechner)

aider --model ollama_chat/qwen3

Um dasselbe Tool stattdessen auf Claude zu richten (beste Qualität, Code wird an die API gesendet), setzt du deinen Anthropic-Schlüssel und wählst ein Claude-Modell — die Agentenschleife ist identisch; nur das Gehirn ändert sich:

export ANTHROPIC_API_KEY=sk-ant-...
aider --model sonnet

Dieser Tausch — ein Flag, zwei völlig unterschiedliche Datenschutz-/Qualitätsprofile, derselbe Agent — ist der ganze Sinn dieser Seite.

Teste dich selbst

0/4
  1. Was bedeutet 'modellagnostisch' für einen Coding-Agenten wie Aider oder Cline?
  2. Deine Codebasis darf aus rechtlichen Gründen dein Netzwerk nicht verlassen. Welches Setup passt?
  3. Wie unterscheidet sich Claude Code von Aider, Cline, Continue und OpenHands?
  4. Welches Tool ist das autonomste — gebaut, um eine ganze Aufgabe zu übernehmen und sie in einer Sandbox mit weniger schrittweiser Freigabe auszuführen?
Drücke Enter oder die Leertaste, um die Karte umzudrehen. Nutze die Pfeiltasten links und rechts, um zwischen den Karten zu wechseln.Begriff angezeigt.
1 / 8
Key takeaways
  • Ein Coding-Agent führt eine Schleife auf deinem Rechner aus — Repo lesen, planen, Dateien bearbeiten, Tests ausführen, iterieren — statt dir Snippets zum Einfügen zu reichen.
  • Fast alle dieser Tools sind modellagnostisch: Agent und Modell sind getrennt, sodass du das Gehirn tauschst, ohne die Schleife zu ändern.
  • Zwei Regler: Claude für die beste Codequalität oder ein lokales Open-Weight-Modell über Ollama für vollen Datenschutz — dein Code verlässt den Rechner nie.
  • Aider = CLI/Git; Cline = Agent in deiner IDE; Continue = konfigurierbarer IDE-Assistent; OpenHands = autonom/abgeschottet; Claude Code = Anthropics eigener Claude-nativer Agent.
  • Wähle entlang zweier Achsen — wo der Agent lebt (CLI vs. IDE vs. autonom) und Claude-betrieben vs. vollständig lokal — und wähle das Modell pro Aufgabe, nicht ein für alle Mal.

Quellen & weiterführende Lektüre​