Cómo funciona
De un objetivo a un plan que puedes seguir
Seis etapas, en un ciclo. Tú dices lo que quieres. PO lo planifica, ordena las tareas, recuerda lo que el proyecto sabe, ejecuta el trabajo, lo comprueba y guarda lo aprendido. Debajo de cada etapa puedes abrir los detalles técnicos.
Planificar → Ordenar → Recordar → Ejecutar → Verificar → Aprender, y de nuevo a Recordar. Lo que guarda la etapa 6 es lo que la etapa 3 recuerda en el siguiente plan.
Pruébalo: pasa el cursor o enfoca una etapa para leerla, selecciónala para ir a ella
El ciclo
El ciclo, etapa por etapa
Desplázate: cada imagen está dibujada como las pantallas del producto. El ejemplo es un fin de semana de equipo.
Etapa 1 de 6: Planificar, paso de lectura 5 de 5: Aprobado
Dices lo que quieres y obtienes un plan
Describes el resultado en una frase. El asistente lo convierte en un plan con tareas. Cada tarea tiene pasos, y cada paso indica cómo comprobar que está hecho.
Bajo el capó
El resultado se guarda como un plan con una prioridad y sus restricciones, y se divide en tareas. Cada tarea indica de qué depende y enumera sus pasos. Cada paso lleva la comprobación que demuestra que está hecho.
Los planes, las tareas y los pasos se guardan como datos, no como texto libre en un chat. Las pantallas y el ejecutor leen los mismos estados.
plan(action: "create", title, description, priority: 8, constraints: [{ constraint_type: "performance", … }])task(action: "create", plan_id, title, depends_on: [task_id], steps: [{ description, verification }])- Estado del plan: draft, approved, in_progress, completed, cancelled.
- Tipos de restricción: performance, security, style, compatibility, other.
- code(action: "plan_implementation", auto_create_plan: true) esboza un plan a partir del grafo de código.
Pruébalo: selecciona un paso, avanza con las flechas o pulsa reproducir; el diagrama vuelve a seguir el desplazamiento tras una pausa
Etapa 2 de 6: Ordenar, paso de lectura 5 de 5: Lista ahora
Las tareas que no dependen unas de otras van juntas
PO ordena las tareas. Una tarea espera solo a las tareas que necesita. Todas las demás pueden empezar ya, a la vez.
Bajo el capó
Una tarea empieza solo cuando todo aquello de lo que depende está completed. PO convierte estos vínculos en olas: la ola 1 contiene todas las tareas sin requisitos pendientes, la ola 2 contiene lo que desbloquea la ola 1, y así sucesivamente.
Las tareas de una misma ola son independientes, así que se ejecutan a la vez. La cadena de dependencias más larga, la ruta crítica, fija el número mínimo de olas.
plan(action: "get_waves", plan_id)plan(action: "get_critical_path", plan_id)- plan(action: "get_dependency_graph") devuelve el DAG de tareas.
- task(action: "get_next") devuelve la siguiente tarea desbloqueada, con la prioridad más alta primero.
- Cuando se reanuda una ejecución, las olas se recalculan y se omiten las olas terminadas.
Pruébalo: selecciona una tarea para ver lo que espera y lo que desbloquea
Pruébalo: selecciona un paso, avanza con las flechas o pulsa reproducir; el diagrama vuelve a seguir el desplazamiento tras una pausa
Etapa 3 de 6: Recordar, paso de lectura 5 de 5: Entregada
El asistente busca lo que el proyecto ya sabe
Antes de cada tarea, el asistente lee las notas y decisiones que corresponden. Así no vuelve a hacer las mismas preguntas.
Bajo el capó
Antes de una tarea, el asistente lee la memoria del proyecto: notas (advertencias, directrices, patrones), decisiones con sus razones y, en un proyecto de código, el código que rodea los archivos que va a tocar. Una búsqueda por significado encuentra primero las coincidencias más cercanas.
Después PO sigue los vínculos entre notas. Una nota que no coincidía con la pregunta puede aparecer igualmente, porque una nota que sí coincidía está muy vinculada a ella. El vínculo se debilita en cada salto, y las notas que se han desvanecido se dejan fuera.
note(action: "search_semantic", query, project_slug)decision(action: "search_semantic", query)admin(action: "search_neurons", query, max_hops: 2)note(action: "get_context", entity_type: "file", entity_id)- Valores por defecto de la activación por propagación: 20 notas semilla, 2 saltos, la señal se reduce a la mitad en cada salto, 10 resultados.
- El 40 % de los huecos de resultado se reserva para notas alcanzadas a través de sinapsis.
- Una puntuación propagada es la puntuación del origen × peso de la sinapsis × energía de la nota × atenuación.
Pruébalo: selecciona un nodo para seguir la activación hasta la tarea
Given to the assistant
- The team prefers a quiet place0.91guidelinedirect match
- The weekend is 14 and 15 June0.84decisiondirect match
- Two people need vegetarian meals0.46gotcha1 hop
- Last year the venue was too far from the station0.17guideline2 hops
Pruébalo: selecciona un paso, avanza con las flechas o pulsa reproducir; el diagrama vuelve a seguir el desplazamiento tras una pausa
Etapa 4 de 6: Ejecutar, paso de lectura 5 de 5: Empieza la ola 2
Los asistentes hacen las tareas, grupo por grupo
Cada tarea va a su propio asistente. Las tareas de un grupo se ejecutan a la vez, y el siguiente grupo espera.
Bajo el capó
plan(action: "run") inicia el ejecutor en su propia rama de git. Para cada ola inicia una sesión de agente por cada tarea elegible y las ejecuta en paralelo, hasta un límite (4 por defecto).
Cada tarea recibe un prompt construido a partir de la memoria del proyecto: su descripción, pasos y restricciones, las notas vinculadas, el perfil y las habilidades que corresponden, y un resumen de lo que hicieron las olas anteriores. Un vigilante observa la sesión por si hay inactividad, llamadas repetidas y tiempos agotados, y envía una pista cuando el agente se desvía.
plan(action: "run", plan_id, cwd, project_slug)plan(action: "run_status", plan_id)- Una tarea se perfila como simple, compleja o creativa según sus etiquetas, pasos y archivos. El perfil fija su límite de tiempo y su presupuesto de coste.
- Simple: 600 s y $0.50. Compleja: 3600 s y $2.00. Creativa: 1800 s y $1.00.
- Las ejecuciones se guardan, así que una ejecución puede reanudarse tras un reinicio. plan(action: "cancel_run") detiene una.
- El asistente que delega una tarea puede indicar el proveedor y el modelo: plan(action: "delegate_task") recibe provider, model y task_class. El proyecto debe haber permitido ese proveedor.
Pruébalo: selecciona un paso, avanza con las flechas o pulsa reproducir; el diagrama vuelve a seguir el desplazamiento tras una pausa
Etapa 5 de 6: Verificar, paso de lectura 5 de 5: Completada
Un grupo está terminado cuando pasan sus comprobaciones
Antes de que empiece el siguiente grupo, PO comprueba el trabajo. Los pasos deben estar cerrados y no puede quedar ningún archivo sensible en los cambios. En un proyecto de código, PO también comprueba que todavía compila.
Bajo el capó
Cuando termina una ola, el ejecutor la verifica antes de que empiece la siguiente. Comprueba que los agentes han producido commits, que cada paso está completed o skipped, que el proyecto compila y que el diff no contiene ningún archivo sensible.
La propia ejecución es una máquina de estados. Un protocolo de ciclo de vida pasa de approved a executing y a post_run, y cada paso necesita un disparador explícito. Una tarea cuyo agente falla o agota el tiempo se reintenta una vez por defecto, con el error como contexto.
protocol(action: "transition", run_id, trigger: "child_completed")step(action: "get_progress", task_id)- Comprobación de compilación: cargo check, npm run build o go build ./..., según el lenguaje detectado.
- Archivos sensibles rechazados: .env, credentials.json, *.pem, *.key y similares.
- Las pruebas son opcionales y están desactivadas por defecto. plan-runner-reviewed añade un estado awaiting_review para una persona.
Pruébalo: selecciona un paso, avanza con las flechas o pulsa reproducir; el diagrama vuelve a seguir el desplazamiento tras una pausa
Etapa 6 de 6: Aprender, paso de lectura 6 de 6: De vuelta a Recordar
Lo aprendido se guarda para la próxima vez
Cuando termina el trabajo, lo que se decidió y se aprendió se escribe de vuelta en la memoria del proyecto. El siguiente plan empieza con ello.
Bajo el capó
Cuando una tarea se completa, el ejecutor escribe de vuelta sin llamar a un modelo: vincula los commits a la tarea y al plan, crea una nota de contexto a partir del registro de git y asocia las decisiones a los archivos a los que afectan.
El asistente añade lo que solo él sabe: decisiones con sus alternativas, advertencias, patrones. Las notas usadas juntas se acercan. Las notas que nunca se usan pierden energía y quedan obsoletas. Un episodio registra la petición, el recorrido por los estados y el resultado. El siguiente plan empieza en la etapa 3 con todo ello.
decision(action: "add", task_id, rationale, alternatives)note(action: "create", note_type: "gotcha", content, anchors)episode(action: "collect", run_id, project_id)admin(action: "reinforce_neurons", note_ids)- La obsolescencia crece con el tiempo desde la última actividad, a un ritmo que depende del tipo de nota. note(action: "confirm") la reinicia.
- Las habilidades surgen de grupos de notas fuertemente vinculadas (admin(action: "detect_skills")).
Pruébalo: selecciona un paso, avanza con las flechas o pulsa reproducir; el diagrama vuelve a seguir el desplazamiento tras una pausa
Responsabilidades
Quién hace qué
PO se encarga de la mecánica, para que el asistente pueda centrarse en el trabajo.
PO lo hace, sin que se lo pidas
- Ordena las tareas en grupos e inicia los asistentes.
- Comprueba cada grupo: pasos cerrados, ningún archivo sensible y la compilación en un proyecto de código.
- Vincula los cambios a la tarea y escribe una nota sobre lo ocurrido.
- Mantiene los cambios de cada ejecución en su propia rama de git.
- Registra qué perfil y qué habilidades ayudaron.
El asistente lo hace, mediante sus herramientas
- Busca notas y decisiones antes de empezar.
- Crea planes, tareas y pasos, y actualiza su estado.
- Guarda decisiones con sus alternativas y lo que afectan.
- Escribe advertencias, directrices y patrones, vinculados a aquello de lo que tratan.
- Hace avanzar un procedimiento, paso a paso.
Puntos de entrada
Tres formas de iniciar el ciclo
Desde tu herramienta de IA
Claude Code, Cursor u otra herramienta de IA conectada a PO. Tú describes el resultado. Ella planifica, ordena y recuerda, y al final guarda lo que aprendió.
Desde el chat
El chat integrado en PO habla con el mismo asistente. Cada mensaje lleva las habilidades correspondientes, las notas y decisiones que se aplican y lo que está en curso. Escribe # para señalar un plan, una tarea, una nota o una decisión. Eliges el motor de una conversación, Claude Code por defecto u otro motor (alfa), o la pones en Auto y PO elige el modelo; un modelo que hayas elegido tú nunca se sustituye. Una cronología encima de la conversación muestra qué se ejecutó y durante cuánto tiempo. Un mensaje que envías mientras el asistente está ocupado espera en una cola que guarda el servidor, así que no se pierde si cambias de conversación o recargas. Con el motor nativo, Codex y ACP, un turno cortado por un reinicio del servidor se reanuda solo; un turno de Claude Code se cierra con un error visible y tu siguiente mensaje retoma la conversación.
Por sí solo
Un plan puede ejecutarse cuando no hay nadie. Se inicia según un calendario o cuando ocurre un evento, con una pausa entre dos inicios. Los tipos de inicio son schedule, webhook, event y chat.
Memoria
PO recuerda lo que decides y lo que aprendes
Las notas, las decisiones y los vínculos entre ellas quedan unidos a tu proyecto. PO las vuelve a encontrar cuando son útiles. Desplázate para ver cómo crece una memoria.
- 1
Tus archivos se vuelven puntos
PO parte de lo que hay en el proyecto: documentos, hojas de cálculo, archivos. Cada uno es un punto azul.
- 2
Se suman los planes y las tareas
Los planes y las tareas se añaden al mismo dibujo. Cada tarea está vinculada a los archivos que toca.
- 3
Las notas y las decisiones siguen vinculadas
Lo que aprendes se convierte en una nota. Lo que decides se convierte en una decisión. Ambas siguen vinculadas a los archivos y entre sí.
- 4
Lo relacionado se agrupa
Los elementos sobre un mismo asunto se acercan entre sí. Ves los temas principales del proyecto de un vistazo.
- 5
PO encuentra la respuesta siguiendo los vínculos
Haces una pregunta. PO encuentra las notas que coinciden (cian). Después sigue los vínculos hasta los elementos relacionados (violeta), aunque las palabras sean distintas.
Ejemplo inventado: un pequeño proyecto de evento. Los nombres del grafo son ilustraciones, no tus datos. Los colores y las formas son los del grafo del producto.
Bajo el capó: los nombres de los vínculos
Estos son los nombres que el producto usa para los vínculos de su grafo. No los necesitas para usar PO.
- CONTAINSUn plan contiene sus tareas.
- IMPORTSUn archivo usa otro archivo.
- AFFECTSUna tarea toca un archivo.
- CO_CHANGEDDos archivos que suelen cambiar juntos, según el historial del código.
- SYNAPSEUn vínculo entre notas, decisiones y archivos. Los vínculos que nadie usa se desvanecen.
Pruébalo
Mira cómo trabaja un asistente con PO
Elige una petición. Verás la respuesta en palabras sencillas y las llamadas que el asistente hace a PO entre bastidores. Abre una llamada para ver sus detalles.
Two notes apply: the place must be close to a train station, and last year the menu had nothing vegetarian. I will write the plan around both.
The plan has 3 tasks in 2 waves. The shortlist and the date poll do not depend on each other, so they happen at the same time. Booking waits for both.
Pruébalo: escribe tu propia petición, abre una llamada para ver sus detalles y luego copia todo el intercambio.
Demostración simulada: las respuestas están guionizadas y no se contacta con ningún servidor. Las llamadas y sus argumentos son los reales.
Primeros pasos
Dale memoria y un plan a tus agentes
Instala el orquestador, conecta tu asistente por MCP y deja que tu primer agente lea el proyecto antes de escribir una sola línea.
La aplicación es gratis. Solo pagas por la IA que ya usas, como tu propia suscripción a Claude Code o una clave para otro modelo. Mira lo que cuesta
O empieza desde el terminal
brew install this-rs/tap/project-orchestrator