---
title: "Google ADK 2026: Produktionsreife KI-Agenten mit dem Agent Development Kit bauen"
description: "Ein praxisnaher Blick auf Googles Agent Development Kit (ADK) in 2026: was es ist, wie man einen echten produktionsreifen Agenten baut, der Vergleich mit LangGraph und CrewAI, und was sich auf Gemini Enterprise ändert."
author: Aleksei Aleinikov
date: 2026-06-27
lang: de
tags: [ai-agents, google-adk, llm, python, gcp, ai]
canonical: https://www.alekseialeinikov.com/de/blog/topics/cloud/google-adk-produktionsreife-ki-agenten-bauen-2026
source: alekseialeinikov.com
---

# Google ADK 2026: Produktionsreife KI-Agenten mit dem Agent Development Kit bauen

2026 liefert jeder „KI-Agenten" aus. Die meisten davon sind ein einzelner Prompt in einer `while`-Schleife mit einem fragilen JSON-Parser, der seitlich drangeklebt ist.

Ein echter Agent ist etwas anderes. Er plant, ruft Tools auf, erholt sich von fehlerhaften Tool-Ergebnissen und bleibt beobachtbar, wenn nachts um 3 Uhr in Produktion etwas schiefgeht. Genau diese Lücke — zwischen einer Demo und einem System, das man tatsächlich betreiben kann — soll Googles **Agent Development Kit (ADK)** schließen.

Ich habe kürzlich den **Gemini Enterprise Certified Partner Specialist**-Track abgeschlossen, und das Nützlichste daran war kein Badge. Es war ein deutlich klareres mentales Modell davon, wie Google Agenten gebaut sehen will — und wo ADK das Framework, das Sie heute wahrscheinlich nutzen, wirklich schlägt.

Das hier ist die Praxis-Version. Keine Marketing-Folien. Nur: was ADK ist, wie man damit einen echten Agenten baut und wie es gegen **LangGraph** und **CrewAI** abschneidet.

## Was das Agent Development Kit wirklich ist

ADK ist ein Open-Source-Framework, um KI-Agenten zu bauen, zu evaluieren und auszuliefern — dasselbe Toolkit, das Google intern für Produkte wie Agentspace verwendet. Es ist modell-agnostisch (Gemini zuerst, aber andere Modelle lassen sich anbinden) und läuft überall: auf Ihrem Laptop, auf Cloud Run oder in **Gemini Enterprise**.

Das mentale Modell ist klein und lohnt sich einzuprägen:

- **Agent** — ein LLM plus Anweisungen plus eine Menge Tools. Die Einheit, aus der Sie alles zusammensetzen.
- **Tool** — eine ganz normale Funktion, die der Agent aufrufen kann. ADK liest Ihre Funktionssignatur und den Docstring und baut das Schema automatisch.
- **Runner** — die Ausführungsschleife, die den Agenten antreibt: Modell promten, Tools aufrufen, Ergebnisse zurückführen, wiederholen, bis fertig.
- **Session** — der Speicher und Zustand, der über mehrere Turns hinweg bestehen bleibt.

Das ist der gesamte Kern. Alles andere — Multi-Agent-Orchestrierung, Evaluierung, Deployment — baut auf diesen vier Bausteinen auf.

## Einen echten Agenten in rund 30 Zeilen bauen

Hier ist ein funktionierender Agent, der etwas Sinnvolles tut: Er beantwortet Fragen zu einer Bestellung, indem er ein echtes Tool aufruft. Beachten Sie, dass das Tool einfach eine normale Python-Funktion mit klarem Docstring ist — ADK macht daraus für Sie ein aufrufbares Schema.

```python
from google.adk.agents import Agent

def get_order_status(order_id: str) -> dict:
    """Liefert den Lieferstatus einer Kundenbestellung.

    Args:
        order_id: Die kundenseitige Bestellnummer, z. B. "A-10423".
    """
    # In Produktion würde das Ihre Bestell-API aufrufen.
    orders = {"A-10423": {"status": "versendet", "eta": "2026-06-29"}}
    return orders.get(order_id, {"status": "unbekannt"})

root_agent = Agent(
    name="support_agent",
    model="gemini-2.5-flash",
    instruction=(
        "Du bist ein knapper Kundensupport-Agent. "
        "Wenn ein Nutzer nach einer Bestellung fragt, rufe get_order_status auf "
        "und antworte in einem Satz. Erfinde niemals einen Bestellstatus."
    ),
    tools=[get_order_status],
)
```

Starten Sie ihn lokal mit der ADK-Dev-UI und Sie bekommen ein Chat-Fenster, einen Live-Trace jedes Tool-Aufrufs und die rohe Modell-Argumentation — ganz ohne eine einzige Zeile Frontend-Code:

```bash
pip install google-adk
adk web
```

In dem Moment, in dem das Trace-Panel zum ersten Mal *Nutzer → Modell → Tool-Aufruf → Tool-Ergebnis → Modell → Antwort* zeigt, fällt der Groschen. Sie raten nicht, was der Agent getan hat. Sie sehen es.

## Wo ADK vorbeizieht: Tools, Eval und Deployment

Drei Dinge unterscheiden ADK von einer selbstgebauten Agenten-Schleife.

**Tools sind First-Class und typisiert.** Ihre Funktionssignatur *ist* der Vertrag. Keine handgeschriebenen JSON-Schemas, die sich vom Code wegbewegen. ADK bringt außerdem fertige Tools mit (Suche, Code-Ausführung) und kann andere Agenten als Tools kapseln — so komponieren Sie Spezialisten.

**Evaluierung ist eingebaut, nicht nachträglich drangeschraubt.** Mit ADK definieren Sie Testfälle — eine Eingabe plus die erwartete Tool-Abfolge und die erwartete finale Antwort — und führen sie als Suite aus. Genau diesen Teil überspringen die meisten Teams und bereuen es später. Ein Agent, der letzte Woche funktionierte, bricht still, wenn Sie einen Prompt ändern; eine Eval-Suite fängt das ab, bevor Ihre Nutzer es tun.

```python
# tests/order.evalset.json treibt `adk eval` an — prüfen Sie, dass der Agent
# get_order_status wirklich aufruft, nicht nur, dass der Text "richtig aussieht".
```

**Deployment ist ein kurzer Sprung, kein Neuschreiben.** Derselbe Agent läuft lokal, auf Cloud Run oder auf der vollständig verwalteten Vertex AI Agent Engine. Wenn Sie zu **Gemini Enterprise** wechseln, erben Sie Identität, Datenquellen-Konnektoren und Skalierung, ohne den Agenten selbst neu zu bauen.

## ADK vs. LangGraph vs. CrewAI

Der ehrliche Vergleich, den die meisten „Agent-Framework"-Beiträge vermeiden. Keines davon ist pauschal das Beste — sie optimieren für Unterschiedliches.

| Dimension | Google ADK | LangGraph | CrewAI |
|---|---|---|---|
| Kernmodell | Agenten + Tools + Runner | Expliziter State-Graph | Rollenspiel-„Crew" aus Agenten |
| Stärke | Produktive Agenten auf Google Cloud | Feingranulare Ablaufsteuerung | Schnelle Multi-Agent-Prototypen |
| Tool-Definition | Python-Funktion + Docstring | Manuelles Tool-/Schema-Wiring | Funktions- oder Klassen-Tools |
| Eingebaute Evaluierung | Ja (`adk eval`) | Nein (selbst mitbringen) | Begrenzt |
| Lokale Entwicklung | `adk web`-UI mit Live-Traces | Code + LangSmith (kostenpflichtig) | CLI / Code |
| Verwaltetes Deployment | Vertex AI Agent Engine | DIY / LangGraph Platform | DIY |
| Lock-in-Risiko | Gering (Open Source, modell-agnostisch) | Gering | Gering |
| Idealfall | Auf GCP ausliefern und betreiben | Komplexe, verzweigte Workflows | Heute noch eine Multi-Agent-Demo |

Kurzfassung: Greifen Sie zu **LangGraph**, wenn Ihr Problem in Wahrheit eine Zustandsmaschine mit kniffligen Verzweigungen ist. Greifen Sie zu **CrewAI**, wenn Sie bis zum Mittagessen eine Multi-Agent-Demo wollen. Greifen Sie zu **ADK**, wenn der Agent *in Produktion leben* muss — auf Google Cloud, mit Evaluierung, Tracing und einer verwalteten Laufzeit, die Sie nicht selbst pflegen.

## Von einem Agenten zum Team

Einzelne Agenten sind der Anfang. Die interessanten Systeme sind Multi-Agent: ein Koordinator, der an Spezialisten delegiert. ADK modelliert das direkt — ein Agent kann Sub-Agenten haben und leitet Arbeit anhand ihrer Beschreibungen weiter.

```python
from google.adk.agents import Agent

billing = Agent(name="billing", model="gemini-2.5-flash",
                instruction="Beantworte Fragen zu Abrechnung und Erstattungen.")
shipping = Agent(name="shipping", model="gemini-2.5-flash",
                 instruction="Beantworte Fragen zu Lieferung und Tracking.")

coordinator = Agent(
    name="coordinator",
    model="gemini-2.5-pro",
    instruction="Leite jede Anfrage an den richtigen Spezialisten und fasse die Antwort zusammen.",
    sub_agents=[billing, shipping],
)
```

Der Koordinator nutzt ein stärkeres Modell, um über das Routing nachzudenken; die Spezialisten nutzen ein günstigeres, schnelleres Modell für die enge Aufgabe. Diese Aufteilung — schlauer Router, günstige Arbeiter — ist eines der wirksamsten Kostenmuster in produktiven Agenten-Systemen, und ADK macht daraus ein paar Zeilen statt eines Frameworks.

## Der Gemini-Enterprise-Aspekt

Den Agenten zu bauen ist die halbe Geschichte. Die andere Hälfte ist alles drumherum: ihn an echte Unternehmensdaten anbinden (Workspace, Datenbanken, Drittanbieter-Apps), ihm eine Identität geben und ihn auf echte Nutzer skalieren. Genau das fügt die **Gemini-Enterprise**-Plattform über ADK hinzu — der Agent, den Sie lokal gebaut haben, ist derselbe Agent, der dort läuft, nur mit Enterprise-Konnektoren und Governance drumherum.

Diese Kontinuität ist das eigentliche Verkaufsargument. Sie prototypisieren nicht in einem Tool und bauen in einem anderen neu. Der 30-Zeilen-Agent oben ist strukturell dasselbe, das Sie an Tausende Nutzer ausliefern.

## Fazit

Das **Agent Development Kit** ist Googles Antwort auf ein echtes Problem: Die meisten „Agenten" sind Demos, und Demos überleben die Produktion nicht. ADK gibt Ihnen vier saubere Primitive — Agent, Tool, Runner, Session — typisierte Tools, eine eingebaute Eval-Suite, Live-Tracing lokal und einen kurzen Weg vom Laptop zu einer verwalteten Laufzeit auf **Gemini Enterprise**.

Wenn Sie 2026 ein Framework wählen: **CrewAI** bringt Sie am schnellsten zur Demo, **LangGraph** gibt Ihnen die meiste Kontrolle über komplexe Abläufe, und **ADK** ist das, was für den Produktionsbetrieb auf Google Cloud gebaut ist. Wählen Sie danach, wo der Agent *leben* muss, nicht nur, wo er geboren wird.

Wenn Sie Agenten bauen — oder den Gemini-Enterprise-Track selbst durcharbeiten — [melden Sie sich](https://www.alekseialeinikov.com/de/contact). Ich teile, was ich baue, unter #GoogleCloud, #GoogleCloudPartners und #GoogleCloudAmbassador.
