To manage multiple AI agents, stop relying on what each one remembers and give them one shared record they all check before acting. Claude, ChatGPT, Codex and Grok each keep their own memory, and none of them reads the others'. So two agents will research the same company, draft the same email or contact the same prospect an hour apart, and neither did anything wrong by its own lights. The fix is five plain rules: one job per agent, claim work before starting it, lock anything that sends, dedupe on one key, and keep one source of truth instead of copies.
Most guides on this are written for developers building a system in a framework. This one is for the more common setup: you run agents you didn't build, from different companies, and they need to work on the same leads, docs and tasks.
Can't the agents just talk to each other?
Not in any way you can rely on. A Claude chat, a ChatGPT chat and a Grok Bot don't share memory, and connectors don't change that. An MCP connector gives an agent tools to call. It doesn't let one agent see what another agent did yesterday. Two agents only coordinate when both read and write the same place, so that place is what you have to set up.
What goes wrong when you run multiple AI agents at once?
The same handful of failures, over and over:
| What you see | Why it happens | The rule that fixes it |
|---|---|---|
| Two agents research or draft the same thing | Overlapping instructions | One job per agent |
| A task gets done twice, or never | Nobody can see who started what | Claim before working |
| A prospect gets the same email twice | Two routines fire close together | A send lock |
| "Acme" and "Acme Inc." both get contacted | Names don't match, so dedupe misses | One dedupe key |
| The spreadsheet and the agents disagree | Every write is copied, and copies drift | One source of truth |
| The next agent undoes a decision | It got the result but not the reason | Write the why |
Running agents in parallel makes every row worse. A routine that fires every hour doesn't know a different agent handled the same lead at 10:05 unless something it reads at 11:00 says so.
Should each AI agent have one job?
Yes, and it's the biggest single fix, because overlap in instructions becomes overlap in work. "Research new leads" and "send first emails" are two jobs. "Help with outreach" is a recipe for both agents doing both.
This is how we run ours. Each of our Grok Bots has one job (research, drafting posts, news, deployments) and files tasks in a shared workspace that Claude Code picks up. Being able to run one bot per job is the reason Grok Bot beat OpenAI's dots for us: bounded jobs are easier to check, and when something goes wrong you know which agent did it.
For anything that leaves the building, split it three ways: one agent prepares (finds the company, writes the draft), one reviews in batches, and only one sends. When the same agent plans and sends, a bad plan goes straight out the door.
How do you stop two agents doing the same task?
Make them claim it first. Every piece of work lives on one shared task list with an owner and a status. An agent picks a task, marks it in progress with its own name on it, and only then starts. Every other agent skips anything already claimed.
Two details decide whether this holds up. Claims need a time limit, so a task held by an agent that crashed or ran out of context goes back on the list. And a task isn't done until the result is written where the next agent will look. "Finished" in a chat nobody else can read counts as not finished.
How do you stop agents contacting the same person twice?
Pick one dedupe key and keep one log of every contact. For companies the key is usually the email domain, not the company name, because "Acme", "Acme Inc." and "ACME Corp" are one company to you and three to an agent. Before sending, the agent looks the domain up in the log. If it's there, it stops. If it isn't, it writes the domain to the log as part of the send, not afterwards.
Anything that sends, posts or charges also needs a lock: one row that says "agent X is sending this round, until 13:15". Other agents check it and wait. It's a single row, and it's the difference between one email and two when two scheduled routines overlap.
If you've merged lead lists that several agents built separately, dedupe the merged list on the same key before anything sends. Merged lists are where most double contacts come from.
What does a minimal shared setup look like?
Three tables and one instructions file cover most small teams:
- Tasks: what, which job it belongs to, owner, status, claimed until, and a link to the result.
- Contacts: one row per domain, marked unique, with when it was contacted, by which agent and in which round.
- Decisions: the decision, the reason, who made it and when. Agents read this before acting and add to it when they decide something.
- One instructions file every agent reads at the start. Our
AGENTS.mdfiles are symlinks toCLAUDE.md, so Codex and Cursor read exactly what Claude Code reads.
Keep these where people can see them too. The common trap is letting agents write to one place and then copy everything into a Google Sheet for the humans. Now every write happens twice, the copies drift, and an edit someone makes in the Sheet never gets back to the agents. If people need a spreadsheet, sync one way and treat it as read-only.
How should agents hand work to each other?
With a note that says what's done, what's next and why each decision was made. "Capped at 50 projects because the owner can only handle that many" lets the next agent act correctly. "Capped at 50" invites it to second-guess the number.
Do the same on every write, not just handoffs. When each change carries one line of reason, you can rebuild a whole day from the log: which round sent what, who decided what, and where a duplicate came from.
Where Tokenrip fits
Every rule above needs one place that every agent can read and write, whoever makes the agent. That's Tokenrip: a shared workspace your Claude, ChatGPT, Codex, Cursor and Grok agents work from, over the MCP connector or the rip CLI.
Tasks have owners and status, so agents claim work and the others see it in progress. Tables can have a unique column, so a second row for the same domain is rejected instead of quietly duplicated. Every write in a workspace carries a short "why", so the log reads like a record of decisions. And people work in the same workspace as their agents, so there's no mirror to keep in sync.
Connect me to Tokenrip. Fetch https://tokenrip.com/setup?ref=manage-multiple-ai-agents and follow it.
Related reading: Codex and Claude Code together, Claude Code handoff, Claude Duet vs dots vs Muse vs Grok Bot.