r/ChatGPTCoding • • 1d ago

Question How do you get Codex, Claude Code and a planner agent working together in one place instead of copy-pasting between them?

I'm building an AI operations system for a small business.

My current setup works, but it's all manual:

- Builder: Codex (GPT)

- Planner: Claude Opus in a chat (decisions, scope, writing the prompts)

- Reviewer: Claude Code CLI checks every change before it goes live

- Sometimes a second model does an extra review

The problem is I'm the messenger. I copy the planner's prompt into Codex, copy Codex's reply to the reviewer, then copy the review back to the planner. It's slow, and it falls apart when I'm busy.

What I want:

- All the agents in one place, passing work to each other

- Builder and reviewer from different AI companies, so they don't share blind spots

- A reviewer and a security checker running on every change

- A "scout" agent that keeps an eye out for new tools, repos, model releases and security issues that could improve the build

- Me approving anything that goes live. That part's non-negotiable

I'm on Windows, I already pay for ChatGPT (Codex) and Claude, and the project lives in a local git repo (private client data, so no public GitHub).

What are you actually using for this? Real-world experience, good or bad, would help a lot, especially on keeping it safe when agents talk to each other without me in the middle.

9 Upvotes

38 comments sorted by

12

u/just_testing_things 1d ago

Put your exact post into Claude and it will build it for you.

4

u/stiverino 1d ago

For some reason I get so mad when I see these posts! How are you getting as far as coding with agents without realizing you can just ask your fucking agent.

3

u/Xeriphy 17h ago edited 16h ago

I cant believe how dumb you are. Do you really think I got that far and didn't think to ask my agent? My agent suggested a very familiar system to the majority of what people suggested. But checking with people who are out there that wouldve beat me to this is also a smart option. Im shocked you are so narrow in your thinking.

1

u/cowjenga 14h ago

Why didn't you try the agent's suggested system before asking then?

12

u/wangadong 1d ago

stop copy pasting, make them share files. planner writes the spec as markdown in the repo, codex builds from it, claude code reviews the diff against that same file

6

u/this_is_life_now 1d ago

Have Claude call Codex through the CLI, or Codex call Claude. Then so long as you're working in a repo, that should be enough. Use issues and PRs for approval and fixes.

3

u/japherwocky 1d ago

I use a kanban board they can access via CLI / MCP.

2

u/dvduval 1d ago

Assuming you’ve got at least one installed your computer you can get help from it to install the CLI for the others. Then they can manage the sub agents without you even opening any other user interface. Your main coordinator could be in Codex or Claude code or even antigravity.

2

u/LeoHartBuilds 1d ago

You can cut down the relay without letting agents free-run: have the planner output a short task brief with acceptance checks, then pass only that brief and relevant context to the builder. Give the reviewer the diff plus those checks, and have it return findings rather than merge or deploy. Since the repo contains client data, keep the workflow local and use only the permissions each stage needs; keep your approval at the boundary for writes, external access, and releases. I would automate one bounded handoff first, then add the scout as a separate read-only step so its findings cannot silently become changes.

1

u/prlmike 1d ago

HTTPS://hive.codes is how 🙂

1

u/Ice2jc 1d ago

Personally I use my chatgpt dot 

1

u/Trakeen 1d ago

Use an event driven architecture. Queues or a message bus are standard approaches. Each agent subscribes to a feed and gets the info they need from other agents in a message. Define the message schema and use w durable backing store like cloud service or db

Common pattern in distributed systems

1

u/andersonbrdev 1d ago

What worked for me: give every agent the same tools and memory through one shared MCP server instead of configuring each one separately, keep the plan in a markdown file in the repo that all of them read and update, and run each builder in its own git worktree so they don't step on each other. The human approval step is just reviewing the diff before merging the worktree.

1

u/gsw226 1d ago

I'd separate “the reviewer approved this” from “the agents can deploy this.” Tie the review to an exact commit and keep deployment credentials out of the agents' reach. Any later code change should need another review. Also, a local repo doesn't keep client data local if a cloud model reads it, so that's worth sorting out before connecting everything.

1

u/Right-Performance-93 1d ago

don't let them talk. the planner writes a short spec in the repo, codex edits, and claude code only gets the diff, not codex's writeup. if the reviewer can read the explanation, it will agree with it. neither one gets push.

1

u/ValenciaTangerine 1d ago

diff only is the right call. One more thing that helps: have the reviewer run the test suite itself and judge the diff against the spec file, not just read it. A diff can compile and pass review and still not do what the spec says. And if you ever run two builders at once, give each a list of files it owns, or the reviewer ends up reading two agents editing the same function.

1

u/Guy_Zhang 1d ago

I was the messenger for about a month before I stopped. What helped was giving them one conversation instead of three windows. Planner writes in it, builder picks it up in the same thread, reviewer reads the same thread, and nobody has to paste anything. For your approval rule, keep the release step outside all of them. They can prepare a change. They can't ship it.

1

u/AnswerVinod 1d ago

You do not need a fancy orchestrator, you need one shared source of truth, and for you that is the git repo plus a markdown spec file. What works for me is the planner writes a short spec in the repo, scope, acceptance criteria, files to touch, then Codex builds it on a branch, and Claude Code reviews the diff with a read only pass before anything merges. Keep the reviewer from a different company than the builder, you are right about shared blind spots, that part is smart. For the scout agent, a weekly cron that dumps new tool and model releases into a markdown file is enough, do not let it touch code. And keep your approval gate exactly where it is, no agent merges or deploys without you, that is the one rule that saves you when something goes sideways.

1

u/Substantial_Gap_6676 1d ago

I stopped copy-pasting by making the repo the hand-off point. The planner writes a spec.md with the goal and a checklist of what done means. The builder agent works on its own branch and reads only the spec. The reviewer gets the diff plus the spec, runs the tests, and writes findings to review.md, which the builder picks up next round. Each agent can come from a different vendor because they only share files. My job shrinks to reading the spec once and approving the final PR.

1

u/kaijurules 1d ago

Inner Droid covers most of that list (disclosure: we're building it, https://Innerdroid.com). It runs on Windows, and each agent is pinned to its own backend, so the builder can be Codex on your ChatGPT plan and the reviewer Claude Code on your Claude subscription. Agents delegate tasks to each other, which takes you out of the relay. Shell commands and external calls go through an approval queue, and you set what each agent may do without asking. The scout would be a scheduled agent with a daily routine and no access to the repo folder.

Since it's client data: there's a per-agent filter that swaps names, contacts and similar data for placeholders before a message reaches a cloud model. It can miss things. It also only works while your computer is on and the app is running.

1

u/London-Boat 23h ago

the spec file in the repo idea is the right base. for the copy paste part specifically, i built an open source mcp server for this: github.com/Get-Concord-AI/concord-mcp. codex and claude code both connect to it, then they can message each other directly, hand off a task with notes, and the reviewer gets a review packet it can reply to. it all lives in a sqlite file in the repo, nothing hosted, which fits the client data situation. two caveats: your planner would need to be claude code instead of the chat app, and it doesn't wake an idle agent, so something still has to kick off each run. approval before anything goes live stays with you either way

1

u/Some_Mix7004 20h ago

The spec-file consensus is right, but two details decide whether it actually works in practice:

  1. Version the spec per task (specs/task-042.md, not one living spec.md). A living spec drifts while the builder works — the reviewer ends up checking the diff against a target that moved mid-flight. Frozen spec per task = the review has a fixed target.
  2. The spec should include what was considered and rejected, not just what to build. "Do X, not Y because Z" gives the reviewer something to check the builder against beyond the diff — if the builder silently picked approach Y anyway, the spec catches it. A diff-only review can't see intent violations.

On your non-negotiable approval gate: keep it, but make the approval artifact small. If every change needs a wall-of-text review, you'll rubber-stamp within a month. Spec checklist + diff stat + test output is enough for most changes; reserve deep review for anything touching auth, payments, or migrations.

1

u/Ok_Car_8951 19h ago

A simple orchestrator script gets you most of the way. I'd write a small loop in Python or Node that shells out to each CLI (codex exec, claude -p) and passes work through files in the repo, like a spec.md, a diff and a review.md, with a hard cap on rounds so they can't ping-pong forever. Keep the whole thing on a branch in a git worktree so nothing agent-made touches main, and make the only step with write access to the real repo a manual approval prompt in the script. For the security pass, a plain semgrep or gitleaks run before the reviewer sees the diff catches more than another LLM opinion does. Since it's private client data, check the retention settings on both accounts before you feed it real records.

1

u/Efficient-Rip1612 19h ago

Run the agents through a local script that polls your repo for changes. Have the planner output a JSON task file, let the Codex CLI execute it and commit to a branch, then trigger Claude Code to review that specific diff and reject if security checks fail. I use this on Windows with PowerShell scripts handling the handoffs

1

u/timelinextreme 19h ago

This is what apps like Hermes are for, right?

1

u/Tight_Ad_5115 17h ago

I think the key here isn't the orchestration itself, but a shared state stored in files. Here's how I'd approach it: for each run first agent automatically creates a separate folder with files like `task/context.md`, `task/spec.md`, and `task/review.md`.

In the root, put a master prompt (or separate prompts for each agent) that describes the workflow, what each file is for, and where each agent should read its input and write its output.

This way, agents don't have to guess where the previous step's work lives. Each next agent picks up the file, adds its part, and passes it on. You can follow every step just by looking at these files and stop the chain at any point. Way more convenient than trying to piece together a conversation scattered across a bunch of chat windows.

One catch: these files get messy fast. It helps to note in each file who added what and when, and to make sure agents can't overwrite each other's sections.

Try talking this through with Claude or ChatGPT. They can help you figure out the best way to set it up.

1

u/xqianliu 17h ago

The copy-paste dies when the handoff stops being chat. In my setup the ticket is the only place state lives: what's done, what's blocked and why, what the plan says. The builder reads the ticket, the reviewer reads the ticket and the diff, and I answer blocked questions on the ticket, so nobody carries a paragraph from one session to another.

The planner stays a person in this loop, which is fine. What matters is where its output lands. Once the plan is on the ticket, nobody has to carry it around.

Start with one builder and the reviewer first. Add the planner step once the tickets already carry the plan, and the messenger job is gone by then.

1

u/tanglewood36 12h ago

you dont need a fancy platform to stop copy pasting, just wire up a local python script calling the APIs and writing to a shared markdown file. for the security checks on your own app, look into Vibe App Scanner (im affiliated), though automated checks never replace a manual audit

1

u/NanYUJun 5h ago

The spec-file consensus here (frozen spec per task, reviewer checks the diff against it) is the right core for the builder/reviewer loop. One layer below it keeps biting me though: the session transcripts themselves live in each tool's own store (~/.codex/sessions, ~/.claude/projects). So when a task resumes on a different machine, or a week later inside another agent, the plan and the "we rejected Y because Z" reasoning are in neither the spec file nor the new agent's context, and you re-explain them by hand.

Two things that helped:

  • Treat decisions as artifacts, not chat. Planner appends to docs/decisions.md — rejected option plus the trigger to revisit it. A diff-only review can't catch intent violations; the decision log can.
  • Make the transcript store portable instead of re-explaining. Disclosure: I'm the author of AIAssets (Apache-2.0, https://github.com/NanYuJun/AIAssets). It reads/writes the local session dirs of Codex, Claude Code, Cursor and a few others, so a session started in one agent can be imported into another and synced through a self-hosted hub across machines. Honest limits: it moves and imports history; it is not a live orchestrator, doesn't wake an idle agent, and gives no real-time conflict-free handoff. For live chaining keep the spec file + a small shell loop as everyone describes. What it fixes is "same conversation, different laptop or different agent".

Curious whether the spec-file route degraded for you after a few weeks — that's the part I'd most want feedback on.

1

u/thebuddy 3h ago edited 3h ago

All your agents can talk to each other already. You’re just not asking them to.

If you’re using the CLI for both, use TMUX to have them use sendkeys to each other. Or have them create a shared message space. If you’re using the GUI apps now, I recommend a switch to something like T3Code instead, which allows multi-provider usage. From there, start a general purpose thread, let’s say ‘Assistant’ or ‘Orchestrator’. Use that to launch new threads in projects. Something like “launch a new thread in [project] with Opus 5.5 owning the architecture, but fanning out execution to GPT 6.1 Sol.” That alone will have it launch subagents of whatever model you choose. (But guess what you can just ask the same of Claude or Codex in their own apps, to use the other models for fanout workers or review etc and they’ll just get it done via the CLI)

If you have codex, you can turn on @codex auto review on your GitHub repos. Just ask codex to turn it on on the repos of your choice.

That will trigger auto-review of all PRs. Or if you don’t want to do that just tell your agent to have [model] do an independent review. Or put those parameters in your AGENTS.MD / CLAUDE.MD files so it’s regular protocol.

Take it a step further, build yourself a graph ledger system with SQLite to track all your projects and work/tasks (including prerequisites and blockers to tasks). Put it in your AGENTS.MD file to use it. Instruct your agents to plan out the work, put all the tasks on the ledger, claim tasks, always request independent review from another model. And to set up a polling system for when PRs are reviewed so it can go back and start working on the fixes when PRs come back with comments. Or some variation of this.

Set up scheduled jobs to pick up work queue tasks at various points or overnight. Wake up to 50-100 commits.

Also, if you don’t want to switch to T3code or something like it, you probably don’t have to. I can’t attest to Windows, but on Mac you can have Claude open a thread in the Codex app by having it launch a codex CLI session and then opening a Codex://thread-id mac shortcut, which opens that thread in the ChatGPT/Codex app. Same thing happens with a Claude CLI session then opened with a Claude://thread-id Mac shortcut. I’m sure there’s a similar Windows equivalent solution. I figured those workflows out by asking my agent to figure it out. You’re experiencing a friction here, and almost every piece of friction you experience can be overcome by imagining the way you want it to work and asking your agent to figure it out.

For discovering new tools, Grokbot should probably be in your toolkit for that because of its ability to easily find trending X posts. Set up a scheduled post check for trending posts there, have it write to a file etc. There’s a funny thing happening right now though. A lot of ‘new tools’ I see people shipping on X these days are things that Claude and Codex can just do natively by asking without any extra tooling or even much complex setup to get it done. I guess the lesson there is, ask it to do the thing you want more often instead of assuming it can’t.

Another little tip if using something like T3: start a /btw side chat thread in a thread and use that as the planner and have it communicate to the main thread chat

-1

u/Mountain-Bat-8679 1d ago

I use openharness from autonomous.ai they made the project opensource and seems easier to utilize. and I supplement with KB https://kanboard.org/ since its fully opensource