ADK-Rust v2: do framework de agentes ao runtime de produção.
A história de como ferramentas, fluxos de trabalho, estado, mídia em tempo real, agentes de codificação, protocolos abertos e controles operacionais se tornaram um sistema Rust componível.
Em março, publicamos a história do ADK-Rust v0.5. Esse lançamento tornou o framework capaz de mais: recuperação, execução de código, provedores de modelo adicionais, grafos duráveis, sessões criptografadas e uma CLI que poderia criar um projeto inicial útil.
A próxima pergunta foi mais difícil. Essas capacidades poderiam se tornar um sistema de produção que um desenvolvedor pudesse compor, observar, proteger, implantar e manter em execução? A jornada para o v2 é a resposta. Ela transformou o ADK-Rust de um kit de ferramentas de agentes em crescimento em um runtime Rust para produtos cujos agentes se comunicam, usam ferramentas, coordenam o trabalho, criam artefatos e colaboram através de protocolos abertos.
Leia o capítulo anterior: ADK-Rust v0.5O caminho para o v2
Seis meses transformando recursos de agentes em um sistema.
Cada lançamento resolveu uma parte diferente do problema de produção. Juntos, eles mudaram o que os desenvolvedores podem construir razoavelmente em torno de um runtime Rust.
O framework aprendeu mais tipos de trabalho
RAG, execução de código, melhorias de provedores, grafos duráveis, sessões criptografadas e cargo-adk expandiram o que um agente Rust poderia fazer.
Agentes cruzaram fronteiras reais do sistema
A2A alcançou fluxos completos de tarefas remotas. AWP deu aos sites uma interface de agente. Servidores MCP ganharam ciclos de vida gerenciados, enquanto a memória e o estado compartilhado se tornaram mais seguros para produtos maiores.
A composição se tornou uma experiência de desenvolvedor
Camadas de recursos reduziram a superfície de dependência padrão. ACP chegou, esquemas se adaptaram a cada provedor de modelo, e templates mais add-ons tornaram a arquitetura uma escolha em vez de um exercício de cópia.
A fundação se tornou estável
Trinta e nove crates alcançaram a camada estável com compromissos de versionamento semântico, portões de documentação mais fortes, trabalho de segurança, avaliação, runtimes gerenciados e APIs de implantação empresarial.
O runtime se tornou a espinha dorsal do produto
CodingAgent e CodeAct se juntaram à família de agentes. Chamadas de ferramentas, progresso, resultados, cancelamento, mídia em tempo real, memória de grafo de conhecimento e protocolos abertos agora viajam através de contratos de runtime explícitos.
O ponto de virada
Um agente de produção é muito mais do que uma chamada de modelo.
Exemplos iniciais de agentes naturalmente se concentravam em um prompt, um modelo e uma resposta. Produtos reais rapidamente expuseram o restante do trabalho: decidir quem pode chamar uma ferramenta, preservar o estado, mostrar o progresso, retomar após uma aprovação, mover um arquivo gerado, rastrear uma falha e conversar com serviços que pertencem a outra equipe.
O v2 trata essas responsabilidades como preocupações do framework com contratos Rust. O modelo continua importante, mas ele é executado dentro de uma invocação com ferramentas, sessões, eventos, callbacks, limites e política operacional. Você pode substituir o modelo sem redesenhar o produto em torno dele.
Essa é a mudança arquitetônica por trás da versão principal: o comportamento do agente e a infraestrutura do produto agora se encontram no mesmo runtime, enquanto permanecem separados o suficiente para compor e testar.
A arquitetura v2
Acompanhe uma peça de trabalho por todo o produto.
Uma requisição pode chegar através de uma interface humana ou de um protocolo de agente. O Runner lhe dá contexto, invoca a forma de agente correta e transmite eventos tipados enquanto ferramentas, estado e controles operacionais suportam o trabalho.
Pessoas e sistemas
Superfícies do produto
Um contrato de execução
Runner e fluxo de eventos tipados
Escolha a forma do trabalho
Agentes componíveis
Dê aos agentes um alcance útil
Ferramentas, conhecimento e estado
Mantenha a produção compreensível
Controles operacionais
Dentro do processo
Agentes, ferramentas, sessões, callbacks, eventos e cancelamento compartilham traits e tipos Rust.
Através de um limite
MCP, A2A, ACP, AWP, HTTP e transportes em tempo real conectam sistemas com diferentes proprietários.
Visível para o produto
O mesmo fluxo de eventos pode impulsionar uma CLI, UI web, cliente API, visualizador de rastreamento ou agente remoto.
Veja como funciona
O rastro de execução é uma interface de produto.
Um agente útil precisa mostrar mais do que sua frase final. O v2 dá a cada passo significativo um lugar no fluxo de eventos, para que os desenvolvedores possam construir interfaces em torno do trabalho à medida que ele acontece.
Requisição
Uma pessoa, serviço ou agente inicia o trabalho.
Decidir
Um agente ou fluxo de trabalho escolhe a próxima ação significativa.
Agir
Uma ferramenta, especialista, modelo ou sistema remoto executa o passo.
Fluxo
Eventos tipados carregam chamadas, progresso, resultados e mudanças de estado.
Continuar
O runtime responde, pausa para entrada, tenta novamente ou retoma mais tarde.
Imagine um agente de codificação executando um conjunto de testes. A UI recebe a chamada da ferramenta, stdout e stderr linha por linha, o resultado tipado, quaisquer mudanças de estado ou artefato, e a próxima decisão do agente através de um fluxo correlacionado. Se a tarefa precisar de aprovação ou o processo for interrompido, a sessão e o ponto de verificação fornecem um lugar claro para continuar.
O que o v2 oferece a um desenvolvedor
Um framework para o ciclo de vida do agente.
Você pode começar com um agente conversacional e adicionar estrutura apenas conforme o produto precisar. Os mesmos contratos centrais permanecem em vigor à medida que o sistema cresce.
Agentes podem trabalhar de diferentes maneiras
Use um agente LLM para raciocínio flexível, agentes de fluxo de trabalho determinísticos para sequências conhecidas, grafos para ramificação e trabalho durável, agentes em tempo real para voz e vídeo, CodingAgent para trabalho de repositório, ou CodeAct quando um modelo deve expressar uma ação multi-passo como código executável.
O progresso faz parte da API
Chamadas e resultados de ferramentas são eventos tipados. Ferramentas de longa duração podem emitir progresso no mesmo fluxo que a resposta do agente, com IDs de chamada ligando a requisição, saída em tempo real e resultado final. Uma UI pode renderizar o trabalho sem raspar logs.
O estado pode sobreviver a uma única rodada do modelo
Sessões preservam a conversa, artefatos mantêm arquivos gerados, pontos de verificação de grafo retomam fluxos de trabalho, e a memória de grafo de conhecimento semântica ou bi-temporal dá aos agentes um contexto que permanece útil em sessões posteriores.
Protocolos abertos têm funções claras
MCP conecta ferramentas e recursos, A2A conecta agentes implantados independentemente, ACP conecta clientes e servidores de agentes de codificação, e AWP dá a um site uma interface estruturada para agentes ao lado de sua interface humana.
A autonomia tem limites operacionais
Callbacks de autorização, ferramentas com escopo, guardrails, aprovações, políticas de sandbox, cancelamento, telemetria, avaliação e evidências de auditoria permitem que uma equipe decida o que um agente pode fazer e inspecione o que aconteceu depois.
Você compila o produto que precisa
A camada mínima mantém um primeiro agente pequeno. Standard adiciona a pilha de produção comum; enterprise adiciona tempo real, navegador, RAG, pagamentos e AWP; full adiciona as capacidades mais pesadas de áudio e execução. Recursos individuais permanecem disponíveis quando um preset é muito amplo.
A experiência inicial
Escolha uma forma de trabalho, depois personalize-a.
A CLI v2 pode gerar a estrutura de execução e adicionar as capacidades circundantes. O projeto gerado ainda se parece com o Rust que você escreveria e revisaria por conta própria.
Criar e 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 runCompor o 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?;Doze templates cobrem arquiteturas iniciais comuns. Nove add-ons compõem capacidades como sessões, telemetria, MCP, autenticação, ferramentas de navegador e guardrails. Cinco padrões empresariais fornecem formas de implantação maiores. cargo adk build verifica o projeto gerado antes da implantação.
Verificado contra a fonte v2
Os detalhes por trás da história.
O próximo capítulo começa com um agente real
Construa o primeiro fluxo de trabalho. Mantenha o caminho para a produção aberto.
Comece com uma requisição, uma chamada de ferramenta visível e uma sessão que você entenda. O ADK-Rust v2 dá a esse pequeno agente um caminho direto para fluxos de trabalho, memória, protocolos abertos, interfaces em tempo real, segurança e implantação quando o produto estiver pronto para eles.