ADK-Rust v2: del framework de agentes al runtime de producción.
La historia de cómo las herramientas, flujos de trabajo, estado, medios en tiempo real, agentes de codificación, protocolos abiertos y controles operativos se convirtieron en un sistema Rust componible.
En marzo, publicamos la historia de ADK-Rust v0.5. Ese lanzamiento hizo que el framework fuera capaz de más: recuperación, ejecución de código, proveedores de modelos adicionales, grafos duraderos, sesiones cifradas y una CLI que podía crear un proyecto inicial útil.
La siguiente pregunta fue más difícil. ¿Podrían esas capacidades convertirse en un sistema de producción que un desarrollador pudiera componer, observar, asegurar, desplegar y mantener en funcionamiento? El viaje a v2 es la respuesta. Transformó ADK-Rust de un creciente conjunto de herramientas para agentes en un runtime Rust para productos cuyos agentes hablan, usan herramientas, coordinan el trabajo, crean artefactos y colaboran a través de protocolos abiertos.
Leer el capítulo anterior: ADK-Rust v0.5El camino a v2
Seis meses transformando las características de los agentes en un sistema.
Cada lanzamiento resolvió una parte diferente del problema de producción. Juntos, cambiaron lo que los desarrolladores pueden construir razonablemente alrededor de un runtime Rust.
El framework aprendió más tipos de trabajo
RAG, la ejecución de código, las mejoras del proveedor, los grafos duraderos, las sesiones cifradas y cargo-adk expandieron lo que un agente Rust podía hacer.
Los agentes cruzaron límites reales del sistema
A2A alcanzó flujos completos de tareas remotas. AWP proporcionó a los sitios web una interfaz de agente. Los servidores MCP obtuvieron ciclos de vida gestionados, mientras que la memoria y el estado compartido se volvieron más seguros para productos más grandes.
La composición se convirtió en una experiencia para desarrolladores
Los niveles de características redujeron la superficie de dependencia predeterminada. Llegó ACP, los esquemas se adaptaron a cada proveedor de modelos, y las plantillas más los complementos hicieron de la arquitectura una elección en lugar de un ejercicio de copia.
La base se volvió estable
Treinta y nueve crates alcanzaron el nivel estable con compromisos de versionado semántico, puertas de documentación más estrictas, trabajo de seguridad, evaluación, runtimes gestionados y APIs de despliegue empresarial.
El runtime se convirtió en la columna vertebral del producto
CodingAgent y CodeAct se unieron a la familia de agentes. Las llamadas a herramientas, el progreso, los resultados, la cancelación, los medios en tiempo real, la memoria de grafos de conocimiento y los protocolos abiertos ahora viajan a través de contratos de runtime explícitos.
El punto de inflexión
Un agente de producción es mucho más que una llamada a un modelo.
Los primeros ejemplos de agentes se centraron naturalmente en un prompt, un modelo y una respuesta. Los productos reales expusieron rápidamente el resto del trabajo: decidir quién puede llamar a una herramienta, preservar el estado, mostrar el progreso, reanudar después de una aprobación, mover un archivo generado, rastrear un fallo y hablar con servicios que pertenecen a otro equipo.
v2 trata esas responsabilidades como preocupaciones del framework con contratos Rust. El modelo sigue siendo importante, pero se ejecuta dentro de una invocación con herramientas, sesiones, eventos, callbacks, límites y políticas operativas. Puedes reemplazar el modelo sin rediseñar el producto a su alrededor.
Ese es el cambio arquitectónico detrás de la versión principal: el comportamiento del agente y la infraestructura del producto ahora se encuentran en el mismo runtime, mientras permanecen lo suficientemente separados como para componer y probar.
La arquitectura v2
Sigue una pieza de trabajo a través de todo el producto.
Una solicitud puede llegar a través de una interfaz humana o un protocolo de agente. El Runner le da contexto, invoca la forma de agente correcta y transmite eventos tipados mientras las herramientas, el estado y los controles operativos apoyan el trabajo.
Personas y sistemas
Superficies del producto
Un contrato de ejecución
Runner y flujo de eventos tipados
Elige la forma del trabajo
Agentes componibles
Da a los agentes un alcance útil
Herramientas, conocimiento y estado
Mantén la producción comprensible
Controles operativos
Dentro del proceso
Agentes, herramientas, sesiones, callbacks, eventos y cancelación comparten traits y tipos de Rust.
A través de un límite
MCP, A2A, ACP, AWP, HTTP y transportes en tiempo real conectan sistemas con diferentes propietarios.
Visible para el producto
El mismo flujo de eventos puede impulsar una CLI, UI web, cliente API, visor de trazas o agente remoto.
Mira cómo funciona
El rastro de ejecución es una interfaz de producto.
Un agente útil necesita mostrar más que su frase final. v2 le da a cada paso significativo un lugar en el flujo de eventos, para que los desarrolladores puedan construir interfaces alrededor del trabajo a medida que sucede.
Solicitud
Una persona, servicio o agente inicia el trabajo.
Decidir
Un agente o flujo de trabajo elige la siguiente acción significativa.
Actuar
Una herramienta, especialista, modelo o sistema remoto realiza el paso.
Flujo
Eventos tipados transportan llamadas, progreso, resultados y cambios de estado.
Continuar
El tiempo de ejecución responde, se pausa para la entrada, reintenta o se reanuda más tarde.
Imagina un agente de codificación ejecutando una suite de pruebas. La UI recibe la llamada a la herramienta, stdout y stderr línea por línea, el resultado tipado, cualquier cambio de estado o artefacto, y la siguiente decisión del agente a través de un flujo correlacionado. Si la tarea necesita aprobación o el proceso es interrumpido, la sesión y el punto de control proporcionan un lugar claro para continuar.
Lo que v2 le da a un desarrollador
Un framework para el ciclo de vida del agente.
Puedes empezar con un agente conversacional y añadir estructura solo cuando el producto lo necesite. Los mismos contratos centrales permanecen en su lugar a medida que el sistema crece.
Los agentes pueden trabajar de diferentes maneras
Usa un agente LLM para razonamiento flexible, agentes de flujo de trabajo deterministas para secuencias conocidas, grafos para trabajo ramificado y duradero, agentes en tiempo real para voz y video, CodingAgent para trabajo de repositorio, o CodeAct cuando un modelo deba expresar una acción de varios pasos como código ejecutable.
El progreso es parte de la API
Las llamadas a herramientas y los resultados de herramientas son eventos tipados. Las herramientas de larga duración pueden emitir progreso en el mismo flujo que la respuesta del agente, con IDs de llamada que vinculan la solicitud, la salida en vivo y el resultado final. Una UI puede renderizar el trabajo sin raspar logs.
El estado puede sobrevivir a un turno de modelo
Las sesiones preservan la conversación, los artefactos guardan los archivos generados, los puntos de control de grafos reanudan los flujos de trabajo, y la memoria de grafo de conocimiento semántico o bi-temporal da a los agentes un contexto que sigue siendo útil en sesiones posteriores.
Los protocolos abiertos tienen trabajos claros
MCP conecta herramientas y recursos, A2A conecta agentes desplegados independientemente, ACP conecta clientes y servidores de agentes de codificación, y AWP le da a un sitio web una interfaz estructurada para agentes junto con su interfaz humana.
La autonomía tiene límites operativos
Callbacks de autorización, herramientas con alcance, barandales, aprobaciones, políticas de sandbox, cancelación, telemetría, evaluación y evidencia de auditoría permiten a un equipo decidir qué puede hacer un agente e inspeccionar lo que sucedió después.
Compilas el producto que necesitas
El nivel mínimo mantiene un primer agente pequeño. Estándar añade la pila de producción común; enterprise añade tiempo real, navegador, RAG, pagos y AWP; completo añade las capacidades de audio y ejecución más pesadas. Las características individuales permanecen disponibles cuando un preajuste es demasiado amplio.
La experiencia inicial
Elige una forma de trabajo, luego hazla tuya.
La CLI de v2 puede andamiar la forma de ejecución y añadir las capacidades circundantes. El proyecto generado sigue pareciendo Rust que escribirías y revisarías tú mismo.
Crear y verificar
cargo install cargo-adk
cargo adk new support-agent \
--template tools \
--addon sessions \
--addon telemetry \
--addon guardrails
cd support-agent
cargo adk build
cargo runComponer el agente
let agent = LlmAgentBuilder::new("support")
.description("Resolves customer issues")
.instruction("Use the reviewed tools and cite evidence.")
.model(Arc::new(model))
.tool(Arc::new(LookUpOrder))
.before_tool(approval_gate)
.build()?;
Launcher::new(Arc::new(agent))
.run()
.await?;Doce plantillas cubren arquitecturas de inicio comunes. Nueve complementos componen capacidades como sesiones, telemetría, MCP, autenticación, herramientas de navegador y barandales. cargo adk build verifica el proyecto generado antes del despliegue.
Verificado contra la fuente v2
Los detalles detrás de la historia.
El siguiente capítulo comienza con un agente real
Construye el primer flujo de trabajo. Mantén abierto el camino a producción.
Comienza con una solicitud, una llamada a herramienta visible y una sesión que entiendas. ADK-Rust v2 le da a ese pequeño agente un camino directo a flujos de trabajo, memoria, protocolos abiertos, interfaces en tiempo real, seguridad y despliegue cuando el producto esté listo para ellos.