Blog • AI / Agent

Wie funktionieren AI Coding Agents? Claude Code, Codex, Xcode 27 Agent, Tool Calling und JSON-Daten erklärt

Öffnen Sie Claude Code, Codex oder Xcode 27 — die Oberfläche sieht aus wie Chat. Was wirklich das Repository ändert, Tests ausführt und den Simulator antippt, ist nicht diese Antwort in natürlicher Sprache.

Ein AI Coding Agent arbeitet so: Das Modell entscheidet den nächsten Schritt und sendet Tool Calling; ein lokaler oder im IDE sitzender Harness führt das Tool aus und füttert strukturierte Ergebnisse zurück. Parameter und Ergebnisse sind fast immer JSON.

Dieser Artikel erklärt:

• Welche Schicht ein Coding Agent gegenüber Vervollständigung zusätzlich hat
• Der gemeinsame Loop: beobachten → entscheiden → ausführen → zurückschreiben
• Warum Tool-Calling-arguments als JSON-String ankommen
• Wohin Claude Code, Codex und der Xcode 27 Agent den Werkzeugkasten legen
• Welche Schicht JSON / JSON Schema prüft — und wie Sie das lokal in JSONNote aufklappen

Kein Chatfenster — ein Loop

Vervollständigung beantwortet „was ist die nächste Zeile“. Ein Coding Agent beantwortet „wie bringen wir dieses Ziel in einem echten Projekt zu Ende“: Kontext lesen, Tool wählen, Code ändern, Befehl ausführen, Ergebnis lesen, erneut entscheiden.

Offizielle Docs wechseln die Formulierung. Die Form bleibt. Claude Code schreibt: Kontext sammeln → handeln → Ergebnisse prüfen. Xcode 27 plant zuerst, ändert dann, prüft sich selbst mit Build / Test / Preview / Simulator. Darunter sind beide:

1. 1
   Beobachten

   Dateien lesen, Symbole suchen, git-Status prüfen, fehlschlagende Testlogs holen. Ohne diesen Schritt ist der nächste Patch geraten.

2. 2
   Entscheiden

   Im Kontext wählt das Modell den nächsten Schritt: nochmal lesen, nochmal suchen, eine Stelle ändern, einen Befehl ausführen oder Sie etwas fragen.

3. 3
   Ausführen

   Der Harness empfängt den tool call und führt ihn unter Rechten und sandbox wirklich aus. Das Modell fasst die Festplatte in diesem Moment nicht an.

4. 4
   Zurückschreiben

   Tool-Ergebnisse werden Text oder JSON und landen wieder im Kontext. Das Modell macht mit der neuen Evidenz weiter oder erklärt die Arbeit für erledigt.

Sie sitzen in diesem Loop mit: unterbrechen, umlenken, riskante Aktionen freigeben. Das Modell schlussfolgert. Der Harness besitzt Tools, Rechte, Sitzungen und was „fertig“ heißt. Wie vier Produkte um diese Kontrolle ringen, siehe

AI Coding Agents sind mehr als Code-Vervollständigung: Worum konkurrieren Codex, Claude Code, OpenCode und DeepSeek Harness?

Dieser Artikel zerlegt nur, wie der Loop dreht und auf welchem Hop JSON erscheint. Für die Stack-Schichten siehe

2026 AI-Agent-Stack: Wie passen LLM, MCP, Function Calling und JSON Schema zusammen?.

Tool Calling: die Parameter sind JSON

Tool Calling (auch Function Calling) ist kein anderer Name für „das Modell kann Code schreiben“. Es ist ein strukturierter Funktionsaufruf: Das Modell wählt einen Namen aus den von Ihnen deklarierten Tools und erzeugt JSON, das zum Parametervertrag passen soll.

In OpenAI-kompatiblen APIs ist das Feld parameters einer Tool-Definition selbst JSON Schema:

{
  "type": "function",
  "function": {
    "name": "run_tests",
    "description": "Run the project test suite and return a structured summary.",
    "parameters": {
      "type": "object",
      "properties": {
        "suite": { "type": "string", "enum": ["unit", "integration", "e2e"] },
        "path": { "type": "string", "minLength": 1 }
      },
      "required": ["suite"],
      "additionalProperties": false
    }
  }
}

Wenn das Modell antwortet, ist arguments oft ein String, kein schon geparstes Objekt:

{
  "id": "call_8f21",
  "type": "function",
  "function": {
    "name": "run_tests",
    "arguments": "{\"suite\":\"unit\",\"path\":\"src/auth\"}"
  }
}

Die fachliche Schicht macht deshalb mindestens zwei Dinge: den String in gültiges JSON parsen, dann Felder, Typen und Enums gegen das deklarierte Schema prüfen. Fehlende Anführungszeichen, Extra-Kommas und nicht deklarierte Schlüssel passieren auf diesem Hop — nicht auf dem Hop „das Modell klang klug“.

Die volle Runde: Request mit Schema → Modell wählt ein Tool und erzeugt arguments → Sie parsen und prüfen → Tool ausführen → Ergebnis als tool message zurückfüttern → das Modell macht weiter. Ein klares Schema trifft die ersten arguments. Ein vages lässt den Loop leerlaufen.

Wie der Vertrag geschrieben wird und worin JSON Mode von Strict Schema unterscheidet, steht in

Warum brauchen AI Agents JSON Schema? Tool Calling bis Structured Output erklärt.

Claude Code: eingebaute Tools plus Erweiterungsschicht

Die offizielle Dokumentation von Claude Code teilt den Agent in zwei Teile: ein Modell, das schlussfolgert, und Tools, die handeln. Ohne Tools kann Claude nur Text zurückgeben. Mit Tools kann es das Repository lesen, Dateien ändern, Befehle ausführen und das Web durchsuchen.

Eingebaute Tools fallen in etwa fünf Gruppen: Dateioperationen (Read / Edit / Write), Suche (Grep / Glob), Ausführung (Bash), Web (WebSearch / WebFetch) und Code-Intelligenz, die ein Plugin braucht (Sprung zur Definition, Typfehler). Sub-Agents und eine Frage an Sie sind ebenfalls Tools — sie dienen der Orchestrierung.

Ein Durchlauf „die fehlschlagenden Tests reparieren“ kann im Loop so aussehen:

1. 1
   Bash führt die Tests aus

   Sehen, welche Assertion explodiert ist, bevor jemand den Code anfasst.

2. 2
   Grep / Read finden die Quelle

   Stack und Symbole nutzen, um den richtigen Kontext ins Fenster zu ziehen.

3. 3
   Edit macht eine präzise Ersetzung

   Die Docs verlangen erst lesen, dann ändern: old_string → new_string, damit nicht blind geschrieben wird.

4. 4
   Tests erneut ausführen

   Ergebnisse kehren in den Kontext zurück. Bei Fehlschlag geht es erneut in den Loop, statt laut „sollte passen“ zu sagen.

Die Erweiterungsschicht sitzt auf diesem Loop. Sie ersetzt ihn nicht:

• CLAUDE.md: Projektkonventionen, die jede Sitzung kennen sollte
• Skills: Workflows on demand, damit nicht jede Lektion im System-Prompt landet
• MCP: Tools für externe Systeme, standardmäßig on demand gesucht, damit der Kontext klein bleibt
• Hooks / Permissions: deterministische Sperren. Gefährliche Befehle und geschützte Pfade dürfen nicht davon abhängen, dass das Modell sich jedes Mal erinnert

Der Engineering-Kompromiss von Claude Code ist klar: ein probabilistischer Agent plus deterministische Hooks. Sitzungen landen außerdem als JSONL, damit Sie fortsetzen und forken können. Was Sie debuggen, ist oft ein Strom von Tool-Ereignissen, nicht „ein Chat“.

Codex: sandbox, Freigaben und JSONL

Codex läuft ebenfalls in einem Agent-Loop, aber das Produktzentrum ist, wie ein vom Modell erzeugter Befehl landet. Im Terminal, wenn Sie

Codex CLI ausführen, wählen Sie zuerst sandbox und Freigaben, dann darf das Modell handeln.

Für Automatisierung codex exec --json nutzen. stdout wird JSONL: Start und Ende von thread / turn, Befehlsausführung, Dateiänderungen, MCP-Aufrufe, Plan-Updates. CI-Skripte konsumieren einen Ereignisstrom, keinen Absatz.

{"type":"item.completed","item":{"id":"item_12","type":"command_execution","command":"npm test -- src/auth","exit_code":1,"aggregated_output":"FAIL src/auth/session.test.ts"}}
{"type":"item.completed","item":{"id":"item_13","type":"file_change","path":"src/auth/session.ts","kind":"update"}}
{"type":"turn.completed","usage":{"input_tokens":18420,"output_tokens":966}}

Wenn Downstream stabile Felder braucht, mit --output-schema die Endantwort an ein JSON Schema binden. Das ist dieselbe Vertragsart wie Tool-Calling-parameters. Gebunden wird das JSON am Aufgabenende, nicht jeder Befehl dazwischen.

Standardmäßig ist codex exec eine Nur-Lesen-sandbox. Um Dateien zu ändern, setzen Sie --sandbox workspace-write explizit. Brauchen Sie mehr Verzeichnisse, bevorzugen Sie --add-dir statt sofort zu danger-full-access zu greifen.

Xcode 27 Agent: Plan, Prüfung, Editor-Tools

Auf der WWDC 2026 hat Apple Xcode 27 als den Ort positioniert, an dem man auf Apple-Plattformen mit Agents Code schreibt. Anders als ein Terminal-Agent lebt der Werkzeugkasten in der IDE.

Apples Newsroom-Beitrag und

Xcode, agents, and you,

What’s new in Xcode 27 machen ein paar Dinge klar:

• Das Gespräch sitzt in einer Editor-Spalte, Sie können es neben Code teilen und Diffs sowie Artefakte prüfen
• /plan zuerst das Repository erkunden und einen Plan ausgeben, ohne schon Quellcode zu ändern; Sub-Agents können Kontext parallel sammeln
• In der Umsetzung prüft es mit Xcodes eigenen Tools: bauen, Tests ausführen, SwiftUI Preview rendern, die App im Simulator oder Device Hub antippen
• Build-Fehler gehen direkt zurück an den Agent, der aus dem Fehlerlog erneut ändert und baut
• Modelle sind nicht an einen Anbieter gebunden: Anthropic, Google, OpenAI und lokale Modelle
• MCP verbindet externe Tools; ACP holt externe Agents (einschließlich solcher wie OpenCode) nach Xcode

Ein WWDC-Lab hat Chat gegen Agent als Fähigkeitslücke gerahmt, nicht als Textlücke: Chat hat ein kleines festes Tool-Set; der Agent-Modus ergänzt Kommandozeile und Xcodes interne Tools (Build, Test, Preview, Simulator). Der Standardsicherheitsmodus sind Rechteabfragen — der Agent erreicht, was die Aufgabe braucht, darf aber nicht auf der Festplatte spazieren.

Für JSON-Entwickler ist der Punkt dieses Hops in Xcode: Prüfergebnisse sind ebenfalls strukturiertes Zurückschreiben. Build-Fehler, Testzusammenfassungen und Preview-Artefakte werden der nächste Input des Agents. Auf Ihrem Backend sehen Sie weiter Ihr eigenes API-JSON. In der IDE konsumiert derselbe Loop die Ausgabe der Xcode-Tools.

Systemweites Siri AI nutzt App Intents, nicht diesen Editor-Agent. Ziehen Sie die zwei Linien nicht zu „Apple hat nur eine Art Agent“ zusammen. Siehe

Wird Siri AI zum AI Agent?.

Drei Produkte, ein Loop, andere Werkzeugkästen

Feature-Listen werden sich weiter ähneln. Der Unterschied liegt in den Standard-Tools, der Ausführungsgrenze und darin, wie ein Ergebnis zum Kontext der nächsten Runde wird.

Die Wahl kann kurz bleiben: allgemeine mehrsprachige Repositories und wiederverwendbare Skills → Claude Code; auf echter Maschine laufen und Rechte in CI festschreiben → Codex; Apple-Plattformen, bei denen die Prüfung durch die Xcode-Toolchain muss → Xcode 27. ACP heißt, die letzte Option muss die ersten zwei nicht ausschließen — ein externer Agent kann in den Editor, Build und Preview bleiben Xcode-Tools.

Wo JSON sitzt und wer es prüft

Die drei UIs unterscheiden sich. Wo JSON auftaucht, ist stabil:

Der Kernsatz: Schema auf der API-Schicht führt die Erzeugung; Schema auf der fachlichen Schicht weist schmutzige Daten ab. Keines ersetzt das andere. Warum KI-Ausgabe zuerst ein Schema braucht, steht in

Warum braucht KI JSON Schema?.

Für ein Tool-Schema eines Coding Agents schreiben Sie, wann aufgerufen wird und wann nicht. Optionen gehören ins enum, nicht vergraben in description:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["action", "path"],
  "properties": {
    "action": { "type": "string", "enum": ["read", "edit", "test"] },
    "path": { "type": "string", "minLength": 1 },
    "suite": { "type": "string", "enum": ["unit", "integration"] },
    "old_string": { "type": "string" },
    "new_string": { "type": "string" }
  },
  "additionalProperties": false,
  "allOf": [
    {
      "if": { "properties": { "action": { "const": "edit" } } },
      "then": { "required": ["old_string", "new_string"] }
    },
    {
      "if": { "properties": { "action": { "const": "test" } } },
      "then": { "required": ["suite"] }
    }
  ]
}

Liefert das Modell {"action":"edit","path":"src/a.ts"} ohne old_string, stoppt das Schema auf der Ausführungsschicht. Das ist billiger, als hinterher ein Diff zu lesen.

Tool-Parameter in JSONNote debuggen

Der langsamste Teil der Agent-Arbeit ist oft nicht der Prompt. Es ist ein fehlgeschlagener tool call. JSONNote läuft lokal im Browser. Schlüssel und Repository-Inhalt werden nicht hochgeladen.

1. 1
   Sehen, ob arguments parsen

   Den vom Modell gelieferten String in JSON formatieren werfen. Fehlende Anführungszeichen, trailing commas und von einem Chat-Client abgeschnittene Hashes zeigen sich hier.

2. 2
   Dann gegen das Schema prüfen

   Tool-Definition und die tatsächlichen arguments in JSON Schema legen. Ein falsches enum, ein fehlendes required oder Extra-Felder nützen mehr als ein „sorry“ vom Modell.

3. 3
   Zwei Aufrufe vergleichen

   Nachdem Sie eine description geändert oder additionalProperties: false gesetzt haben, mit JSON Diff Parameter-Regressionen prüfen.

4. 4
   Die Debug-Szene teilen

   Mit URL Hash teilen ein Tool-JSON in einen Link einbetten. Ein Kollege öffnet und reproduziert. Die Daten treffen keinen Server.

FAQ

Worin unterscheiden sich AI Coding Agent und Code-Vervollständigung wesentlich?

Vervollständigung schlägt nur die nächste Zeile vor. Ein Coding Agent kann ein Repository lesen, Dateien ändern, Befehle ausführen, externe Tools aufrufen und im Loop anhand der Tool-Ergebnisse weiter entscheiden. Der Unterschied ist nicht die Textqualität. Es ist, ob er handeln kann.

Ändert das Modell Dateien direkt auf meiner Festplatte?

Nein. Das Modell erzeugt nur einen tool call, meist ein JSON. Der lokale Harness schreibt Dateien, führt die Shell aus und tippt den Simulator an. Fehlt ein Tool, wird die Berechtigung verweigert oder scheitert die Parameterprüfung, passiert auf der Festplatte nichts.

Was ist besser: Claude Code, Codex oder der Xcode 27 Agent?

Es gibt keinen einheitlichen Sieger. Claude Code für allgemeine Repositories plus Skills und MCP. Codex für sandbox, Freigaben und JSONL-Ereignisse in CI. Den Xcode 27 Agent für Apple-Plattformen, wenn Build, Preview und Simulator-Prüfung nötig sind. Xcode kann über ACP auch einen externen Agent anbinden.

Warum JSON selbst prüfen, wenn das Modell das Schema schon ausgefüllt hat?

Vom Modell gefüllte Parameter sind eine weiche Grenze. arguments ist oft ein String und kann Felder fehlen lassen, den falschen Typ nutzen oder nicht deklarierte Schlüssel hinzufügen. Produktion braucht weiter parse plus JSON Schema, dann die fachliche Schicht. Codex --output-schema bindet nur die Endantwort. Es ersetzt keine Prüfung jedes Tool-Ergebnisses.

Kann der Xcode 27 Agent nur Apples eigene Modelle nutzen?

Nein. Xcode 27 verdrahtet Modelle und Agents von Anthropic, Google und OpenAI in denselben Editor-Workflow. Es unterstützt auch lokale Modelle, ACP für externe Agents und MCP für externe Tools. Was sich ändert, ist der Werkzeugkasten und wie Arbeit geprüft wird — nicht der Loop selbst.

Fazit

Die drei Produkte werden weiter wie Chat aussehen. Der Satz darunter ändert sich nicht:

Coding Agent = Modell-Entscheidung × Tool Calling × Harness-Ausführung. JSON ist die gemeinsame Form von Tool-Parametern und zurückgeschriebenen Ergebnissen.

Zuerst den Loop sehen, dann den Werkzeugkasten wählen: Claude Code stärkt einen allgemeinen Agent, Codex besitzt sandbox und Ereignisse, Xcode 27 macht Build und Preview zu Prüf-Tools. Das Schema gehört in die Deklaration, die Prüfung auf die Ausführungsschicht, das Debuggen kann im lokalen Browser bleiben.

← Zurück zum Blog