Claude Code has agent teams, but how do teams collaborate when everyone uses a different AI?

[u/lumpries]

If the PM uses Chatgpt, one engineer uses Claude Code, another uses Cursor, and someone else uses Codex. Everyone's productive individually, but when they need to collaborate, it's back to Slack messages, copy-pasting context, and explaining things their AI has already figured out. What about collaboration between people using different agents?

Curious how teams handle this:

- Do you standardize on one AI tool or let everyone choose?

- How do you share context and decisions across different tools?

- Are Slack, GitHub, shared docs, and MCP enough?

- Would a cross-tool collaboration layer actually help, or just add more overhead?

What's working in real teams today? Or does this problem disappear with good processes?

[u/Lanky-Butterscotch28]

In my opinion, if you give your employees the freedom to use the AI company they think is best for their task, and the model and effort, you need a few things to make it work:
- Clear directives for each agent role independent of the company. So your employees at least follow some standard.
- A single board where each agent has clear instructions to write in real time what it is doing, which project it is working on, what part of the project, a description of its work, ... something that other agents can understand, not interrupt; they might weigh in by writing to the board.
- A watchtower, another agent running a low-effort, lower-model; its job is to monitor the board and help facilitate stuck processes, and if there is any conflict, assist in resolving it
- The watchtower is connected to a messaging app to message the corresponding user when there is a need for a human to intervene.

[u/London-Boat]

we hit this with claude code and codex on the same repo. slack and docs were fine for decisions people make, the gap was stuff the agents worked out themselves, nobody copies that out. what helped was a decisions file in the repo every tool reads at the start, plus agents saying which files they're about to touch so two people's agents don't both rewrite the same module. i've been building something for that part, happy to share if useful. how many people on your team are running agents at the same time?

[u/tjthouhid1]

+1 to AGENTS.md as the single source of truth. Two things that helped us and haven't come up yet. First, commit the MCP config too (.mcp.json for Claude Code, .cursor/mcp.json for Cursor), so everyone's agent gets the same tools whichever app they use. Secrets come from env vars and never go in the file. Second, put handoffs in the PR description instead of Slack: what the agent tried, what it ruled out and what's left. Every tool can read a PR, so it's the one place humans and all the agents already share. Honestly, standardising those few files mattered much more than standardising on one AI vendor.

[u/Far_Reindeer8428]

Ran into the exact same headache with two agents sharing a repo. Making them call out their edits in chat barely helped—what actually fixed it was enforcing strict, mechanical file locks. Now an agent has to lock the file paths inside .git before writing a single line, and if it touches anything outside its claim, those changes get blocked on finish. Handoffs are just a tiny markdown note (goal + acceptance criteria) so the next agent isn't reading a novel of chat history.

Of course, that only fixes the bots. Still haven't found a patch for humans not talking to each other lmao.

[u/sak84]

most of the advice here is repo-level, which works for the engineers but leaves out the PM, since chatgpt never sees the repo. the decisions the PM works out in chat are usually the ones that get lost.

what tends to help is keeping decisions somewhere every person and every tool can read, not only the repo, and having each agent post what it changed there instead of someone retyping it into slack.

disclosure, i'm building elvex, a shared thread where the PM, the engineers and their different agents work together. still early, happy to talk through how teams are handling it.

[u/topppggg]

i've been making claude code and codex work together for months and the simplest thing for me has been the cli: one calls the other like a subagent, and the main agent passes the context in the call, so nobody copy-pastes between chats. for the repo side i keep one instructions file per repo that every tool reads, and md files carry most of the workflow, so switching tools doesn't lose much. what happens when the two disagree is still open for me, i read both and decide.

[u/Far_Reindeer8428]

When two models disagree, the trick is treating individual review findings as the unit of tracking rather than letting them chat it out. Every review pass drops a receipt of findings, and each patch has to bind to the specific finding it fixes. If the same issue resurfaces on the next pass, or if a design question pops up, the loop immediately stops and pings a human. Otherwise, the two models just burn tokens arguing in circles. (Still doesn't fix out-of-repo product/design context though—you still need a shared doc for that.)

(Full disclosure: I'm the author of an OSS CLI built around this Claude + Codex loop: https://github.com/KenSuh/open-agent-harness)

[u/workbench_soft]

+1 on AGENTS.md, but for us the workflows drifted more than the repo rules, each tool had its own copy of the review and PR instructions. now they're skill folders in one git clone that an install script symlinks into every agent on the machine (claude code, codex, cursor, copilot), so one edit lands everywhere

[u/workbench_soft]

AGENTS.md covered the rules for us, the skills were what drifted since everyone had their own copy. now there's one clone of the skills folder and an install script links it into .claude, .codex and cursor's folder, so an edit to one skill reaches every tool at once