Saltar al contenido

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.
Plan · dependency graph
Wave 13 in parallelWave 22 in parallelWave 31 taskT1 Venuesno prerequisiteT2 Availabilityno prerequisiteT3 Budgetno prerequisiteT4 Bookingafter T1, T2T5 Mealsafter T3T6 Share planafter T4

Pruébalo: selecciona una tarea para ver lo que espera y lo que desbloquea

6 tasks3 waveswave 1 is ready now

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.
Memory · recall
taskdirecthop 1hop 20.910.840.720.460.410.350.300.170.15

Pruébalo: selecciona un nodo para seguir la activación hasta la tarea

Given to the assistant

  • The team prefers a quiet place
    0.91
    guidelinedirect match
  • The weekend is 14 and 15 June
    0.84
    decisiondirect match
  • Two people need vegetarian meals
    0.46
    gotcha1 hop
  • Last year the venue was too far from the station
    0.17
    guideline2 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. 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. 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. 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. 4

    Los elementos sobre un mismo asunto se acercan entre sí. Ves los temas principales del proyecto de un vistazo.

  5. 5

    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.

Memoria

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.

Chat · team-weekendDemostración simulada
Organize a weekend in June for my team of 12. We want a quiet place near a train station.

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.

Respuestas guionizadas. No se contacta con ningún servidor.

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