Google Agent Smith schreibt 25% des Google-Codes: Was API-Teams wissen sollten

Kurz gesagt (TL;DR)

Googles interner KI-Code-Agent, Agent Smith, generiert jetzt über 25 % des neuen Produktionscodes des Unternehmens. Im Gegensatz zu Autovervollständigungs-Tools wie Copilot arbeitet Agent Smith asynchron im Hintergrund, schreibt, testet und iteriert Code ohne menschliche Interaktion. Für API-Teams wirft dies Fragen zur Vertragsstabilität, Testabdeckung, Dokumentationsdrift und Überprüfungsabläufen auf, wenn ein Viertel Ihrer Codebasis maschinell generiert wird.

Einleitung

Während einer Telefonkonferenz zu den Geschäftsergebnissen im März 2026 nannte Google-CEO Sundar Pichai eine Zahl, die die gesamte Softwareindustrie innehalten ließ: KI-generierter Code macht mittlerweile mehr als 25 % des neu produzierten Codes bei Google aus.

Das ist keine Autovervollständigung. Das sind keine Copilot-Vorschläge, die von Entwicklern angenommen wurden. Dies ist Code, der nach der KI-Generierung in der Produktion eingesetzt wird. Das dahinterstehende Tool, intern Agent Smith genannt (eine Anspielung auf den sich selbst replizierenden Antagonisten aus The Matrix), wurde bei Googles über 180.000 Mitarbeitern so beliebt, dass das Unternehmen den Zugriff drosseln musste, um die Infrastrukturbelastung zu bewältigen.

Agent Smith stellt eine andere Kategorie dar als die KI-Codierungstools, die die meisten Entwickler heute verwenden. Wo Copilot und Claude Code in Echtzeit assistieren, arbeitet Agent Smith im Hintergrund. Ingenieure weisen Aufgaben zu, gehen weg und kehren später zurück, um die fertige Arbeit zu überprüfen.

Für API-Entwicklungsteams wirft dieser Wandel von „KI-unterstütztem“ zu „KI-generiertem“ Code praktische Fragen auf. Wenn 25 % Ihrer Codebasis von einem autonomen Agenten geschrieben werden, wie halten Sie API-Verträge stabil? Wie stellen Sie sicher, dass Tests maschinell generierte Endpunkte abdecken? Wie verhindern Sie, dass die Dokumentation abweicht?

Dieser Artikel beleuchtet, was Agent Smith tut, wie er sich von anderen KI-Codierungstools unterscheidet und worauf sich API-Teams vorbereiten sollten.

Was Agent Smith tut

Asynchrones autonomes Codieren

Agent Smith sitzt nicht in Ihrer IDE und wartet darauf, dass Sie tippen. Er arbeitet asynchron im Hintergrund. Hier ist der Arbeitsablauf:

1. Ein Ingenieur beschreibt eine Aufgabe in natürlicher Sprache
2. Agent Smith zerlegt die Aufgabe in Unteraufgaben
3. Er schreibt Code über mehrere Dateien hinweg
4. Er führt Tests durch und iteriert bei Fehlern
5. Der Ingenieur überprüft die fertige Arbeit

Dies unterscheidet sich grundlegend von den Inline-Vorschlägen von Copilot oder den interaktiven Sitzungen von Claude Code. Agent Smith ist eher wie ein Junior-Entwickler, der ein Ticket annimmt, für ein paar Stunden verschwindet und mit einem Pull Request zurückkommt.

Ingenieure können Aufgaben delegieren und den Fortschritt über Googles interne Chat-Plattform verfolgen, sogar von mobilen Geräten aus. Das Tool greift automatisch auf Mitarbeiterprofile und relevante Dokumentation zu und zieht Kontext aus Googles interner Wissensdatenbank.

Auf Gemini und Antigravity aufgebaut

Agent Smith läuft auf Googles Gemini-Modellfamilie, ergänzt durch Abfragesysteme, die ihm Zugriff auf Googles riesige interne Codebasis und Dokumentation ermöglichen. Es basiert auf Antigravity, Googles bestehender agentenbasierter Codierungsplattform, erweitert diese jedoch um autonome Aufgabenzerlegung und -ausführung.

Die Retrieval Augmentation ist entscheidend. Agent Smith generiert Code nicht isoliert. Er durchsucht Googles interne Codebasis nach ähnlichen Mustern, referenziert bestehende Implementierungen und folgt internen Codierungskonventionen. Dieses Kontextbewusstsein ermöglicht eine produktionsreife Ausgabe in einem Umfang von 25 %.

Was „25 % neuer Code“ bedeutet

Pichais Zahl bedarf des Kontextes. „25 % neuer Code“ bezieht sich auf Code, der:

• Von KI generiert wird, nicht automatisch vervollständigt
• Die Code-Überprüfung besteht (menschliche Ingenieure überprüfen weiterhin die Ausgabe von Agent Smith)
• In Produktionssystemen ausgeliefert wird
• Über die gesamte Engineering-Leistung von Google gemessen wird

Dies bedeutet nicht, dass 25 % der gesamten Google-Codebasis KI-generiert sind. Es bedeutet, dass 25 % des heute neu geschriebenen Codes von Agent Smith stammen. Die Unterscheidung ist wichtig, da neuer Code zu einer bestehenden, von Menschen geschriebenen Codebasis hinzukommt. Aber die Entwicklung ist klar: Der Prozentsatz wächst, und Pichai hob dies als strategischen Vorteil hervor.

Wie sich Agent Smith von anderen KI-Codierungstools unterscheidet

Das Spektrum der KI-Codierungstools

Agent Smith befindet sich am autonomen Ende dieses Spektrums. Der einzige weitere Schritt wäre eine vollständig autonome Bereitstellung ohne menschliche Überprüfung, was noch kein großes Tool tut (und auch nicht sollte).

Warum Asynchronität für API-Teams wichtig ist

Echtzeit-KI-Codierungstools (Copilot, Claude Code) arbeiten im Fluss des Entwicklers. Der Entwickler sieht, was die KI schreibt, versteht den Kontext und nimmt sofort Korrekturen vor.

Asynchrone Agenten ändern diese Dynamik. Wenn Agent Smith einen API-Endpunkt schreibt, überprüft der Entwickler ihn nachträglich. Die Überprüfung ist vom Erstellungskontext getrennt. Das bedeutet:

• Der Entwickler versteht möglicherweise nicht, warum der Agent ein bestimmtes Antwortformat gewählt hat
• API-Vertragsänderungen sind in einer Standard-Code-Überprüfung möglicherweise nicht offensichtlich
• Zugehörige Artefakte (Tests, Dokumente, Mocks) wurden möglicherweise nicht aktualisiert
• Brechende Änderungen könnten durchrutschen, wenn der Prüfer nicht die vollen Auswirkungen überprüft

Was kaputt geht, wenn KI Ihren API-Code schreibt

API-Vertragsdrift

Ein API-Vertrag ist die Vereinbarung zwischen Ihrem Dienst und seinen Konsumenten: Endpunkte, Anfrage-/Antwortschemata, Statuscodes, Fehlerformate. Wenn ein menschlicher Entwickler eine API ändert, aktualisiert er typischerweise die OpenAPI-Spezifikation, benachrichtigt Konsumenten und versioniert die Änderung.

Wenn ein autonomer Agent eine API ändert, erfolgen diese Koordinierungsschritte nicht automatisch. Agent Smith schreibt Code, der Tests besteht. Aber Tests decken nur das ab, was zuvor geschrieben wurde. Wenn der Agent ein Antwortschema so ändert, dass es bestehende Tests besteht, aber nachgeschaltete Konsumenten bricht, zeigt sich der Bruch in der Produktion.

Beispielszenario:

• Agent Smith wird mit der Aufgabe „Benutzereinstellungen zum Profil-Endpunkt hinzufügen“ betraut
• Er fügt ein Feld preferences zur GET /api/users/{id}-Antwort hinzu
• Bestehende Tests bestehen, da sie das Fehlen zusätzlicher Felder nicht überprüfen
• Die TypeScript-Typen des Frontend-Teams enthalten preferences nicht
• Die strikte JSON-Analyse der mobilen App wirft einen Fehler beim unerwarteten Feld

Der Code ist korrekt. Die Tests bestehen. Der Vertrag ist gebrochen.

Lücken in der Testabdeckung

KI-generierter Code kommt mit KI-generierten Tests, und KI-Agenten neigen dazu, Tests zu schreiben, die das Validieren, was sie gebaut haben, nicht aber Tests, die vor Regressionen schützen. Dies schafft einen blinden Fleck: Die Tests bestätigen, dass das neue Verhalten funktioniert, aber sie bestätigen nicht, dass das bestehende Verhalten beibehalten wird.

Für API-Endpunkte bedeutet dies:

• Antwortzeit-Benchmarks werden möglicherweise nicht getestet
• Fehlerantwortformate können von Ihrem Standard-Fehlerschema abweichen
• Verhalten der Ratenbegrenzung wird möglicherweise nicht validiert
• Authentifizierungs-Edge-Cases werden möglicherweise nicht abgedeckt
• Paginierungsverhalten kann von bestehenden Endpunkten abweichen

Dokumentationsdrift

Wenn Ihre API-Dokumentation aus Code-Annotationen oder OpenAPI-Spezifikationen generiert wird, sollten agentengeänderte Code-Änderungen automatisch in die Dokumentation übertragen werden. Viele Teams pflegen die Dokumentation jedoch separat. Wenn Agent Smith einen Endpunkt hinzufügt oder ein Antwortschema ändert, ist die Dokumentationsaktualisierung eine separate Aufgabe, die der Agent möglicherweise nicht ausführt.

Selbst bei automatisch generierten Dokumenten erfordern die Beschreibungen, Beispiele und Nutzungshinweise menschlichen Kontext, den ein KI-Agent nicht hat. Der Agent kann dokumentieren, was ein Endpunkt tut. Er kann nicht dokumentieren, warum er existiert, wer ihn nutzt oder welche Kompromisse zu seinem Design geführt haben.

Überprüfungsmüdigkeit

Wenn 25 % des Codes KI-generiert sind, überprüfen 25 % der Code-Reviews KI-Outputs. KI-generierter Code ist syntaktisch konsistent und gut strukturiert, was ihn auf den ersten Blick „in Ordnung“ erscheinen lässt. Aber „in Ordnung“ auszusehen ist nicht dasselbe wie im Kontext korrekt zu sein.

Prüfer stehen vor einer neuen Herausforderung: Der Code liest sich gut, stimmt aber möglicherweise nicht mit architektonischen Entscheidungen, Teamkonventionen oder unausgesprochenen Anforderungen überein, die im Kopf des Prüfers existieren, aber nicht in der Aufforderung des Agenten. Mit der Zeit kann die Überprüfungsmüdigkeit bei KI-generiertem Code zu einer bloßen Absegnung führen, was der Punkt ist, an dem Fehler ausgeliefert werden.

Wie man agentensichere API-Workflows erstellt

1. API-Verträge zur einzigen Wahrheitsquelle machen

Design-first API-Entwicklung ist die stärkste Verteidigung gegen agenteninduzierte Drift. Wenn die OpenAPI-Spezifikation die einzige Wahrheitsquelle ist, ist jede Codeänderung, die den Vertrag bricht, erkennbar.

Ohne Design-first:

Code-Änderung → Tests bestehen → Bereitstellung → Vertrag gebrochen

Mit Design-first:

Spezifikation definiert Vertrag → Code muss der Spezifikation entsprechen → Vertragsvalidierung fängt Drift ab

Der visuelle API-Designer von Apidog ermöglicht es Ihnen, Endpunkte, Schemata und Antwortformate zu definieren, bevor Code geschrieben wird. Wenn Agent Smith (oder ein anderer Agent) Code generiert, validieren Sie ihn gegen die Spezifikation, nicht gegen bestehende Tests, die möglicherweise unvollständig sind.

2. Vertragstests statt Unit-Tests verwenden

Unit-Tests validieren internes Verhalten. Vertragstests validieren die Vereinbarung zwischen Diensten. Wenn ein KI-Agent Ihre API ändert, fangen Vertragstests Änderungen ab, die Unit-Tests übersehen.

Beispiel für einen Vertragstest:

// Dieser Test schlägt fehl, wenn sich die Antwortform ändert,
// auch wenn die neue Form „gültig“ ist
describe("GET /api/users/:id contract", () => {
  it("returns expected schema", async () => {
    const response = await request(app).get("/api/users/123");

    expect(response.body).toMatchSchema({
      type: "object",
      required: ["id", "name", "email", "created_at"],
      properties: {
        id: { type: "string" },
        name: { type: "string" },
        email: { type: "string", format: "email" },
        created_at: { type: "string", format: "date-time" }
      },
      additionalProperties: false  // Dies fängt unerwartete Felder ab
    });
  });
});

Die Zeile additionalProperties: false ist entscheidend. Ohne sie würde ein Agent, der Felder zur Antwort hinzufügt, alle Tests bestehen. Mit ihr erfordert jede Schemaänderung explizite Vertragsaktualisierungen.

Apidog automatisiert Vertragstests anhand Ihrer API-Spezifikation. Definieren Sie Ihr Schema einmal, und Apidog validiert jede Antwort dagegen sowohl bei manuellen Tests als auch bei CI/CD-Läufen.

3. Bereitstellungen an Spezifikationsvalidierung koppeln

Fügen Sie die API-Spezifikationsvalidierung Ihrer CI/CD-Pipeline hinzu. Bevor Code (menschlich oder KI-generiert) bereitgestellt wird, vergewissern Sie sich, dass er dem deklarierten Vertrag entspricht:

# CI/CD-Pipeline-Schritt
- name: API-Vertrag validieren
  run: |
    # Vergleichen Sie die aktuelle Spezifikation mit der laufenden Implementierung
    apidog run --test-scenario-id VERTRAGSTESTS
    
    # Fehlschlag, wenn Vertragsverletzungen gefunden wurden
    if [ $? -ne 0 ]; then
      echo "API-Vertragsverletzung erkannt. Änderungen überprüfen."
      exit 1
    fi

Dies fängt Agent Smiths vertragsbrüchige Änderungen ab, bevor sie die Produktion erreichen.

4. Spezifikationsaktualisierungen für API-Änderungen vorschreiben

Erstellen Sie eine Entwicklungsregel: Jeder PR, der das API-Verhalten ändert, muss eine entsprechende OpenAPI-Spezifikationsaktualisierung enthalten. Für KI-generierte PRs bedeutet dies, dass der Agent die Spezifikation aktualisieren muss, oder ein Mensch muss dies vor dem Mergen tun.

In Apidog werden Spezifikationsänderungen automatisch übertragen auf:

• API-Dokumentation
• Mock-Server-Antworten
• Test-Assertions
• Client-SDK-Typen

Diese Kaskade stellt sicher, dass kein Artefakt abweicht, wenn sich der Vertrag ändert.

5. API-Verhalten in der Produktion überwachen

Selbst mit Vertragstests und Spezifikationsvalidierung fängt die Produktionsüberwachung das auf, was Pre-Production-Tests übersehen. Verfolgen Sie:

• Verletzungen des Antwortschemas: Protokollieren, wenn Antworten nicht dem deklarierten Schema entsprechen
• Neue Felder erscheinen: Warnung bei Antwortfeldern, die nicht in der Spezifikation enthalten sind
• Änderungen der Fehlerrate: KI-generierte Endpunkte können unterschiedliche Fehlerverteilungen aufweisen
• Latenzverschiebungen: Von Agenten geschriebener Code kann unterschiedliche Leistungsmerkmale aufweisen
• Änderungen des Verkehrsverhaltens: Neue Endpunkte können unerwartete Verkehrsmuster erhalten

6. API-Überprüfung von Code-Überprüfung trennen

Eine Standard-Codeüberprüfung fragt: „Funktioniert dieser Code?“ Eine API-Überprüfung fragt: „Betrifft diese Änderung die Konsumenten?“

Erstellen Sie für KI-generierte API-Änderungen eine separate Prüfliste:

• Bricht diese Änderung bestehende Konsumenten?
• Ist die OpenAPI-Spezifikation aktualisiert?
• Sind abwärtsinkompatible Änderungen versioniert?
• Sind Fehlerantworten konsistent mit dem vorhandenen Fehlerformat?
• Sind neue Endpunkte mit Beispielen dokumentiert?
• Wurden nachgeschaltete Teams benachrichtigt?

Die Entwicklung: Wohin geht die autonome Codierung?

Agent Smith heute vs. morgen

Agent Smith bei 25 % ist der Ausgangspunkt. Sergey Brin bezeichnete KI-Agenten während einer Verkaufs-Townhall im März 2026 als „großen Fokus“. Die 25 %-Zahl wird steigen, wenn das Tool verbessert wird, Zugangsbeschränkungen gelockert werden und Arbeitsabläufe angepasst werden.

Andere Unternehmen entwickeln ähnliche Systeme:

• Claude Codes KAIROS (durchgesickert im Quellcode): immer aktiver Daemon mit GitHub-Webhook-Abonnements und Hintergrund-Workern
• GitHub Copilot Agent Mode: mehrstufige Codierungsaufgaben mit autonomer Dateibearbeitung
• Amazons CodeWhisperer: Ausweitung von der Autovervollständigung hin zu agentengesteuerten Workflows

Der Branchentrend ist klar: KI-Codierungstools entwickeln sich vom „Assistenten“ zum „autonomen Mitwirkenden“ zur „Hintergrundinfrastruktur“. Innerhalb weniger Jahre wird die Frage nicht mehr sein, ob KI Ihren API-Code schreibt, sondern wie viel davon.

Worauf sich API-Teams jetzt vorbereiten sollten

Design-First ist keine Option mehr, sondern ein Muss. Wenn Agenten Code schreiben, ist die API-Spezifikation das einzige stabile Artefakt. Machen Sie sie jetzt zur Quelle der Wahrheit, bevor die Einführung von Agenten dies dringend erforderlich macht.

Investieren Sie in die Infrastruktur für Vertragstests. Unit-Tests reichen nicht aus, wenn der Code-Autor Ihre ungeschriebenen Konventionen nicht versteht. Vertragstests kodieren diese Konventionen explizit.

Wählen Sie Tools, die Artefakte synchron halten. Getrennte Tools (separater API-Client, separater Test-Runner, separater Mock-Server, separater Dokumentationsgenerator) schaffen Möglichkeiten für Drift, die Agenten ausnutzen. Integrierte Plattformen wie Apidog halten alles synchron.

Erstellen Sie Überprüfungsprozesse für KI-generierten Code. Die standardmäßige Codeüberprüfung erfasst keine API-Vertragsverletzungen. Erstellen Sie Checklisten und automatisierte Validierungen speziell für API-Änderungen.

Probieren Sie Apidog kostenlos aus, um API-Workflows zu erstellen, die konsistent bleiben, egal ob Ihre nächste Codeänderung von einem menschlichen Entwickler, Agent Smith oder einem anderen autonomen Codierungstool stammt.

FAQ

Was ist Google Agent Smith?

Agent Smith ist Googles interner KI-Codierungsagent, der auf der Gemini-Modellfamilie und der Antigravity-Plattform basiert. Er arbeitet asynchron im Hintergrund: Ingenieure weisen Aufgaben zu, und Agent Smith schreibt, testet und iteriert Code ohne Echtzeit-Interaktion mit Menschen. Ab März 2026 generierte er über 25 % des neuen Produktionscodes von Google.

Ist Agent Smith außerhalb von Google verfügbar?

Nein. Agent Smith ist ein internes Tool, das auf Google-Mitarbeiter beschränkt ist. Google hat keine Pläne für eine öffentliche Veröffentlichung angekündigt. Die Technologie ähnelt dem Copilot Agent Mode und Claude Code, ist aber tiefer in Googles interne Codebasis und Dokumentationssysteme integriert.

Bricht KI-generierter Code API-Verträge?

Das kann er. KI-Agenten schreiben Code, der Tests besteht, aber Tests decken möglicherweise nicht alle Aspekte Ihres API-Vertrags ab. Schemaänderungen, neue Antwortfelder, unterschiedliche Fehlerformate und Verhaltensmodifikationen können die Tests durchrutschen und gleichzeitig nachgelagerte Konsumenten brechen. Vertragstests und Design-First-Entwicklung verhindern dies.

Sollten API-Teams sich um Agent Smith sorgen?

Nicht speziell um Agent Smith, da er Google-intern ist. Aber um den Trend, den er repräsentiert, ja. Ähnliche autonome Codierungstools (Copilot Agent Mode, KAIROS und andere) werden Ihr Team erreichen. Wenn Sie Ihre API-Workflows jetzt mit Design-First-Entwicklung, Vertragstests und integrierten Tools vorbereiten, sind Sie in der Lage, autonome Agenten sicher einzusetzen.

Wie verhindere ich, dass KI-Agenten meine APIs beschädigen?

Verwenden Sie eine Design-First-Entwicklung, bei der die OpenAPI-Spezifikation die einzige Wahrheitsquelle ist. Fügen Sie Vertragstests mit additionalProperties: false hinzu, um unerwartete Schemaänderungen abzufangen. Verriegeln Sie Bereitstellungen bei der Spezifikationsvalidierung. Verwenden Sie eine integrierte Plattform wie Apidog, die Spezifikationen, Tests, Mocks und Dokumente automatisch synchronisiert.

Was ist der Unterschied zwischen KI-unterstütztem und KI-generiertem Code?

KI-unterstützter Code (Copilot-Vorschläge, Claude-Code-Sitzungen) wird in Echtzeit mit menschlicher Aufsicht geschrieben. Der Entwickler sieht und genehmigt jede Änderung. KI-generierter Code (Agent Smith) wird asynchron ohne menschliche Echtzeit-Beteiligung erstellt. Der Entwickler überprüft die abgeschlossene Arbeit nachträglich. Dieser Unterschied verändert die Dynamik der Überprüfung und erhöht das Risiko unerkannter Vertragsverletzungen.

Werden KI-Agenten API-Entwickler ersetzen?

Nein. Agent Smith erfordert immer noch eine menschliche Aufgabenbeschreibung, Code-Überprüfung und Bereitstellungsgenehmigung. Eine MIT-Studie vom März 2026 bestätigte, dass KI die Produktivität von Entwicklern steigert, aber nicht das Urteilsvermögen, das Kontextbewusstsein und das architektonische Denken ersetzt, die Menschen bieten. Die Rolle verlagert sich vom Schreiben von Code auf das Definieren von Aufgaben, das Überprüfen der Ausgabe und das Aufrechterhalten der Systemkohärenz.

Wichtigste Erkenntnisse

• Googles Agent Smith generiert 25 % des neuen Produktionscodes durch asynchronen, autonomen Betrieb
• Dies stellt eine Verschiebung von KI-unterstütztem zu KI-generiertem Code dar, die die Überprüfungsdynamik für API-Teams verändert
• API-Vertragsdrift ist das Hauptrisiko, wenn autonome Agenten Endpunkte und Schemata ändern
• Design-First-Entwicklung mit OpenAPI-Spezifikationen als einziger Wahrheitsquelle verhindert Vertragsbrüche
• Vertragstests mit strenger Schema-Validierung fangen Änderungen ab, die Unit-Tests übersehen
• Integrierte Plattformen wie Apidog synchronisieren Spezifikationen, Tests, Mocks und Dokumente, um Drift zu verhindern
• Der Trend zu autonomen Codierungsagenten beschleunigt sich; bereiten Sie Ihre API-Workflows jetzt vor

Agent Smith bei 25 % ist der Anfang. Die Unternehmen, die heute agentensichere API-Workflows aufbauen, werden morgen in der Lage sein, autonome Codierungstools sicher einzusetzen.