KI-Coding-Agent: GPT-6.1 Sol vs. Claude 5.5 [2026]

Ende September 2026 haben OpenAI und Anthropic im Abstand von nur 24 Stunden zwei neue Modelle veröffentlicht: GPT-6.1 Sol am 29. September und Claude Sonnet 5.5 am 28. September. Beide zielen explizit auf Programmieraufgaben, Tool-Nutzung und professionelle Workflows ab, und beide sind günstiger als ihre jeweiligen Flaggschiff-Vorgänger. Für Entwicklerteams in Deutschland, Österreich und der Schweiz ergibt sich daraus ein Zeitfenster, das sich lohnt: Mit zwei komplementären APIs lässt sich ein eigener Coding-Agent bauen, der Code generiert, ihn von einem zweiten Modell gegenprüfen lässt und die Kosten dabei im Blick behält. Dieses Tutorial zeigt in 12 Schritten, wie ein solches System in rund 90 Minuten entsteht, inklusive Kosten-Tracking, REST-Endpoint und DSGVO-Hinweisen für den Betrieb in der EU.

Das Tutorial richtet sich an Entwicklerinnen und Entwickler mit Python-Grundkenntnissen, die noch keine eigene Agenten-Architektur gebaut haben, aber verstehen wollen, wie sich zwei APIs sinnvoll kombinieren lassen. Am Ende steht ein vollständiges, lauffähiges Projekt mit Ordnerstruktur, REST-Schnittstelle, Unit-Tests und einer parallelen Verarbeitung mehrerer Aufgaben, nicht nur ein isoliertes Codefragment. Wer die zwölf Schritte in der angegebenen Reihenfolge abarbeitet, hat am Schluss ein Werkzeug, das sich direkt in bestehende Entwicklungsprozesse einbauen lässt.

Google · Bevorzugte Quellen

Verpasse keine neuen Tech-Storys auf Google

Füge TrendinTech Deutschland einmal in der Google-App hinzu und unsere Artikel erscheinen in deinen Vorschlägen.

Jetzt hinzufügen

Warum GPT-6.1 Sol und Claude Sonnet 5.5 jetzt den KI-Agenten-Markt verändern

Der September 2026 war ein ungewöhnlich dichter Monat für neue Sprachmodelle. OpenAI positioniert GPT-6.1 Sol als Modell für Coding, Computer-Use und professionelle Arbeit, mit einer Intelligenz nahe am teureren GPT-6 Astra, aber zu einem Fünftel des Preises für Input- und Output-Token. Konkret liegt GPT-6.1 Sol bei 2 US-Dollar pro Million Input-Token und 10 US-Dollar pro Million Output-Token, bei einem Kontextfenster von bis zu 1.050.000 Token. Das Modell ist über die OpenAI API, ChatGPT Work und Codex verfügbar.

Anthropic zog einen Tag früher nach und launchte Claude Sonnet 5.5 als zweites Modell der neuen Claude-5.5-Familie, nach Claude Opus 5.5 vom 22. September. Sonnet 5.5 ist als schnellere und günstigere Ergänzung zu Opus 5.5 gedacht und lässt sich über die Claude API, AWS, Google Cloud und Azure einsetzen. Kurz darauf, am 7. Oktober, folgte laut Branchentracker AI/TLDR zusätzlich Claude Haiku 5.5 mit einem Kontextfenster von 1 Million Token bei einem Einstiegspreis von 0,10 US-Dollar pro Million Input-Token, was die Familie nach unten abrundet.

Der Zeitpunkt ist kein Zufall. Beide Anbieter konkurrieren aktuell direkt um Entwicklerteams, die APIs für automatisierte Coding-Workflows einsetzen, von einfachen Codegenerierungs-Tools bis zu komplexeren Agentensystemen, die mehrere Schritte eigenständig abarbeiten. Günstigere Preise pro Million Token bei gleichzeitig höherer Modellqualität senken die Einstiegshürde für genau solche Projekte, auch für kleinere Teams ohne großes API-Budget. Das macht den Herbst 2026 zu einem günstigen Moment, um mit einem eigenen, kleinen Agenten zu experimentieren, statt auf ein fertiges, oft teureres Produkt eines Drittanbieters zu warten.

Parallel dazu hat Google DeepMind am 30. September Gemini 4 Argon vorgestellt, ein Modell für langfristige Software-Engineering-Aufgaben, Wissensarbeit und defensive Cybersicherheit, das laut dem Tech Times AI-Timeline-Tracker zunächst nur ausgewählten Sicherheitsteams über das sogenannte Fairwind-Programm zur Verfügung steht. DeepSeek wiederum veröffentlichte bereits am 10. September V4.1 Flash als Mixture-of-Experts-Modell mit 552 Milliarden Parametern, von denen während der Prefill-Phase etwa 8 Milliarden und während der Decode-Phase rund 16 Milliarden aktiv sind. Das Modell unterstützt ein Kontextfenster von 1 Million Token, nativ multimodale Eingaben und wird unter MIT-Lizenz mit offenen Gewichten bereitgestellt, was es zu einem interessanten Kandidaten für lokale Experimente macht.

Für dieses Tutorial kombinieren wir die beiden am breitesten verfügbaren und günstigsten Optionen: GPT-6.1 Sol als Code-Generator und Claude Sonnet 5.5 als Code-Reviewer. Beide Modelle sind per API sofort nutzbar, beide sind für Coding-Aufgaben optimiert, und beide liegen preislich im Bereich, der für Experimente und kleine Produktionsworkloads tragbar ist.

Für kleine und mittlere Unternehmen im DACH-Raum ist genau dieser Preispunkt entscheidend. Ein Softwareteam, das bisher aus Kostengründen auf automatisierte Code-Reviews verzichtet hat, kann mit einem zweistufigen Agenten aus GPT-6.1 Sol und Claude Sonnet 5.5 Routineaufgaben wie Hilfsfunktionen, Datenvalidierung oder kleine Skripte zu einem Bruchteil der Kosten eines manuellen Reviews vorprüfen lassen. Das ersetzt keine erfahrene Entwicklerin oder keinen erfahrenen Entwickler, reduziert aber die Zahl der offensichtlichen Fehler, die sonst erst im Pull-Request-Review auffallen. Gerade für Teams, die beide Modelle noch nie produktiv eingesetzt haben, lohnt sich ein kleines, gut verständliches Projekt wie dieses als Einstieg, bevor größere interne Systeme darauf aufbauen.

Voraussetzungen: Tools, Accounts und Versionen im Überblick

Bevor es an den Code geht, braucht es eine saubere Grundausstattung. Die folgende Tabelle listet alles, was für dieses Projekt installiert oder eingerichtet sein muss, inklusive der Mindestversionen, die zum Zeitpunkt dieses Artikels aktuell sind.

Werkzeug / Account	Empfohlene Version	Zweck im Projekt
Python	3.12 oder neuer	Laufzeitumgebung für den Agenten
pip	24.x oder neuer	Paketverwaltung
openai (Python-Paket)	aktuelle Version aus PyPI	Zugriff auf GPT-6.1 Sol über die OpenAI API
anthropic (Python-Paket)	aktuelle Version aus PyPI	Zugriff auf Claude Sonnet 5.5 über die Claude API
fastapi + uvicorn	aktuelle Version aus PyPI	REST-Endpoint für den Agenten
python-dotenv	aktuelle Version aus PyPI	Laden der API-Keys aus einer .env-Datei
OpenAI-Account mit API-Key	–	Zugang zu GPT-6.1 Sol
Anthropic-Account mit API-Key	–	Zugang zu Claude Sonnet 5.5
Terminal / Shell	bash oder zsh	Befehle ausführen, Server starten

Beide API-Keys lassen sich direkt im jeweiligen Entwicklerportal erzeugen. Die Python-Paketdokumentation für beide SDKs ist frei zugänglich, etwa das openai-Paket auf PyPI und das anthropic-Paket auf PyPI. Wer kein eigenes Geld investieren möchte, bekommt bei beiden Anbietern üblicherweise ein kleines Startguthaben für Tests, das für dieses Tutorial locker ausreicht.

Python 3.12 ist deshalb die sinnvolle Untergrenze, weil beide SDKs moderne Sprachfeatures wie strukturierte Typ-Hinweise voraussetzen und ältere Python-Versionen bei neueren Paketversionen zunehmend zu Kompatibilitätswarnungen führen. Wer bereits ein anderes Python-Projekt mit einer älteren Version pflegt, sollte für den Agenten trotzdem eine separate virtuelle Umgebung mit aktueller Python-Version anlegen, statt die bestehende Umgebung wiederzuverwenden. Das vermeidet Versionskonflikte zwischen den Abhängigkeiten unterschiedlicher Projekte, die sich sonst nur schwer auseinanderhalten lassen.

Architektur: So spielen Generator, Reviewer und Orchestrator zusammen

Der Agent, den wir bauen, besteht aus drei Bausteinen. Der Generator schickt eine Aufgabenbeschreibung in deutscher Sprache an GPT-6.1 Sol und bekommt einen ersten Codeentwurf zurück. Der Reviewer gibt diesen Entwurf an Claude Sonnet 5.5 weiter, das den Code auf Fehler, Sicherheitsprobleme und Stilfragen prüft und gegebenenfalls eine überarbeitete Version liefert. Der Orchestrator steuert den Ablauf, protokolliert Tokenverbrauch und Kosten und stellt am Ende eine REST-Schnittstelle bereit, über die sich der ganze Prozess mit einem einzigen HTTP-Request anstoßen lässt.

Warum zwei Modelle statt einem

Ein einzelnes Modell kann eigene Fehler oft nicht erkennen, weil es in derselben Denkweise steckenbleibt, die den Fehler erst erzeugt hat. Ein zweites Modell mit anderer Trainingsbasis prüft aus einer anderen Perspektive und findet dadurch Probleme, die beim ersten Durchgang durchrutschen. In der Praxis zeigt sich das besonders bei Randfällen, fehlender Fehlerbehandlung oder unsicheren Default-Werten.

Optionale Erweiterung mit DeepSeek V4.1 Flash

Wer zusätzlich ein drittes, günstigeres Votum möchte, kann DeepSeek V4.1 Flash als dritten Prüfer einbinden. Da die Gewichte unter MIT-Lizenz offen verfügbar sind, lässt sich das Modell auch selbst hosten, was für Teams mit strengen Datenschutzanforderungen relevant sein kann. In diesem Tutorial bleibt die Integration optional und wird am Ende als Erweiterung skizziert.

Datenfluss Schritt für Schritt

Konkret läuft eine einzelne Anfrage so durch das System: Zuerst nimmt der FastAPI-Endpoint eine Aufgabenbeschreibung in deutscher Sprache als JSON entgegen. Der Orchestrator reicht diesen Text unverändert an den Generator weiter, der daraus über die OpenAI API einen Codevorschlag von GPT-6.1 Sol anfordert. Sobald der Code zurückkommt, reicht der Orchestrator ihn zusammen mit einer festen Prüfanweisung an den Reviewer weiter, der über die Anthropic API eine Einschätzung von Claude Sonnet 5.5 einholt. Beide Zwischenergebnisse, inklusive der jeweils verbrauchten Token, laufen am Ende wieder im Orchestrator zusammen, der daraus die Gesamtkosten berechnet und eine einzige JSON-Antwort an den aufrufenden Client zurückgibt. Jeder dieser Schritte ist bewusst als eigene Funktion gekapselt, damit sich einzelne Teile austauschen oder testen lassen, ohne den restlichen Ablauf zu verändern.

Ein praktisches Beispiel verdeutlicht den Nutzen dieser Architektur: Ein Team, das einen Rückstand von 50 kleinen Tickets abarbeiten muss, etwa kleine Hilfsfunktionen, Datenvalidierungen oder einfache Parser, kann jedes Ticket als einzelne Aufgabenbeschreibung an den Agenten schicken. Statt dass eine Entwicklerin oder ein Entwickler jedes Ticket von Hand durchgeht, liefert der Agent für jedes Ticket einen ersten Codeentwurf samt Review, und das Team muss nur noch die bereits vorgeprüften Vorschläge gegenlesen und freigeben. Bei den in diesem Tutorial gezeigten Preisen bleibt der Gesamtaufwand für 50 solcher Durchläufe im niedrigen einstelligen Euro-Bereich, deutlich unter dem Zeitaufwand, den ein manueller Ersteinwurf für jedes einzelne Ticket verursachen würde.

Schritt 1 bis 3: Entwicklungsumgebung und Projektstruktur einrichten

Der erste Schritt ist eine isolierte virtuelle Umgebung, damit Paketversionen dieses Projekts keine anderen Python-Installationen beeinflussen. Details zum Mechanismus liefert die offizielle venv-Dokumentation von Python. Im zweiten und dritten Schritt folgen die Projektstruktur und die Installation der benötigten Pakete.

mkdir ki-coding-agent && cd ki-coding-agent
python3 -m venv .venv
source .venv/bin/activate

mkdir -p agent
touch agent/__init__.py agent/generator.py agent/reviewer.py agent/orchestrator.py
touch main.py .env requirements.txt

pip install --upgrade pip
pip install openai anthropic fastapi uvicorn python-dotenv
pip freeze > requirements.txt

Nach diesem Schritt liegt eine saubere Ordnerstruktur vor: ein Paket agent mit den drei Kernmodulen, eine zentrale main.py für den FastAPI-Server und eine .env-Datei für geheime Zugangsdaten, die niemals in ein Git-Repository gehört. Diese Trennung in einzelne Module mag für ein so kleines Projekt zunächst übertrieben wirken, zahlt sich aber aus, sobald das Projekt wächst. Wer später zum Beispiel ein viertes Modul für automatisierte Tests oder ein fünftes für ein Web-Frontend ergänzt, kann das ohne Umbau der bestehenden Dateien tun, weil jedes Modul nur eine klar abgegrenzte Aufgabe hat.

Direkt im Anschluss empfiehlt sich ein Eintrag in der .gitignore-Datei, der die Ordner .venv und die Datei .env von der Versionskontrolle ausschließt. Das verhindert, dass beim ersten Commit versehentlich sowohl die virtuelle Umgebung als auch geheime API-Keys in ein Repository gelangen, ein Fehler, der in der Praxis überraschend häufig passiert.

# .gitignore
.venv/
.env
agent_runs.log
__pycache__/
*.pyc

Mit dieser kurzen Datei ist das Projekt von Anfang an sauber von sensiblen und temporären Dateien getrennt. Das kostet im ersten Schritt nur eine Minute, erspart aber im Nachhinein die mühsame Arbeit, versehentlich committete Keys aus der Git-Historie zu entfernen.

Schritt 4 und 5: API-Zugänge für OpenAI und Anthropic konfigurieren

Beide Anbieter erzeugen API-Keys im jeweiligen Entwicklerportal. Diese Keys werden in die .env-Datei eingetragen und per python-dotenv geladen, statt sie im Code fest zu verdrahten. Das ist nicht nur sauberer, sondern verhindert, dass Zugangsdaten versehentlich in ein öffentliches Repository landen.

# .env
OPENAI_API_KEY=sk-dein-openai-key
ANTHROPIC_API_KEY=sk-ant-dein-anthropic-key
GENERATOR_MODEL=gpt-6.1-sol
REVIEWER_MODEL=claude-sonnet-5-5-20260928
MAX_OUTPUT_TOKENS=2000

Die Modellnamen stehen bewusst als Umgebungsvariablen und nicht im Code, weil beide Anbieter regelmäßig neue Versionen veröffentlichen. Sollte in ein paar Monaten etwa Claude Haiku 5.5 für einfachere Reviews ausreichen, reicht eine Zeile Änderung in der .env-Datei, ohne den restlichen Code anzufassen.

Ein zweiter wichtiger Punkt bei diesem Schritt ist die Trennung zwischen Entwicklungs- und Produktionsschlüsseln. Viele Teams legen für Tests einen separaten API-Key mit niedrigerem Ausgabenlimit an, getrennt von dem Key, der später im echten Betrieb verwendet wird. Dadurch lässt sich ein fehlerhafter Testlauf, der versehentlich tausend Anfragen auslöst, nicht mit dem Produktionsbudget verwechseln. Beide Anbieter erlauben das Anlegen mehrerer Keys pro Account, inklusive individueller Ausgabenobergrenzen im jeweiligen Abrechnungsbereich.

Schritt 6 und 7: Code-Generator mit der GPT-6.1 Sol API implementieren

Das Generator-Modul schickt die Aufgabenstellung an GPT-6.1 Sol und erwartet als Antwort ausschließlich Code, ohne begleitenden Fließtext. Dafür hilft eine klare Systemanweisung, die das Modell auf die Rolle eines Code-Generators festlegt.

# agent/generator.py
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
MODEL = os.environ.get("GENERATOR_MODEL", "gpt-6.1-sol")

SYSTEM_PROMPT = (
    "Du bist ein praezises Coding-Werkzeug. Antworte ausschliesslich mit "
    "lauffaehigem Python-Code in einem einzigen Codeblock. Keine Erklaerungen, "
    "keine einleitenden Saetze."
)

def generate_code(task_description: str) -> dict:
    response = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": task_description},
        ],
        max_tokens=int(os.environ.get("MAX_OUTPUT_TOKENS", 2000)),
    )
    choice = response.choices[0].message.content
    usage = response.usage
    return {
        "code": choice,
        "input_tokens": usage.prompt_tokens,
        "output_tokens": usage.completion_tokens,
    }

Die Funktion gibt neben dem generierten Code auch die verbrauchten Token zurück, die später für das Kosten-Tracking gebraucht werden. Wer die Rate-Limit-Regeln der OpenAI API genauer verstehen möchte, findet Details in der offiziellen Rate-Limit-Dokumentation.

Die Systemanweisung ist bewusst streng formuliert, weil GPT-6.1 Sol wie die meisten Chat-Modelle standardmäßig dazu tendiert, Code mit erklärendem Fließtext einzurahmen. Für einen Agenten, der die Antwort automatisiert weiterverarbeitet, ist genau dieser Fließtext störend, da er sich nur mit zusätzlichem Aufwand wieder aus der Antwort herausfiltern lässt. Eine klare, kurze Systemanweisung, die ausschließlich Code ohne Kommentartext verlangt, spart diesen Zwischenschritt und macht die Ausgabe direkt weiterverarbeitbar. Wer möchte, kann die Anweisung zusätzlich um Stilvorgaben erweitern, etwa die Vorgabe, konsequent Typ-Hinweise zu verwenden oder eine bestimmte Formatierungskonvention wie PEP 8 einzuhalten.

Schritt 8 und 9: Code-Review-Modul mit Claude Sonnet 5.5 bauen

Das Reviewer-Modul bekommt den von GPT-6.1 Sol erzeugten Code als Eingabe und wird angewiesen, Fehler, Sicherheitslücken und unsaubere Stellen zu benennen und eine korrigierte Fassung zu liefern. Die Anthropic-API nutzt dafür die Methode messages.create, deren Parameter in der Anthropic-Dokumentation beschrieben sind.

# agent/reviewer.py
import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
MODEL = os.environ.get("REVIEWER_MODEL", "claude-sonnet-5-5-20260928")

REVIEW_PROMPT = (
    "Pruefe den folgenden Python-Code auf Fehler, Sicherheitsprobleme und "
    "unsaubere Stellen. Gib zuerst eine kurze Liste der gefundenen Probleme, "
    "danach die korrigierte Version in einem Codeblock.\n\nCode:\n{code}"
)

def review_code(code: str) -> dict:
    response = client.messages.create(
        model=MODEL,
        max_tokens=int(os.environ.get("MAX_OUTPUT_TOKENS", 2000)),
        messages=[
            {"role": "user", "content": REVIEW_PROMPT.format(code=code)}
        ],
    )
    text = response.content[0].text
    usage = response.usage
    return {
        "review": text,
        "input_tokens": usage.input_tokens,
        "output_tokens": usage.output_tokens,
    }

Auch hier wird der Tokenverbrauch zurückgegeben. Beide Module sind bewusst so klein gehalten, dass sie sich einzeln testen lassen, bevor der Orchestrator sie verbindet.

Claude Sonnet 5.5 eignet sich für die Reviewer-Rolle, weil Anthropic das Modell gezielt für Aufgaben trainiert, bei denen Genauigkeit wichtiger ist als Kreativität, etwa das Aufspüren logischer Fehler oder unsicherer Default-Werte in fremdem Code. Da der Reviewer ein anderes Modell von einem anderen Anbieter ist als der Generator, prüft er den Code gewissermaßen mit einem anderen Blick, was in der Praxis Fehler auffängt, die ein einzelnes Modell bei der Selbstkontrolle leicht übersieht. Wichtig ist, dass der Reviewer-Prompt konkret nach Problemen fragt, statt pauschal um eine Einschätzung zu bitten, da präzise Fragen in aller Regel zu präziseren und nützlicheren Antworten führen.

Schritt 10: Orchestrierungs-Loop und Tool-Aufrufe verbinden

Der Orchestrator ruft erst den Generator, dann den Reviewer auf und fasst beide Ergebnisse zu einer Antwort zusammen. Zusätzlich berechnet er die Kosten anhand der von beiden Anbietern veröffentlichten Preise pro Million Token.

# agent/orchestrator.py
from agent.generator import generate_code
from agent.reviewer import review_code

PRICING = {
    "gpt-6.1-sol": {"input": 2.00, "output": 10.00},
    "claude-sonnet-5-5-20260928": {"input": 3.00, "output": 15.00},
}

def _cost(model_key: str, input_tokens: int, output_tokens: int) -> float:
    price = PRICING[model_key]
    return (input_tokens / 1_000_000 * price["input"]) + (
        output_tokens / 1_000_000 * price["output"]
    )

def run_agent(task_description: str) -> dict:
    gen_result = generate_code(task_description)
    review_result = review_code(gen_result["code"])

    gen_cost = _cost("gpt-6.1-sol", gen_result["input_tokens"], gen_result["output_tokens"])
    review_cost = _cost(
        "claude-sonnet-5-5-20260928",
        review_result["input_tokens"],
        review_result["output_tokens"],
    )

    return {
        "generated_code": gen_result["code"],
        "review": review_result["review"],
        "cost_usd": round(gen_cost + review_cost, 5),
        "tokens_used": {
            "generator": gen_result["input_tokens"] + gen_result["output_tokens"],
            "reviewer": review_result["input_tokens"] + review_result["output_tokens"],
        },
    }

Die Preisangaben in PRICING entsprechen den zum Start von GPT-6.1 Sol veröffentlichten Tarifen von 2 US-Dollar Input und 10 US-Dollar Output pro Million Token. Für Claude Sonnet 5.5 sollte vor dem Produktiveinsatz immer die aktuelle Preisliste im Anthropic-Account geprüft werden, da sich Tarife je nach Region und Vertrag unterscheiden können.

Der Grund, die Kostenberechnung direkt im Orchestrator und nicht erst nachträglich aus der Monatsrechnung abzuleiten, liegt in der Reaktionszeit. Wenn jede Antwort bereits die tatsächlichen Kosten des einzelnen Laufs enthält, lässt sich sofort erkennen, ob eine bestimmte Art von Aufgabe unverhältnismäßig teuer ist, etwa weil eine zu lange Aufgabenbeschreibung ein großes Kontextfenster füllt. Dieses Prinzip, Kosten so nah wie möglich am Ereignis zu messen, lässt sich auf praktisch jedes System übertragen, das mehrere kostenpflichtige API-Aufrufe pro Anfrage auslöst.

Schritt 11 und 12: Kosten-Tracking, Logging und REST-Endpoint

Im vorletzten Schritt kommt ein einfaches Logging hinzu, das jeden Agentenlauf mit Zeitstempel, verwendeten Token und Kosten in eine lokale Datei schreibt. Im letzten Schritt wird die ganze Logik über FastAPI als REST-Endpoint erreichbar gemacht, damit auch andere Systeme den Agenten ansprechen können.

# main.py
import json
import logging
from fastapi import FastAPI
from pydantic import BaseModel
from dotenv import load_dotenv
from agent.orchestrator import run_agent

load_dotenv()
logging.basicConfig(filename="agent_runs.log", level=logging.INFO)

app = FastAPI(title="KI Coding Agent")

class TaskRequest(BaseModel):
    task: str

@app.post("/agent/run")
def run(request: TaskRequest):
    result = run_agent(request.task)
    logging.info(json.dumps({"task": request.task, "cost_usd": result["cost_usd"]}))
    return result

Der Server startet mit uvicorn main:app –reload und ist danach unter http://127.0.0.1:8000/agent/run erreichbar. Ein Testaufruf per curl sieht so aus:

curl -X POST http://127.0.0.1:8000/agent/run \
  -H "Content-Type: application/json" \
  -d '{"task": "Schreibe eine Funktion, die eine CSV-Datei einliest und die Summe einer Spalte berechnet."}'

Eine typische Antwort sieht gekürzt so aus:

{
  "generated_code": "import csv\n\ndef sum_column(path, column):\n    ...",
  "review": "1. Fehlende Fehlerbehandlung bei nicht vorhandener Datei.\n2. ...",
  "cost_usd": 0.00284,
  "tokens_used": {
    "generator": 412,
    "reviewer": 596
  }
}

Dieser einzelne Lauf kostet damit deutlich unter einem Cent, was zeigt, wie günstig sich kleine Automatisierungsaufgaben mit den aktuellen Modellpreisen umsetzen lassen.

Schlägt dagegen einer der beiden API-Aufrufe fehl, etwa weil der Key ungültig ist, liefert der Server eine Fehlermeldung mit Statuscode, die sich ebenfalls protokollieren lässt:

{
  "detail": "Error code: 401 - Incorrect API key provided"
}

Solche Fehlermeldungen sollten nie unbemerkt im Hintergrund verschwinden. Schon ein einfacher try-except-Block um die beiden Aufrufe im Orchestrator, der den Fehler ins Log schreibt und eine verständliche Meldung an den Client zurückgibt, verhindert stille Ausfälle, die sonst erst durch Nachfragen von Nutzerinnen und Nutzern auffallen.

Das komplette Projekt: Fertiger Code und Ordnerstruktur

Nach allen zwölf Schritten ergibt sich folgende Projektstruktur, die direkt lauffähig ist, sobald die beiden API-Keys in der .env-Datei eingetragen sind:

ki-coding-agent/
├── .venv/
├── .env
├── requirements.txt
├── agent_runs.log
├── main.py
└── agent/
    ├── __init__.py
    ├── generator.py
    ├── reviewer.py
    └── orchestrator.py

Von hier aus lässt sich das Projekt in mehrere Richtungen erweitern: ein Streamlit-Frontend für nicht-technische Nutzer, ein Slack-Bot, der Aufgaben direkt aus einem Kanal entgegennimmt, oder eine Warteschlange für Batch-Verarbeitung größerer Mengen an Coding-Aufgaben. Die Kernlogik in orchestrator.py bleibt dabei in allen Fällen unverändert.

Bemerkenswert an dieser Struktur ist, wie wenig Code insgesamt nötig ist, um zwei Frontier-Modelle sinnvoll zu kombinieren. Die drei Dateien im agent-Paket umfassen zusammen deutlich unter 150 Zeilen Python-Code, und trotzdem deckt das Projekt bereits Codegenerierung, automatisierte Qualitätsprüfung, Kostenkontrolle und eine produktionsnahe Schnittstelle ab. Das zeigt, dass der eigentliche Mehrwert eines Agenten selten in komplexem Code liegt, sondern in der durchdachten Reihenfolge, in der die Modelle eingesetzt werden, und in den Daten, die zwischen ihnen weitergegeben werden. Wer dieses Grundgerüst einmal verstanden hat, kann es auf viele andere Zweiergespanne aus Generator und Prüfmodell übertragen, etwa für Texte, Konfigurationsdateien oder Datenbankabfragen, nicht nur für Python-Code.

GPT-6.1 Sol vs. Claude Sonnet 5.5 vs. DeepSeek V4.1 Flash vs. Gemini 4 Argon im Vergleich

Die vier im September 2026 veröffentlichten Modelle unterscheiden sich deutlich in Preis, Kontextfenster und Verfügbarkeit. Die folgende Tabelle fasst die wichtigsten Eckdaten zusammen, wie sie von den jeweiligen Anbietern und von Branchentrackern veröffentlicht wurden.

Modell	Anbieter	Release	Kontextfenster	Preis (Input / Output pro 1M Token)	Zugang
GPT-6.1 Sol	OpenAI	29.09.2026	bis 272.000 Token	2 $ / 10 $	OpenAI API, ChatGPT Work, Codex
Claude Sonnet 5.5	Anthropic	28.09.2026	nicht öffentlich final spezifiziert	je nach Vertrag	Claude API, AWS, Google Cloud, Azure
DeepSeek V4.1 Flash	DeepSeek	10.09.2026	1.000.000 Token	MIT-Lizenz, offene Gewichte	Self-Hosting oder API-Anbieter
Gemini 4 Argon	Google DeepMind	30.09.2026	nicht öffentlich final spezifiziert	rund 4 $ laut Tech Times AI-Timeline	zunächst nur Fairwind-Programm (Cyber-Defender)

Für ein Einsteigerprojekt wie in diesem Tutorial sind GPT-6.1 Sol und Claude Sonnet 5.5 die pragmatischste Wahl, weil beide ohne Warteliste per API sofort nutzbar sind. Gemini 4 Argon ist laut Google DeepMind aktuell zuerst für vertrauenswürdige Cyber-Defender über das Fairwind-Programm freigeschaltet, bevor ein breiterer Zugang folgt. DeepSeek V4.1 Flash eignet sich vor allem für Teams, die aus Datenschutz- oder Kostengründen lieber selbst hosten, auch wenn dafür mehr GPU-Infrastruktur nötig ist. Details zur Modellverfügbarkeit bei Google liefert die Gemini-API-Dokumentation, Hintergründe zu DeepSeek finden sich im offiziellen DeepSeek-Organisationsprofil auf GitHub.

Für ein Softwareteam in Hamburg, Wien oder Zürich bedeutet das in der Praxis: Wer schnell starten will, nimmt GPT-6.1 Sol und Claude Sonnet 5.5, wie in diesem Tutorial gezeigt. Wer dagegen bereits eine eigene GPU-Infrastruktur betreibt und keine Daten an US-Anbieter senden darf, sollte DeepSeek V4.1 Flash näher prüfen, auch wenn der Betriebsaufwand dafür höher ausfällt als bei einer reinen API-Lösung. Gemini 4 Argon bleibt für die meisten Teams vorerst eine Beobachtungsoption, bis der eingeschränkte Zugang über das Fairwind-Programm einem breiteren Rollout weicht.

Die 5 häufigsten Fehler beim Bau eigener KI-Agenten

Wer zum ersten Mal einen Agenten aus mehreren Modellen baut, tappt fast immer in dieselben Fallen. Die folgenden fünf Punkte kosten die meiste Zeit, lassen sich aber mit wenig Aufwand vermeiden.

API-Keys im Code statt in .env: Sobald ein Key fest im Quelltext steht, landet er früher oder später in einem Git-Commit. Immer über Umgebungsvariablen laden und die .env-Datei in die .gitignore eintragen.
Kein Token-Limit gesetzt: Ohne ein explizites Maximum für Output-Token kann ein einzelner fehlerhafter Prompt unerwartet hohe Kosten verursachen, besonders wenn ein Modell in eine Wiederholungsschleife gerät.
Keine Fehlerbehandlung bei API-Timeouts: Beide APIs können bei hoher Last zeitweise langsamer antworten. Ein Agent ohne Retry-Logik bricht dann komplett ab, statt es nach kurzer Pause erneut zu versuchen.
Review-Modell bekommt zu wenig Kontext: Wenn nur der rohe Code ohne die ursprüngliche Aufgabenstellung an den Reviewer geht, fehlen ihm wichtige Informationen, um zu beurteilen, ob der Code die eigentliche Anforderung überhaupt erfüllt.
Kosten nicht pro Anfrage, sondern nur im Nachhinein geschätzt: Wer Kosten erst am Monatsende aus der Rechnung ablesen kann, merkt ein Preisproblem viel zu spät. Das in diesem Tutorial gezeigte Logging pro Anfrage macht Kostenspitzen sofort sichtbar.

Alle fünf Punkte lassen sich mit den in diesem Tutorial gezeigten Mustern von Anfang an vermeiden, statt sie später mühsam nachzurüsten. Gerade die fehlende Fehlerbehandlung bei Timeouts fällt in Testläufen selten auf, weil die APIs im Normalbetrieb zuverlässig schnell antworten, und zeigt sich erst unter echter Last oder bei einem kurzfristigen Ausfall beim Anbieter.

Troubleshooting: Lösungen für die häufigsten Probleme

Auch mit sauberem Code treten beim Betrieb eines API-basierten Agenten typische Probleme auf. Die meisten davon lassen sich in wenigen Minuten lösen, sobald klar ist, wo die Ursache liegt. Die folgende Übersicht deckt die acht häufigsten Fälle ab, auf die Entwicklerteams in der Praxis stoßen, von fehlgeschlagener Authentifizierung bis zu unerwartet hohen Rechnungen am Monatsende.

Problem	Wahrscheinliche Ursache	Lösung
401 Unauthorized	Falscher oder abgelaufener API-Key	Key im jeweiligen Entwicklerportal neu generieren und .env aktualisieren
429 Too Many Requests	Rate-Limit des Accounts überschritten	Exponentielles Backoff einbauen, Anfragen drosseln, Limits im Konto prüfen
Leere oder abgeschnittene Antwort	max_tokens zu niedrig gesetzt	MAX_OUTPUT_TOKENS in der .env erhöhen
ModuleNotFoundError: openai	Virtuelle Umgebung nicht aktiviert	source .venv/bin/activate vor jedem Start ausführen
Review-Modell wiederholt nur den Code	Prompt enthält keine explizite Anweisung zur Fehlersuche	REVIEW_PROMPT präzisieren und konkrete Prüfkriterien nennen
Hohe Latenz bei jedem Lauf	Sequenzieller Aufruf von Generator und Reviewer	Für unabhängige Teilaufgaben parallele Requests mit asyncio nutzen
Unerwartet hohe Rechnung	Fehlendes Token-Limit oder Endlosschleife im Agenten-Code	Hartes Token-Budget pro Lauf setzen und Logging auswerten
FastAPI-Server startet, Endpoint antwortet aber nicht	Falscher Port oder Firewall blockiert lokalen Zugriff	uvicorn-Ausgabe auf den tatsächlich gebundenen Port prüfen, ggf. –port anpassen
Review-Text in falscher Sprache	Kein expliziter Sprachhinweis im Prompt	Im REVIEW_PROMPT ausdrücklich „antworte auf Deutsch“ ergänzen
Inkonsistente Ergebnisse bei identischer Aufgabe	Keine feste Temperatur gesetzt, Modell variiert Formulierungen	Temperatur-Parameter niedrig setzen, etwa zwischen 0 und 0.3, für reproduzierbarere Antworten

Die meisten dieser Probleme lassen sich schon beim ersten Testlauf erkennen, wenn die Antwort des Servers und die Logdatei agent_runs.log konsequent mitgelesen werden. Wer zusätzlich den HTTP-Statuscode jeder Antwort prüft, statt nur auf den Inhalt zu schauen, findet Authentifizierungs- und Rate-Limit-Probleme meist innerhalb der ersten Minute nach dem Start.

Fortgeschrittene Tipps und DSGVO-Hinweise für den Produktionseinsatz

Sobald der Agent über das Experimentierstadium hinauswächst, lohnen sich ein paar zusätzliche Maßnahmen. Erstens: ein Caching-Layer für wiederkehrende Aufgaben, der identische Anfragen erkennt und keine erneute API-Anfrage auslöst. Zweitens: ein Schwellenwert im Orchestrator, der bei Review-Ergebnissen mit kritischen Sicherheitsproblemen automatisch einen dritten Durchlauf anstößt, statt den Code ungeprüft weiterzugeben. Drittens: strukturierte Ausgaben statt Freitext, etwa durch ein festes JSON-Schema, das beide Modelle einhalten müssen, damit nachgeschaltete Systeme die Antwort zuverlässig verarbeiten können.

Unit-Tests für Generator und Reviewer

Weil jeder Testlauf gegen die echte API Geld kostet und von der Internetverbindung abhängt, lohnt sich ein zweiter Testpfad, der die beiden Module mit simulierten Antworten prüft, statt echte Anfragen zu senden. Mit der Bibliothek pytest und einem einfachen Monkeypatch lässt sich das in wenigen Zeilen umsetzen.

# tests/test_orchestrator.py
from unittest.mock import patch
from agent.orchestrator import run_agent

@patch("agent.orchestrator.review_code")
@patch("agent.orchestrator.generate_code")
def test_run_agent_returns_cost(mock_generate, mock_review):
    mock_generate.return_value = {
        "code": "def add(a, b):\n    return a + b",
        "input_tokens": 50,
        "output_tokens": 20,
    }
    mock_review.return_value = {
        "review": "Keine kritischen Probleme gefunden.",
        "input_tokens": 80,
        "output_tokens": 30,
    }

    result = run_agent("Schreibe eine Addier-Funktion.")

    assert "generated_code" in result
    assert result["cost_usd"] > 0
    assert result["tokens_used"]["generator"] == 70

Dieser Test läuft in Millisekunden, verursacht keine API-Kosten und prüft trotzdem die eigentliche Logik: Werden beide Module korrekt aufgerufen, stimmt die Kostenberechnung, und landet der generierte Code tatsächlich im Ergebnis. Für die echten API-Aufrufe empfiehlt sich ergänzend ein kleiner, manuell ausgeführter Integrationstest, der einmal pro Release gegen die echten Endpunkte läuft, statt bei jedem automatisierten Testlauf Kosten zu verursachen.

Mehrere Aufgaben parallel verarbeiten mit asyncio

Die in diesem Tutorial gezeigte Version verarbeitet eine Aufgabe nach der anderen. Sollen mehrere Aufgaben gleichzeitig bearbeitet werden, etwa weil mehrere Entwicklerinnen und Entwickler den Endpoint parallel nutzen, lohnt sich der Umstieg auf die asynchronen Varianten beider SDKs. Beide Anbieter liefern dafür eigene Async-Clients, die sich fast identisch zu den synchronen Varianten verwenden lassen.

# agent/batch.py
import asyncio
from openai import AsyncOpenAI
import os

async_client = AsyncOpenAI(api_key=os.environ["OPENAI_API_KEY"])
MODEL = os.environ.get("GENERATOR_MODEL", "gpt-6.1-sol")

async def generate_many(tasks: list[str]) -> list[str]:
    async def one(task: str) -> str:
        response = await async_client.chat.completions.create(
            model=MODEL,
            messages=[{"role": "user", "content": task}],
            max_tokens=1500,
        )
        return response.choices[0].message.content

    results = await asyncio.gather(*(one(t) for t in tasks))
    return results

# Aufruf: asyncio.run(generate_many(["Aufgabe 1", "Aufgabe 2", "Aufgabe 3"]))

Mit asyncio.gather laufen alle drei Anfragen gleichzeitig, statt nacheinander auf jede einzelne Antwort zu warten. Bei drei Aufgaben, die jeweils zwei Sekunden Antwortzeit haben, sinkt die Gesamtwartezeit dadurch von rund sechs Sekunden auf etwa zwei Sekunden. Für den FastAPI-Endpoint lässt sich diese Logik in eine zusätzliche Route wie /agent/run-batch einbauen, die eine Liste von Aufgaben entgegennimmt und eine Liste von Ergebnissen zurückgibt.

Für Teams in Deutschland, Österreich und der Schweiz kommt die Frage nach der Datenverarbeitung dazu. Claude Sonnet 5.5 lässt sich laut Anthropic auch über AWS, Google Cloud und Azure beziehen, was je nach gewählter Region eine Verarbeitung innerhalb der EU ermöglichen kann. Vor dem Produktiveinsatz mit personenbezogenen oder sensiblen Daten sollte jedes Team die aktuellen Auftragsverarbeitungsverträge und Regionseinstellungen des jeweiligen Cloud-Anbieters prüfen. Einen allgemeinen Überblick über die Anforderungen der Datenschutz-Grundverordnung liefert die Seite gdpr.eu. Wer aus Compliance-Gründen gar keine Daten an US-Anbieter senden möchte, findet in DeepSeek V4.1 Flash wegen der offenen MIT-Lizenz eine Option für ein vollständig selbst gehostetes Setup, wobei dafür entsprechende GPU-Kapazität bereitstehen muss.

Ein letzter Tipp: Modellnamen und Preise ändern sich bei beiden Anbietern regelmäßig. Wer den Agenten über mehrere Monate betreibt, sollte die aktuellen Modell-Updates im Blick behalten, etwa über die Anthropic-Newsseite oder die Modellübersicht auf platform.openai.com, um Code und Kostenkalkulation bei Bedarf schnell anzupassen.

Für den Dauerbetrieb lohnt sich außerdem ein einfaches Monitoring oberhalb der reinen Logdatei. Ein tägliches Skript, das die Summe der Spalte cost_usd aus agent_runs.log aufsummiert und bei Überschreiten eines festen Tagesbudgets eine Benachrichtigung auslöst, reicht für die meisten kleinen Teams bereits aus. Größere Teams, die den Agenten in mehrere interne Systeme einbinden, greifen stattdessen oft auf bestehende Observability-Werkzeuge zurück und lassen die Logzeilen dort zentral auswerten, statt eine eigene Lösung zu pflegen. Wichtig ist in beiden Fällen, dass Kosten, Fehlerraten und Antwortzeiten an einem Ort zusammenlaufen, statt über verschiedene Tools verstreut zu sein.

Häufig gestellte Fragen

Brauche ich für dieses Projekt zwingend beide API-Keys?
Ja, der in diesem Tutorial gezeigte Agent ruft sowohl GPT-6.1 Sol als auch Claude Sonnet 5.5 auf. Ohne einen der beiden Keys lässt sich nur eine der beiden Funktionen testen, der Vergleichseffekt zwischen Generator und Reviewer entfällt dann.

Wie hoch sind die laufenden Kosten im Alltag?
Bei kleinen Coding-Aufgaben liegt ein einzelner Agentenlauf meist im Bereich von wenigen Cent, abhängig von der Länge der Aufgabe und der Antwort. Das im Tutorial eingebaute Kosten-Tracking zeigt den exakten Betrag pro Anfrage direkt in der Antwort an, sodass sich Kostenspitzen bei besonders langen Aufgaben sofort erkennen lassen, statt erst am Ende des Monats in der Gesamtrechnung aufzufallen.

Kann ich GPT-6.1 Sol durch ein anderes Modell ersetzen?
Ja. Da der Modellname in der .env-Datei als Umgebungsvariable steht, reicht eine Änderung von GENERATOR_MODEL, um beispielsweise ein anderes verfügbares OpenAI-Modell zu testen, sofern die Preisangaben im Orchestrator entsprechend angepasst werden.

Ist DeepSeek V4.1 Flash eine sinnvolle Alternative zu den beiden Hauptmodellen?
Für Teams mit eigener GPU-Infrastruktur und strengen Datenschutzanforderungen ja, da die Gewichte offen unter MIT-Lizenz verfügbar sind. Für ein schnelles Einsteigerprojekt ohne eigene Hardware sind API-basierte Modelle wie GPT-6.1 Sol und Claude Sonnet 5.5 unkomplizierter.

Was passiert, wenn der Reviewer kritische Fehler findet?
In der Grundversion dieses Tutorials gibt der Agent den Review-Text einfach zusammen mit dem Originalcode zurück. Für den Produktionseinsatz empfiehlt sich ein zusätzlicher Schritt, der bei kritischen Befunden automatisch einen korrigierten Code-Vorschlag anfordert, bevor das Ergebnis ausgeliefert wird.

Funktioniert der Agent auch mit anderen Programmiersprachen als Python?
Grundsätzlich ja, da beide Modelle mehrere Programmiersprachen unterstützen. Dafür muss lediglich der Systemprompt im Generator-Modul angepasst werden, etwa um stattdessen JavaScript, Go oder TypeScript anzufordern. Die restliche Architektur aus Generator, Reviewer und Orchestrator bleibt dabei unverändert, nur die Formulierung in den Prompt-Texten ändert sich.

Lässt sich der Agent in eine bestehende CI/CD-Pipeline einbauen?
Ja, der FastAPI-Endpoint lässt sich problemlos von einem CI-Schritt per curl oder HTTP-Client aufrufen, etwa um automatisch generierte Hilfsfunktionen vor einem Merge zusätzlich gegenprüfen zu lassen. Sinnvoll ist dabei, den Pipeline-Schritt so zu gestalten, dass er bei kritischen Review-Befunden den Build fehlschlagen lässt, statt die Warnung nur anzuzeigen und zu ignorieren.

Was ist der Unterschied zwischen Claude Sonnet 5.5 und Claude Opus 5.5?
Laut Anthropic ist Sonnet 5.5 bewusst als schnellere und günstigere Ergänzung zu Opus 5.5 positioniert, das rund eine Woche früher, am 22. September 2026, veröffentlicht wurde. Für Review-Aufgaben wie in diesem Tutorial reicht die Qualität von Sonnet 5.5 in aller Regel aus.

KI-Coding-Agent selbst bauen: 12 Schritte, 90 Min [2026]