Conheça o Ralph
Um loop autônomo de agentes que continua até concluir todos os itens do PRD. Nenhum script Bash é necessário — tudo é executado dentro do ADK-Rust.
Demonstração ao vivo do ADK-Ralph v2
Dê ao Ralph um pequeno produto para construir.
Isto executa o binário Rust real. O Agente PRD define uma história de usuário, o Agente Arquiteto cria o design e plano de tarefas, e o Agente Ralph Loop escreve e verifica o projeto em um espaço de trabalho isolado.
01 · PRD Agent
Definir o produto
02 · Architect Agent
Projetar o sistema
03 · Ralph Loop Agent
Construir e verificar
Um projeto · três iterações de implementação · limite de oito minutos · arquivos temporários deletados após entrega
A execução real aparecerá aqui.
Você verá fases do agente, atividade das ferramentas, verificações de qualidade e os arquivos que Ralph retorna.
Arquitetura geral
Criado inteiramente em Rust com os recursos nativos de loop do ADK-Rust
Agente de loop
O orquestrador principal percorre as tarefas, delega o trabalho e acompanha o progresso geral.
Agente executor
Executa tarefas individuais com contexto focado. Implementa, testa e registra as alterações.
Ferramentas personalizadas
Ferramentas nativas do ADK-Rust para Git, operações de arquivos, verificações de qualidade e gestão do PRD.
Principais recursos
O Ralph demonstra os recursos do ADK-Rust para desenvolver agentes autônomos
Loop autônomo
Execução contínua até concluir todos os itens do PRD. Integração nativa das ferramentas de loop, sem scripts Bash.
Coordenação multiagente
O agente de loop coordena os agentes executores. Cada agente se especializa em sua função para trabalhar com maior eficiência.
Ferramentas personalizadas
Git, operações de arquivos, verificações de qualidade e gestão do PRD, tudo criado como ferramentas nativas do ADK-Rust.
Orientado pelo PRD
Gestão de tarefas em JSON com histórias de usuário, critérios de aceitação e acompanhamento de resultados.
Controles de qualidade
Verificação automática com cargo check, test, clippy e fmt antes de cada commit.
Persistência de estado
Commits do Git, registros de progresso e atualizações do AGENTS.md fornecem memória completa e rastreabilidade.
Implementação em detalhes
Código Rust limpo e idiomático que aproveita todos os recursos do ADK-Rust
use serde::{Deserialize, Serialize};
use std::fs;
use anyhow::Result;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Prd {
pub project: String,
pub branch_name: String,
pub description: String,
pub user_stories: Vec<UserStory>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserStory {
pub id: String,
pub title: String,
pub description: String,
pub acceptance_criteria: Vec<String>,
pub priority: u32,
pub passes: bool,
#[serde(default)]
pub notes: String,
}
impl Prd {
pub fn load(path: &str) -> Result<Self> {
let content = fs::read_to_string(path)?;
let prd: Prd = serde_json::from_str(&content)?;
Ok(prd)
}
pub fn save(&self, path: &str) -> Result<()> {
let content = serde_json::to_string_pretty(self)?;
fs::write(path, content)?;
Ok(())
}
pub fn get_next_task(&self) -> Option<&UserStory> {
self.user_stories
.iter()
.filter(|story| !story.passes)
.min_by_key(|story| story.priority)
}
pub fn mark_complete(&mut self, task_id: &str) -> Result<()> {
if let Some(story) = self.user_stories
.iter_mut()
.find(|s| s.id == task_id)
{
story.passes = true;
}
Ok(())
}
pub fn is_complete(&self) -> bool {
self.user_stories.iter().all(|story| story.passes)
}
pub fn stats(&self) -> (usize, usize) {
let complete = self.user_stories
.iter()
.filter(|s| s.passes)
.count();
let total = self.user_stories.len();
(complete, total)
}
}Estrutura do projeto
Uma organização modular que separa agentes, ferramentas e modelos para facilitar a manutenção e a extensão.
ralph/ ├── Cargo.toml # Ralph agent config ├── src/ │ ├── main.rs # Entry point │ ├── agents/ │ │ ├── mod.rs │ │ ├── loop_agent.rs # Main orchestrator │ │ └── worker_agent.rs # Task executor │ ├── tools/ │ │ ├── mod.rs │ │ ├── git_tool.rs # Git operations │ │ ├── file_tool.rs # File manipulation │ │ ├── test_tool.rs # Quality checks │ │ └── prd_tool.rs # PRD management │ └── models/ │ ├── prd.rs # PRD data structures │ └── config.rs # Configuration ├── prd.json # Task list └── progress.txt # Learnings log
Nativo versus Bash
Por que criar agentes autônomos diretamente em Rust em vez de orquestrá-los com scripts shell?
| Aspecto | Bash | Nativo |
|---|---|---|
| Implementação | Script shell + ADK-Rust | Rust puro |
| Segurança de tipos | Em execução | Na compilação |
| Tratamento de erros | Códigos de saída | Result<T, E> |
| Concorrência | Sequencial | Async/await |
| Integração de ferramentas | Comandos shell | Ferramentas nativas do ADK-Rust |
| Depuração | Arquivos de log | Tracing + logs estruturados |
| Desempenho | Custo de criar processos | Abstrações sem custo |
| Segurança de memória | Gestão manual | Garantida pelo compilador |
| Testes | Apenas testes de integração | Testes unitários e de integração |
Pronto para criar seu próprio Ralph?
Explore o código-fonte completo, adapte-o ao seu caso de uso ou use-o como ponto de partida para seus próprios sistemas de agentes autônomos.