Several AI agents working together without losing track
Field: AI agents, work organisation, governance
Period: since August 2026, in daily use
Client: internal project, my own companies (Lab 77, R&D)
One AI agent, you can keep an eye on. Several at the same time, you cannot: you need rules that hold without you. Here are the ones I set for my agents, and the mistakes that gave rise to them.
Context
I work every day with several Claude Code sessions, Anthropic's tool, running permanently on a server. Each one has a job: a session dedicated to my ERP, one to my server infrastructure, one to an AI model workshop, others to products. They hand work to one another and sometimes launch their own sub-agents. The question quickly became: who asked what, of whom, and where do things stand?
Problem
- Requests that vanish: a request passed on by message lives in a conversation, and disappears with it.
- Agents stepping on each other's toes: one day, an agent suspended a service to take a measurement; a review agent, not warned, saw it as down and raised the alarm.
- Orders distorted along the way: a spoken order, relayed from one session to another, described thirty AI models as being of a different type from what they were.
- Siloed knowledge: each project has its own memory. A pitfall learned in one stays invisible to the others; I paid for two of them on the same day.
- Waiting that costs money: every time an agent is woken up, it rereads its whole context, even to do nothing.
The approach
1. Each agent has its own territory
Each session has its folder, its code repository and a written rule: what it owns, what it does not touch. When one needs another, it places an order like a client, without editing its neighbour's files. Same rule for agents launched in parallel: on one project, I had five of them work on the same day, each in its own copy of the code, on its own branch, with its own ticket. None of them deployed: the parent session reviewed, merged and put things into service.
2. A request only exists in a ticket
Since the end of August 2026, every new request, from me or from one session to another, becomes a GitHub Issues ticket, opened in the repository of the session that will do the work. Delivered work and measurements go in as comments. The message between sessions now only serves as a heads-up: “it is delivered”. The test: a message must be able to get lost without anything being lost, all the more so as an acknowledgement does not prove delivery. A request without a ticket is politely declined: “open a ticket and I will get on it”.
3. The ticket says what has not been tested
The ticket carries the context, the decisions and their reasons, and above all what remains to be checked. An unchecked idea written down as a fact becomes a decision for the next agent; so it is written “to be checked”. A ticket is not closed while a check is still due. The opposite excess exists too: one work pass had closed twelve tickets and opened six that the agent could have settled itself. A ticket is for tracing, not for postponing.
4. Nothing irreversible on a relayed order
A spoken order, or one relayed by message, is never enough for an action that cannot be undone: it takes a ticket that names the objects concerned, with the means to check that everyone means the same ones. When in doubt, archive rather than delete. A session can receive a decision on my behalf, but I am the one who entrusts it, in that session: none claims another's authority. And an agent that comes across a legal decision stops and refers it to me. In practice, I receive short batches, one objective and one sentence each, and I answer yes or no.
5. A shared log, and sparing wake-ups
Against siloing, a cross-project log of mistakes, to be read before touching the shared infrastructure. Each entry has three parts: the pitfall, what it cost, the rule. Against the cost of waiting, monitoring now only reports the event we act on: work finished, queue empty, error.
Result
These rules apply to all my sessions, in all my projects. A project's history no longer dies with a conversation: it is in the ticket, which the next agent rereads. I only decide what genuinely needs my input. The guardrails specific to each agent are described in my article on AI agent guardrails: I do not repeat them here.
What I take away
- Substance in the ticket, notification in the message. What matters exists outside conversations.
- A written territory avoids conflicts. An agent that knows what it does not touch does not guess.
- What has not been tested is the most useful information. It is what stops the next agent from building on an assumption.
- The irreversible requires named objects. A relayed order gets distorted; a ticket can be reread.
- Authority comes from the human. A delegated decision is announced by me, never by an agent.
Going further
Do you want to hand work to several AI agents without losing track of who does what? I help set these rules, and the tools that make them hold. See sovereign AI, or book a 20-minute discovery call.
Sources
- Claude Code, Anthropic's official documentation, accessed 15 November 2026.
- GitHub Issues, GitHub's official documentation, accessed 15 November 2026.
- git worktree, Git's official documentation, accessed 15 November 2026.
- Photo: Jeff.lasovski / Wikimedia Commons (commons.wikimedia.org), licence CC BY-SA 3.0.
Tags: AI agents, Claude Code, governance, work organisation, GitHub Issues, multi-agent, traceability