Google ADK (Agent Development Kit) es el framework de código abierto con el que Google quiere que construyas tus propios agentes de IA, del mismo modo que los construye internamente para productos como Agentspace. Es code-first, funciona con Gemini y con casi cualquier modelo, y te lleva desde un agente de diez líneas hasta un servicio desplegado en Vertex AI sin cambiar de herramienta. Esta guía explica qué es, cómo montar tu primer agente y cuándo elegirlo frente al Agents SDK de OpenAI. La misma explicación está disponible en inglés.

Puntos clave

  • ADK es un kit de código abierto (licencia Apache-2.0) para construir, evaluar y desplegar agentes; su repositorio google/adk-python supera las 20.000 estrellas en GitHub y su versión 2.5.0 es del 16 de julio de 2026.
  • Se anunció en Google Cloud Next 2025 y tiene SDKs oficiales para Python, Java, Go, TypeScript y Kotlin, con una interfaz de desarrollo (adk web) común a todos.
  • Ofrece dos familias de agentes: los LlmAgent, que razonan, y los agentes de flujo (SequentialAgent, ParallelAgent, LoopAgent), que orquestan pasos de forma determinista.
  • Es agnóstico respecto al modelo: usa Gemini de forma nativa y conecta con Claude, GPT u Ollama en tu propio equipo a través de LiteLLM.
  • Despliega el mismo agente en Vertex AI Agent Engine, en Cloud Run o en un contenedor propio, con trazas en Cloud Trace.

¿Qué es el Agent Development Kit?

El Agent Development Kit es una biblioteca que Google publicó para que cualquiera construya agentes de IA con el mismo enfoque que usa la propia empresa. La documentación oficial lo define como «un kit de código abierto, code-first, para construir, evaluar y desplegar agentes sofisticados con flexibilidad y control». La palabra clave es code-first: defines el comportamiento del agente en Python (o Java, Go, TypeScript y Kotlin) en lugar de arrastrar bloques en una interfaz visual.

El proyecto es abierto bajo licencia Apache-2.0, su repositorio google/adk-python supera las 20.000 estrellas y avanza deprisa: se presentó en Google Cloud Next 2025 y la versión estable actual es la 2.5.0, del 16 de julio de 2026. En mayo de 2026 llegó ADK 2.0, que reescribió el motor de ejecución: pasó de un modelo jerárquico a un grafo de ejecución en el que agentes, herramientas y funciones son nodos de un flujo de trabajo. Ese cambio da un control mucho más fino sobre el enrutado de las tareas.

ADK no te ata a Google Cloud. Puedes desarrollar en tu portátil, ejecutar todo con un modelo abierto y desplegar donde quieras. La integración profunda con Vertex AI existe cuando la necesitas, pero es opcional.

Instalación y un agente básico

Instalar ADK en Python es una sola línea:

pip install google-adk

Requiere Python 3.10 o superior. Un agente vive en un archivo agent.py que expone una variable root_agent. Las herramientas son funciones de Python normales: ADK lee su firma y su docstring para saber cuándo y cómo llamarlas.

from google.adk.agents import Agent

def obtener_hora(ciudad: str) -> dict:
    """Devuelve la hora actual de una ciudad.

    Args:
        ciudad: nombre de la ciudad, por ejemplo "Madrid".
    """
    return {"status": "ok", "ciudad": ciudad, "hora": "10:30"}

root_agent = Agent(
    name="asistente",
    model="gemini-2.5-flash",
    instruction="Eres un asistente útil. Responde siempre en español.",
    tools=[obtener_hora],
)

Para probarlo tienes tres comandos. adk run abre una conversación en la terminal, adk web levanta una interfaz de chat en el navegador con un inspector de trazas muy útil para depurar, y adk api_server expone el agente como una API. No necesitas escribir el bucle de razonamiento a mano: ADK lo gestiona por ti.

Herramientas, sesiones y memoria

Las herramientas son lo que hace útil a un agente, y ADK admite de todo. Además de tus funciones de Python, trae herramientas integradas como la búsqueda de Google o la ejecución de código, sabe consumir cualquier API descrita con OpenAPI y conecta con servidores MCP (Model Context Protocol, el estándar abierto para conectar herramientas externas a un agente) a través de su MCPToolset. También puedes reutilizar herramientas de LangChain o CrewAI, o convertir un agente entero en la herramienta de otro.

Para que un agente recuerde, ADK separa tres piezas. El SessionService guarda el historial de la conversación (en memoria, en una base de datos o en Vertex), el State almacena variables de trabajo dentro de una sesión y el MemoryService ofrece memoria a largo plazo que sobrevive a varias conversaciones. Como cada acción se registra como un evento, el estado es reconstruible: si un despliegue falla y se reinicia, el agente puede reanudar donde estaba en lugar de repetir trabajo.

Sobre el modelo, ADK usa Gemini de forma nativa (gemini-2.5-flash, gemini-2.5-pro), pero es agnóstico: mediante la clase LiteLlm conecta con Claude, GPT y más de cien proveedores, y con un modelo abierto servido por Ollama o vLLM. Así puedes prototipar con Gemini y luego moverte a un modelo que ejecutes tú mismo.

Agentes multiagente y despliegue

El punto fuerte de ADK es componer varios agentes. Un LlmAgent puede tener sub_agents y delegar en ellos, y los agentes de flujo orquestan el trabajo de forma explícita: SequentialAgent ejecuta pasos en orden, ParallelAgent los lanza a la vez y LoopAgent repite hasta cumplir una condición. Combinándolos construyes desde un simple traspaso entre especialistas hasta sistemas multiagente jerárquicos con un coordinador al mando.

Un flujo secuencial de dos agentes se escribe así:

from google.adk.agents import SequentialAgent, LlmAgent

investigador = LlmAgent(name="investigador", model="gemini-2.5-flash",
                        instruction="Busca datos sobre el tema y resúmelos.")
redactor = LlmAgent(name="redactor", model="gemini-2.5-flash",
                    instruction="Redacta un texto claro a partir del resumen.")

root_agent = SequentialAgent(name="pipeline",
                             sub_agents=[investigador, redactor])

Cuando el agente está listo, ADK ofrece varias salidas. La más integrada es Vertex AI Agent Engine, un entorno de ejecución gestionado que se encarga de la infraestructura, la autenticación y la observabilidad con Cloud Trace. Si prefieres controlar tú el despliegue, empaquetas el agente en un contenedor y lo publicas en Cloud Run o en Kubernetes (GKE), o en cualquier servidor propio. ADK admite además el protocolo Agent-to-Agent (A2A) para que agentes de sistemas distintos colaboren entre sí.

ADK frente al Agents SDK de OpenAI

Google ADK y el Agents SDK de OpenAI nacieron ambos en 2025 y resuelven el mismo problema, pero con prioridades distintas. El SDK de OpenAI es más ligero: gira en torno a handoffs y al patrón de «agentes como herramientas», rinde al máximo con los modelos de OpenAI y trae tracing propio. ADK apuesta por un enfoque más estructurado y para empresa: agentes de flujo declarativos, sesiones con estado registrado evento a evento, cinco lenguajes con casi la misma cobertura y un camino directo a Vertex AI.

La regla práctica: elige el Agents SDK de OpenAI si quieres algo minimalista y trabajas sobre todo con modelos de OpenAI. Elige ADK si construyes sobre Google Cloud, necesitas Java o Go, o quieres orquestación multiagente determinista con despliegue gestionado. Como ADK es agnóstico respecto al modelo, no renuncias a usar Claude o un modelo abierto por el camino.

Preguntas frecuentes

¿Google ADK es gratuito y de código abierto?

Sí. El framework es de código abierto con licencia Apache-2.0 y su código está en google/adk-python; instalarlo y usarlo no cuesta nada. Pagas solo por lo que consumas aparte: las llamadas al modelo (Gemini u otro proveedor) y, si eliges desplegar en Vertex AI Agent Engine o en Cloud Run, la infraestructura de Google Cloud correspondiente.

¿Puedo usar ADK sin Gemini ni Google Cloud?

Sí. ADK usa Gemini de forma nativa, pero mediante la integración con LiteLLM funciona con Claude, GPT, modelos de Ollama o vLLM y más de cien proveedores. Y como puedes desplegar el agente en un contenedor propio o en Cloud Run, no estás obligado a usar Vertex AI. Google Cloud aporta comodidad, no es un requisito.

¿En qué se diferencia un LlmAgent de un agente de flujo?

Un LlmAgent decide qué hacer con el modelo en cada paso, así que es flexible pero menos predecible. Un agente de flujo (SequentialAgent, ParallelAgent o LoopAgent) ejecuta una estructura fija que tú defines en código, sin que el modelo decida el orden. Se combinan: el modelo razona dentro de cada paso y el flujo garantiza el recorrido general.

Conclusión

Google ADK es una apuesta seria por dar a cualquier desarrollador las mismas herramientas con las que Google construye agentes en producción. Su mezcla de sencillez inicial (un agente cabe en diez líneas) y capacidad para crecer (multiagente, sesiones con estado, despliegue gestionado) lo hace apto tanto para un experimento del fin de semana como para un sistema de empresa. Empieza por el agent.py del ejemplo, pruébalo con adk web y, cuando quieras coordinar varios agentes, revisa los patrones de sistemas multiagente.

Fuentes: [1] Documentación oficial de ADK[1], [2] ADK Python en GitHub[2], [3] Novedades de ADK 2.0[3], [4] Vertex AI Agent Engine[4].

Visitas: 0

Fuentes

  1. Documentación oficial de ADK
  2. ADK Python en GitHub
  3. Novedades de ADK 2.0
  4. Vertex AI Agent Engine

Ruta: Frameworks para construir agentes de IA