Conoce a Ralph
Un bucle de agentes autónomo que se ejecuta continuamente hasta completar todos los elementos del PRD. No necesita scripts de Bash: todo se ejecuta dentro de ADK-Rust.
Demostración en vivo de ADK-Ralph v2
Dale a Ralph un pequeño producto para construir.
Esto ejecuta el binario Rust real. El Agente PRD define una historia de usuario, el Agente Arquitecto crea el diseño y plan de tareas, y el Agente Ralph Loop escribe y verifica el proyecto en un espacio de trabajo aislado.
01 · PRD Agent
Definir el producto
02 · Architect Agent
Diseñar el sistema
03 · Ralph Loop Agent
Construir y verificar
Un proyecto · tres iteraciones de implementación · límite de ocho minutos · archivos temporales eliminados tras entrega
La ejecución real aparecerá aquí.
Verás fases del agente, actividad de herramientas, controles de calidad y los archivos que Ralph devuelve.
Arquitectura general
Construido íntegramente en Rust con las capacidades nativas de bucle de ADK-Rust
Agente de bucle
El orquestador principal recorre las tareas, delega el trabajo y supervisa el progreso general.
Agente trabajador
Ejecuta tareas individuales con un contexto específico. Implementa, prueba y confirma los cambios.
Herramientas personalizadas
Herramientas nativas de ADK-Rust para Git, operaciones con archivos, controles de calidad y gestión del PRD.
Principales capacidades
Ralph muestra las capacidades de ADK-Rust para desarrollar agentes autónomos
Bucle autónomo
Ejecución continua hasta completar todos los elementos del PRD. Integración nativa de herramientas de bucle sin scripts de Bash.
Coordinación multiagente
El agente de bucle coordina a los agentes trabajadores. Cada agente se especializa en su función para trabajar con mayor eficacia.
Herramientas personalizadas
Git, operaciones con archivos, controles de calidad y gestión del PRD, todo creado como herramientas nativas de ADK-Rust.
Guiado por el PRD
Gestión de tareas basada en JSON con historias de usuario, criterios de aceptación y seguimiento de resultados.
Controles de calidad
Verificación automática con cargo check, test, clippy y fmt antes de cada commit.
Persistencia del estado
Los commits de Git, los registros de progreso y las actualizaciones de AGENTS.md proporcionan memoria completa y trazabilidad.
Implementación en detalle
Código Rust limpio e idiomático que aprovecha todas las capacidades de 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)
}
}Estructura del proyecto
Una organización modular que separa agentes, herramientas y modelos para facilitar el mantenimiento y la ampliación.
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 frente a Bash
¿Por qué crear agentes autónomos directamente en Rust en lugar de coordinarlos con scripts de shell?
| Aspecto | Bash | Nativo |
|---|---|---|
| Implementación | Script de shell + ADK-Rust | Rust puro |
| Seguridad de tipos | En ejecución | En compilación |
| Gestión de errores | Códigos de salida | Result<T, E> |
| Concurrencia | Secuencial | Async/await |
| Integración de herramientas | Comandos de shell | Herramientas nativas de ADK-Rust |
| Depuración | Archivos de registro | Trazas + registros estructurados |
| Rendimiento | Coste de crear procesos | Abstracciones de coste cero |
| Seguridad de memoria | Gestión manual | Garantizada por el compilador |
| Pruebas | Solo pruebas de integración | Pruebas unitarias y de integración |
¿Listo para crear tu propio Ralph?
Explora el código fuente completo, adáptalo a tu caso de uso o úsalo como inspiración para tus propios sistemas de agentes autónomos.