A Codex multi-agent workflow

PigeonStack: a Codex multi-agent workflow

First, credit and thanks to Lauren Tan (poteto), the original author of pstack. PigeonStack adapts her work for this Codex workflow.

PigeonStack is PigeonYang's maintained Codex setup. It brings global rules, an adapted pstack plugin, agent-role definitions, selected configuration, and a local sync script into one source repository. Sol remains the Primary, Luna handles routine work, a fresh Sol Senior Executor starts ordinary technical design at medium, and Astra handles critical design or work that remains unresolved after the Sol tiers.

Ordinary technical design goes to Sol, while Astra is reserved for critical design and unresolved work. This routing is expected to reduce how often work reaches Astra. Quota savings have not been measured.

Not sure which pstack skill fits your task? Ask /poteto-help. It reads the bundled guides, recommends a relevant skill, and can provide one example prompt. Asking for help does not start the suggested work. Codex model selection and permissions follow this repository’s GPT configuration.

A bounded handoff

One Primary owns the decisions

The Primary checks the evidence, chooses a solution, and accepts the result. Agents receive a concrete task and return changes, observations, or a blocker.

RoleWork
Sol PrimaryOwns the goal, constraints, day-to-day decisions, coordination, and final acceptance.
Luna ExecutorHandles routine implementation and operations, prescribed read-only evidence collection, assigned checks, and faithful updates to approved content. It returns the result and evidence to the Primary.
Sol Senior ExecutorStarts direct ordinary technical assignments and Luna-failure takeovers at gpt-6.1-sol, medium. The same unresolved problem advances through Sol high and xhigh before Astra. A fresh child chooses, implements, and verifies a complete result without switching the active Primary.
Astra ExpertDirectly handles master or system architecture, key interface and data-contract design, and consequential design tradeoffs. It takes other work only after Sol xhigh remains unresolved or when the user explicitly selects Astra. For a takeover, it owns diagnosis, solution selection, implementation, and verification through completion. It starts at gpt-6-astra, high. Unresolved work can transfer to a fresh child at xhigh, the automatic escalation limit.

Routine execution goes to Luna. Ordinary proposals, plans, local design, routine rule updates, upstream adaptations, and bounded consultations go directly to a fresh Sol Senior Executor at medium. Luna-failure takeovers also start at Sol medium. For the same unresolved problem, proceed through Sol high and xhigh before Astra high; an ordinary Sol medium or high assignment does not skip to Astra. Send master or system architecture, key interface and data-contract design, and consequential tradeoffs directly to Astra. Keep core architecture decisions out of Luna's scope. A technical-document label or Primary uncertainty alone does not trigger Astra. Optional read-only Astra consultation is available for a critical design question, a question that remains unresolved after Sol xhigh reports failure or reaches its 30-minute assessment, or an explicit task-specific user model request. Ordinary consultations start with Sol at medium. The Primary dispatches every consultation and child. Explicit task-specific user model and effort selections remain authoritative. Takeovers use the general execution role with an explicit model and effort. No role IDs or runtime permissions change. Actual model access depends on the Codex host and account.

Run independent work together

Text and code tasks can run in parallel when they have no shared writes or dependencies. Image generation, editing, viewing, and transfer run one at a time.

Use the tools you already have

PigeonStack packages instructions, a Codex plugin, configuration, and deployment tooling. It does not provide an MCP server or a separate autonomous scheduler.

When an executor reports that it cannot solve the problem, advance immediately to the next tier. Otherwise, the Primary assesses unresolved work 30 minutes after first dispatch at that model and effort tier. A retry or replacement at the same tier does not reset its clock. Carry evidence, failed attempts, and total elapsed time across upgrades. Existing waits are interruptible; 30 minutes is an assessment point, not a hard delay.

When routine work starts at Luna, the escalation path is Luna max, Sol medium, Sol high, Sol xhigh, Astra high, and a fresh Astra child at xhigh. Direct ordinary assignments start at Sol medium; critical design starts at Astra high. A successful tier ends the path. Each new task starts at its role's default unless the user explicitly selects a model or effort. Only a handoff for the same unresolved task advances to the next tier; same-tier retries or replacements keep that tier and its clock. The Senior Executor and Expert choose, implement, and verify a complete solution, then return the result and evidence to the Primary for final acceptance. User-selected Astra assignments follow the same high-to-xhigh limit. Ordinary webpage implementation and refactoring remain with Luna regardless of size. External blockers, including unavailable models or effort levels, credentials, access, permissions, or services, do not trigger reasoning escalation. If Astra at xhigh cannot resolve the problem or it remains unresolved at its 30-minute assessment, stop and report the actual limit or missing evidence. Do not automatically escalate Astra to max or ultra, or restart the cycle. A confirmed healthy long-running command is not a reasoning failure and continues through its existing observation loop. See MODELS.md for model IDs and role details.

ComputerUse actions stay with the Primary because child tools do not expose ComputerUse. Do not delegate actions requiring ComputerUse. A Senior Executor or Expert may request a named UI action and its observed result, then continue the same problem. This asks the Primary for an observation, not for a solution. Text, code, CLI, and API work remain delegable. The rule adds no tools or permission flow.

Prioritize the authorized normal business workflow through existing entry points. When an actual bug occurs or is reported, retain sufficient evidence, diagnose and repair the cause within scope, then rerun the affected real workflow and targeted regression checks. Address the bug when encountered, without waiting for the whole workflow to finish. Block only affected and dependent actions, and continue independent valid work. Report any outcome that an unavailable workflow prevents you from verifying. Targeted regression does not authorize a full test suite.

During normal task work, reuse existing scripts, CLIs, and business entry points. A minimal tool may help with repeated deterministic work only when the need is observed and authorized. Give the responsible agent a way to inspect the real result. Before escalating models, distinguish gaps in tools, feedback, or the environment from reasoning failures. At completion, use evidence already collected to identify recurring mistakes and improve the smallest relevant code, tool, skill, or rule within scope. Record unrelated findings in the existing project record. These habits add no mandatory project scan, report, skill, harness, validation gate, or automatic retrospective.

A validation gate is a mandatory check that must pass before an action can proceed. Add a new gate only for an evidence-confirmed problem or an explicit current requirement. An unverified hypothesis or hypothetical future failure cannot become a new gate or prerequisite. A confirmed bug does not automatically require a gate. If needed, scope the gate to the affected action and boundary, and verify that it catches the failure or enforces the requirement without unnecessarily blocking valid work. Existing required checks, explicit current requirements, and safety, permission, and data-integrity boundaries remain in force before any bug occurs.

Who it helps

For Codex users who need clear handoffs

Use PigeonStack when you want an agent workflow with named decision ownership, scoped execution, and evidence-based acceptance.

Its cost-performance goal is a work strategy, not a benchmark. Model IDs, access, supported reasoning effort, and cost depend on your account and Codex client.

Questions and limits

What to expect from PigeonStack

What is PigeonStack?

PigeonStack is PigeonYang's maintained set of Codex global rules, agent-role definitions, selected configuration, a customized pstack plugin, and a local synchronization script.

How does PigeonStack relate to pstack?

PigeonStack adapts Lauren Tan's pstack workflows for Codex and adds repository-specific rules and deployment configuration. It does not claim to be superior to the upstream project. The site links to the pinned upstream source and preserves its attribution.

Is it a plugin, an MCP server, or a skill?

PigeonStack is a repository and deployment setup that includes an adapted Codex plugin and selected skills. It does not include an MCP server, timers, hooks, or a background scheduler.

Can I choose other models?

Model choices are configured in the repository, and the local rules give explicit user selection priority. Your Codex host and account must expose the model and agent tools you choose. The repository does not verify a provider's internal model mapping.

What is the difference between a preview and an installation?

An isolated preview uses --codex-home with --skip-plugin-install to check copied files and merged configuration. It does not activate the plugin or rewrite machine-specific paths embedded in instructions. The getting started guide shows both routes.

What has been verified?

A successful sync check establishes that managed files and configuration align on disk. A new Codex session is needed to verify instruction loading and actual model routing. Publishing this site does not prove search indexing or rankings.

Start with a safe target

Preview the files before changing a live Codex home

The guide shows the isolated preview commands, their exit codes, and the maintainer-host deployment boundary.

Open the getting started guide