The idea
Different AI models are good at different things. Claude excels at reasoning, planning, and breaking features into clear steps. Codex excels at technical implementation, testing, and making sure code actually works.
Most people use one or the other. The Architect + Builder workflow uses both — with agentplan as the bridge between them.
The key insight: neither agent needs to know about the other. Claude writes the plan. Codex reads the tickets. agentplan is the shared contract they both understand.
How it works
Step 1: Talk to Claude about your idea
Open your project repo in Claude Code. Describe the feature you want to build. Go back and forth — let Claude ask questions, explore edge cases, and think through the architecture.
This is where Claude shines. It thinks in features, user stories, and system design. Let it do what it's good at.
Step 2: Create a plan
Once you've talked it through, use Claude Code's built-in /plan command to have Claude formalize the plan.
/plan
# Claude creates a structured plan with steps,
# implementation details, and acceptance criteria
Step 3: Turn the plan into agentplan tickets
Instead of having Claude execute the plan immediately, convert it into an agentplan project. This is the handoff moment — where the architect's vision becomes a set of concrete, trackable tickets.
"Take this plan and create an agentplan project with tickets for each step"
# Claude uses the agentplan CLI to create the project and tickets:
# agentplan create my-feature
# agentplan ticket add my-feature "Set up data models" --desc "..." --priority high
# agentplan ticket add my-feature "Build API endpoints" --desc "..." --depends T-1
# agentplan ticket add my-feature "Write integration tests" --desc "..."
# ...
Why not execute immediately? Claude is great at planning but Codex is better at implementation. By converting to tickets first, you get a reviewable contract — you can inspect, reorder, and adjust before any code is written.
Step 4: Hand off to Codex
Open Codex and point it at the agentplan project. If you've installed the agentplan Codex skill (agentplan setup codex), Codex can read and manage tickets natively.
"Check agentplan for the my-feature project. Review all tickets and
make sure everything is technically sound."
# Codex reads the tickets, reviews the plan, and flags issues:
# "T-3 should depend on T-2, not just T-1"
# "Missing a ticket for database migration"
# "T-5 needs error handling — adding a subtask"
Step 5: Review and refine together
Go back and forth with Codex. This is where the builder's technical eye catches what the architect missed:
- Missing dependencies between tickets
- Tickets that are too large and should be split
- Edge cases that need their own tickets
- Testing gaps
- Infrastructure or migration steps the plan overlooked
Codex updates the project directly — adding tickets, adjusting priorities, setting dependencies.
Step 6: Execute
Once you're satisfied with the plan, tell Codex to start working through the tickets.
"Start working on the my-feature project. Pick up the next ticket."
# Codex claims T-1, implements it, marks done, moves to T-2...
# agentplan ticket start my-feature T-1
# ... implements the work ...
# agentplan ticket done my-feature T-1 --note "Models created with migrations"
Each ticket gets implemented with proper testing, documentation, and clean commits. Codex excels here — small, well-defined tickets are exactly what it's best at.
Why this works
Each model does what it's best at
Claude thinks in features and user stories. It asks the right questions, considers edge cases, and produces clean architectural plans. But it can sometimes rush implementation or miss testing details.
Codex thinks in implementation details and correctness. It writes thorough tests, handles error cases, and produces production-ready code. But it can lose sight of the bigger picture without a clear plan.
Together, they cover each other's blind spots.
The contract prevents drift
Without agentplan, plans live in chat context that gets lost. Tickets are persistent — they survive across sessions, they're inspectable, and they create a clear record of what was planned vs. what was built.
You stay in control
The human reviews between steps 3 and 6. You see the plan before any code is written. You approve the builder's adjustments before execution starts. Nothing ships without your sign-off.
Setup
pip install agentplan
# macOS with Homebrew Python:
pipx install agentplan
# 2. Install the Claude Code plugin
agentplan setup claude
# 3. Install the Codex skill
agentplan setup codex
# 4. (Optional) Install dashboard extras
pip install "agentplan[dashboard]"
# That's it. Both agents can now read and write agentplan projects.
Tips
- Let Claude plan freely. Don't constrain it during the planning phase. The more thorough the plan, the better the tickets.
- Small tickets win. If a ticket takes more than 15-20 minutes, split it. Codex works best with focused, well-scoped work.
- Use dependencies. If ticket B can't start until ticket A is done, set
--depends T-1. agentplan auto-unblocks when dependencies close. - Review Codex's additions. When Codex adds tickets, check them. Sometimes it over-engineers — sometimes it catches something real.
- Use the dashboard. Run
agentplan dashboard --opento see the full kanban view while Codex works.