Der Agent sagt, alles ist grün. Und jetzt?

Coding-Agenten können inzwischen erstaunlich viel erledigen. Sie ändern Code, starten Builds, führen Tests aus und erklären anschließend, dass die Aufgabe abgeschlossen ist. Das klingt nach einem ziemlich produktiven Arbeitstag. Zumindest für den Agenten.

Mich interessiert an dieser Stelle allerdings eine andere Frage: Was wurde tatsächlich geprüft?

Ein grüner Build ist keine Aussage darüber, ob die Anforderungen erfüllt sind. Ein erfolgreicher Testlauf beweist nicht, dass die entscheidenden Fehlerfälle abgedeckt wurden. Und ein Agent, der eine Konsolenausgabe überzeugend zusammenfasst, kann sie trotzdem falsch verstanden haben.

Damit ein Coding-Agent mehr ist als ein schneller Bediener der Kommandozeile, braucht er Zugriff auf Entwicklungswerkzeuge. Aber dieser Zugriff muss kontrollierbar sein. Und aus den Ergebnissen müssen sich belastbare Aussagen ableiten lassen.

Hier kommt das Model Context Protocol (MCP) ins Spiel.

↑ Nach oben

MCP verbindet Werkzeuge. Es bewertet sie nicht.

MCP stellt eine gemeinsame Schnittstelle bereit, über die eine KI-Anwendung externe Fähigkeiten entdecken und aufrufen kann. Das können Datenquellen, Suchfunktionen oder eben Werkzeuge der Softwareentwicklung sein.

Für einen Coding-Agenten ist das praktisch. Er muss nicht für jedes Build-System und jeden Test-Runner eine eigene Integrationslogik mitbringen. Ein MCP-Server kann eine klar definierte Operation anbieten, ihre Eingaben beschreiben und das Ergebnis zurückgeben.

Die Architektur unterscheidet drei Rollen:

  • Host: Die KI-Anwendung, in der der Agent arbeitet und die über die verfügbaren Funktionen entscheidet.
  • Client: Die Verbindungskomponente im Host, die mit einem bestimmten MCP-Server kommuniziert.
  • Server: Das Programm, das Funktionen und gegebenenfalls weitere Informationen bereitstellt.

Ein Host kann mehrere MCP-Clients und damit mehrere Server verwenden. Diese Rollen sind in der offiziellen MCP-Architekturübersicht beschrieben.

Entscheidend ist die Grenze: MCP standardisiert den Austausch, nicht die fachliche Qualität. Wenn ein Server einen Test falsch ausführt oder eine Warnung verschluckt, macht das Protokoll daraus keinen korrekten Test.

Das klingt selbstverständlich. Wird aber schnell übersehen, sobald eine hübsche Oberfläche „Erfolgreich“ meldet.

↑ Nach oben

Was bei einem Tool-Aufruf wirklich passiert

Ein MCP-Server kann sogenannte Tools bereitstellen. Jedes Tool besitzt unter anderem einen Namen, eine Beschreibung und ein Eingabeschema. Der Client kann die angebotenen Tools über tools/list ermitteln und eines davon über tools/call aufrufen.

Nehmen wir ein rein erfundenes Tool, das Tests für ein Projekt anstößt. Ein gekürzter Aufruf könnte so aussehen:

{
  "jsonrpc": "2.0",
  "id": 7,
  "method": "tools/call",
  "params": {
    "name": "run_project_tests",
    "arguments": {
      "project": "demo",
      "scope": "unit"
    }
  }
}

Der Name run_project_tests und die Parameter dienen nur als Beispiel. Sie sind keine standardisierten MCP-Tools und keine Behauptung über eine konkrete Implementierung.

Der Server führt daraufhin seine implementierte Funktion aus und liefert eine Antwort. Dabei muss man zwei Fehlerklassen auseinanderhalten:

  1. Protokoll- oder Verbindungsfehler: Der Aufruf kommt nicht ordnungsgemäß beim Server an oder kann dort nicht als MCP-Anfrage verarbeitet werden.
  2. Fachlicher Fehler: Der Aufruf funktioniert technisch, aber die ausgeführten Tests schlagen fehl oder das Prüfwerkzeug kann seine Aufgabe nicht abschließen.

Im zweiten Fall kann der Server regulär antworten und das Tool-Ergebnis beispielsweise mit isError: true kennzeichnen. Die MCP-Tools-Spezifikation beschreibt dieses Verhalten.

Für Softwarequalität reicht mir diese Unterscheidung allerdings noch nicht. Ich möchte zusätzlich wissen, welche Tests ausgeführt wurden, welche nicht und auf welcher Codeversion. Ein reiner Text wie „Tests erfolgreich“ ist dafür ziemlich dünn.

↑ Nach oben

Eine sinnvolle Antwort braucht mehr als „OK“

Stellen wir uns vor, ein Agent soll prüfen, ob eine Änderung freigegeben werden kann. Für diese Entscheidung wäre ein strukturiertes Ergebnis hilfreich, das mindestens folgende Informationen enthält:

Information Warum sie wichtig ist
Projekt und Commit Damit klar ist, auf welchen Code sich das Ergebnis bezieht
Prüfart und konkrete Prüfschritte Damit nicht „Tests“ behauptet wird, obwohl nur ein Teil lief
Werkzeug und Version Damit sich Unterschiede zwischen Entwicklungsumgebungen nachvollziehen lassen
Status je Prüfung Damit bestanden, fehlgeschlagen und nicht ausgeführt unterscheidbar bleiben
Diagnosen und begrenzte Artefakte Damit Fehler überprüft werden können, ohne Logs ins Unendliche wachsen zu lassen

MCP erlaubt strukturierte Tool-Ergebnisse und die Beschreibung einer Ausgabestruktur über ein outputSchema. Das ist eine gute technische Grundlage. Welche Felder ein Qualitätssicherungswerkzeug tatsächlich benötigt, muss aber die Anwendung definieren.

Besonders wichtig finde ich drei Zustände: bestanden, fehlgeschlagen und nicht ausgeführt.

Der dritte Zustand wird gern unterschätzt. Wenn der Test-Runner wegen einer fehlenden Abhängigkeit gar nicht gestartet wurde, darf das nicht in einer freundlichen Erfolgsmeldung verschwinden. Dasselbe gilt, wenn ein Timeout den Lauf abbricht oder die gesuchte Testdatei gar nicht vorhanden war.

Die Oberfläche darf gern grün sein. Nur bitte nicht, weil jemand die anderen Farben vergessen hat.

↑ Nach oben

Lokal gestartet heißt nicht ungefährlich

Für lokale Entwicklungsumgebungen ist der MCP-Transport über stdio naheliegend. Der Client startet dabei typischerweise den Serverprozess, und beide tauschen JSON-RPC-Nachrichten über stdin und stdout aus. Logmeldungen gehören auf stderr, weil beliebige Ausgaben auf stdout den Protokollstrom beschädigen können. Daneben gibt es den Transport Streamable HTTP für andere Betriebsformen. Die MCP-Transportspezifikation beschreibt die Unterschiede.

stdio spart für lokale Werkzeuge einen zusätzlichen Netzwerkdienst. Es ist aber keine Sicherheitsfunktion.

Ein MCP-Server, der mit meinen Benutzerrechten läuft, kann grundsätzlich auch Dinge tun, die dieses Benutzerkonto darf. Wenn ich ihm eine Funktion anbiete, die beliebige Shell-Kommandos ausführt, habe ich damit noch keine kontrollierte Entwicklungsumgebung geschaffen. Ich habe einem Agenten nur einen ziemlich großen Werkzeugkasten in die Hand gedrückt.

Sinnvolle Grenzen gehören deshalb auf mehrere Ebenen:

  • Im Host: Nur benötigte Tools verfügbar machen und riskante Aktionen nach den Regeln der Anwendung freigeben lassen.
  • Im Server: Eingaben prüfen, erlaubte Operationen begrenzen und Projektverzeichnisse verbindlich festlegen.
  • Im Betriebssystem: Prozesse mit möglichst wenigen Rechten betreiben und bei Bedarf Ausführung, Dateizugriff und Ressourcenverbrauch isolieren.

Ein übergebener Projektpfad darf beispielsweise nicht einfach ungeprüft als Verzeichnisgrenze gelten. Relative Pfade und symbolische Links können dazu führen, dass ein Werkzeug ganz woanders arbeitet als gedacht. Frei zusammengesetzte Shell-Befehle sind ebenfalls keine besonders gute Idee.

Dazu kommt ein Problem, das nichts mit dem Transport zu tun hat: Tool-Ausgaben sind Daten, keine Anweisungen. In einem Quellcodekommentar, einer README oder einem Build-Log kann Text stehen, der einen Agenten zu einer bestimmten Handlung auffordert. Eine solche Aufforderung darf nicht allein deshalb verbindlich werden, weil der Agent sie gerade eingelesen hat.

↑ Nach oben

Der Git-Arbeitsbaum gehört auch zur Qualitätssicherung

Es gibt noch eine recht bodenständige Frage: Was hinterlässt ein automatischer Prüflauf?

Build-Verzeichnisse, Coverage-Berichte, temporäre Dateien und riesige Logs sind für sich genommen nichts Ungewöhnliches. Ein Agent kann davon aber erstaunlich viel erzeugen, wenn niemand vorher festlegt, wo die Ausgaben landen und wann Schluss ist.

Ich halte deshalb ein paar einfache Regeln für sinnvoll: Ausgabepfade vor dem Lauf festlegen, Dateianzahl und Datenmenge begrenzen, Timeouts definieren und temporäre Artefakte möglichst außerhalb des versionierten Repositories ablegen. Nach einem Abbruch muss klar sein, welche Dateien zurückbleiben und wer sie entfernt.

Das ist weniger spektakulär als die nächste Agenten-Demo. Im Alltag aber deutlich hilfreicher als ein Git-Arbeitsbaum mit ein paar Tausend neuen Dateien, von denen niemand so recht weiß, woher sie kommen.

Auch Protokolle verdienen Aufmerksamkeit. Ein vollständiger Konsolenauszug kann sensible Pfade, Tokens oder vertrauliche Quelltextfragmente enthalten. Nicht jede Information, die ein Werkzeug ausgeben kann, muss ungefiltert an das Sprachmodell oder in ein dauerhaftes Log gelangen.

↑ Nach oben

Was MCP an Softwarequalität tatsächlich verbessern kann

Die Stärke von MCP liegt für mich nicht darin, dass ein Agent damit plötzlich besseren Code schreibt. Sie liegt darin, bewährte Prüfwerkzeuge über definierte Schnittstellen in den Entwicklungsablauf einzubinden.

Ein Compiler bleibt ein Compiler. Ein statischer Analysator bleibt ein statischer Analysator. Auch Coverage-Messung und Dokumentationsgeneratoren werden durch eine MCP-Anbindung nicht intelligenter.

Aber ihre Ergebnisse können einem Agenten in einer konsistenten Form zugänglich werden. Der Agent kann auf einen fehlgeschlagenen Test reagieren, eine Diagnose mit einer Codeänderung verbinden und eine Prüfung erneut anstoßen. Wenn dabei Projektstand, Eingaben und Resultate nachvollziehbar bleiben, entsteht ein überprüfbarer Arbeitsablauf statt einer Folge überzeugend formulierter Behauptungen.

Mit meinem Projekt SWDEV beschäftige ich mich praktisch mit dieser Verbindung aus Coding-Agenten und Entwicklungswerkzeugen. Die Details der Umsetzung gehören allerdings in die Projektbeschreibung. Hier ist mir das allgemeinere Prinzip wichtiger.

Ich möchte nicht einfach wissen, dass ein Agent „fertig“ sagt. Ich möchte sehen können, was er getan hat und wie weit ich dem Ergebnis vertrauen kann.

↑ Nach oben