--- title: "What data an agent coordination tool needs (and what it should not see) · Cork" description: "What data an AI agent coordination tool needs to stop agents overwriting each other, what it should never see, and the questions to ask before you install one." canonical: "https://corkcli.com/blog/agent-coordination-tool-data-privacy" last_updated: "2026-11-14" published: "2026-10-03" author: "Kevin Vera" --- # What data an agent coordination tool needs (and what it should not see) What data an AI agent coordination tool needs to stop agents overwriting each other, what it should never see, and the questions to ask before you install one. By Kevin Vera · October 3, 2026 · [Guides](https://corkcli.com/blog/c/guides) · 6 min read An agent coordination tool needs to know where agents are working and what they changed: the repository, file paths, symbol names and signatures, which symbols depend on which, and when each agent edited what. It does not need your secrets, your full conversation transcripts, or a copy of your whole codebase on someone else's server, and a well-designed tool can do its job without them. Before you install one, ask what leaves the machine, how long it is kept, and who on your team can see it. ## Why coordination needs any data at all Coordinating agents means answering questions like: is another agent editing this function right now? Did someone just rename something my agent calls? Has this problem already been solved today? Each answer needs a small, specific fact about another agent's work. The design goal is to share those facts and nothing more. It helps to separate three kinds of data: 1. **Structure:** what exists in the code (files, functions, classes, signatures, call relationships). 2. **Activity:** what agents are doing (which symbols an agent is editing, what it changed, when, test results). 3. **Content:** the actual code, prompts, conversations and environment. Coordination mostly runs on structure and activity. Content is where the risk is. ## What a coordination tool genuinely needs - **Repository identity.** Which repo (and which branch or worktree) an agent is in, so it is only compared with agents on the same code. - **File paths and symbol names.** `billing/invoice.py::total_due` is enough to detect that two agents are on the same function. A collision check does not need the function body. - **Signatures and dependencies.** To warn that a rename broke a caller, the tool needs the old and new signature and the list of callers. This is a code graph: names and edges. - **Edit events.** "Agent B changed `total_due` at 10:02 and its signature changed." Timestamps and agent identifiers make it possible to tell a stale view from a live one. - **Agent and person identity.** Which session, and on a team, which person. Without this, a warning cannot say whose work it is or route a message. - **Outcomes.** Whether tests passed after a change, so other agents know whether to build on it. - **Durable notes, if you choose to write them.** Decisions such as "do not cache this, the upstream changes hourly," anchored to a symbol. Some features need more. Matching a plain-language prompt to the code it is about needs either the prompt text or a representation of it (such as an embedding). Rebasing and rerunning tests needs the working tree, which stays on your machine. Ask where each of these happens. ## What it should not see - **Secrets.** `.env` files, keys, tokens and credentials have no coordination value. Agents themselves can be fenced off from them; in Claude Code, a permission deny rule such as `Read(./.env)` or `Read(./secrets/**)` blocks the file tools from reading those paths. A coordination tool should never need them either. - **Full transcripts.** Agent hooks receive a lot of context. A Claude Code hook gets JSON on stdin that includes `session_id`, `cwd`, `tool_name`, `tool_input` and a `transcript_path` pointing at the whole conversation. A coordination hook does not need to read that transcript to detect a collision. If a tool uploads transcripts, ask why. - **Whole file contents by default.** Symbol names and signatures cover most coordination. If a tool sends code bodies to a server, it should say so plainly and say why. - **Anything outside the repo.** Your home directory, other projects and shell history are out of scope. A useful test: if the tool's server were breached, what would an attacker learn? "Agent 3 edited `total_due` at 10:02" is low risk. A copy of every prompt and every file is not. ## Questions to ask before you install one 1. **What runs locally and what goes to a server?** Can it run fully on one machine? 2. **What exactly is sent?** Paths and symbols, or code bodies, prompts and transcripts? 3. **Does it call a model with my data?** Extra model calls cost tokens and send content to another provider. 4. **How long is data kept?** Is there a history window, and can it be shortened? 5. **Who can see it?** Only my agents, my team, or the vendor's staff? 6. **What identity and admin controls exist?** SSO, audit or compliance export, removing a departed teammate. 7. **How do I remove it?** Is there a clean uninstall, and what happens to local data? ## How the hooks themselves see your data Coordination tools usually plug into agents through hooks, so it is worth knowing what a hook receives. In Claude Code, hooks run as commands you configure in `~/.claude/settings.json` (all your projects), `.claude/settings.json` (shared with the repo) or `.claude/settings.local.json` (yours, not committed). Codex reads hooks from `~/.codex/hooks.json` or `/.codex/hooks.json`, and asks you to review and trust a non-managed hook before it runs. Cursor reads `~/.cursor/hooks.json` or `.cursor/hooks.json`. Because hooks run with your user's permissions, read any hook command before you trust it, the same as any script you install. ## How Cork helps Cork is the [coordination layer](https://corkcli.com/blog/coordination-layer-ai-coding-agents) for multiplayer coding agents: it keeps Claude Code, Codex and Cursor agents, on one machine or across a team's machines, from overwriting each other on one codebase, and hands each agent what the others already learned. How it maps to the questions above, from what Cork publishes: - **Local first.** Cork Free runs on one machine with no account, and all data stays on the machine. Unlimited agents and repos. - **No extra model calls.** Hooks in Claude Code, Codex and Cursor do the protocol with no extra model calls. - **Shared only when you choose a team.** On the paid plan, agents on teammates' machines see each other, and the plan adds prompts matched to code by meaning (an embedding model) and shared knowledge. That is the point at which data is shared beyond one machine. - **Retention you can name.** Cloud Free has a 30-day history window, the paid plan 90 days, and Enterprise custom retention. - **Admin controls.** Enterprise adds SAML or SCIM provisioning. Cork does not run your agents or host your machines. Install it with: ```bash curl -fsSL https://corkcli.com/install.sh | sh ``` ## Frequently asked questions ### Does an agent coordination tool need my source code? Mostly not. Detecting collisions and broken callers needs file paths, symbol names, signatures and edit events. Ask any vendor which features send code bodies and why. ### Can AI agent hooks read my conversation transcripts? They can be given a path to them. Claude Code hook input includes `transcript_path`. Whether a tool reads it is up to the tool, so check its documentation and read the hook command. ### How do I stop AI coding agents from reading .env files? In Claude Code, add permission deny rules such as `Read(./.env)` and `Read(./secrets/**)` to your settings. Also keep secrets out of git and run a secret scanner such as gitleaks before commits. ### Is it safe to use a coordination tool on a private repository? It can be, if you know what leaves the machine. Prefer a tool that can run fully locally, shares only structure and activity by default, states its retention, and offers SSO and export if you need them. ## Sources - - - - - ## Related reading - [Cork Free: set up multiplayer coding agents on one machine in one command](https://corkcli.com/blog/cork-free-setup-one-machine): Set up Cork Free in one command so Claude Code, Codex and Cursor agents on one machine stop overwriting each other. No account; data stays on the machine. - [Cork vs Superconductor: a hosted agent workspace, or coordination for the agents you run](https://corkcli.com/blog/cork-vs-superconductor): Cork vs Superconductor: Superconductor runs coding agents in cloud sandboxes for teams. Cork stops parallel agents from overwriting each other's code. - [Cork vs AQ: a shared cloud workspace, or a coordination layer for the agents you already run](https://corkcli.com/blog/cork-vs-aq): Cork vs AQ: AQ hosts multiplayer cloud workspaces for coding agents. Cork coordinates the agents you already run so they stop overwriting each other. - [Cork vs HumanLayer: an agent IDE for teams, or coordination under any tool](https://corkcli.com/blog/cork-vs-humanlayer): Cork vs HumanLayer: HumanLayer is a multiplayer coding agent IDE and cloud; Cork keeps parallel agents from overwriting each other wherever they run. [All articles](https://corkcli.com/blog.md) · [Cork in Markdown](https://corkcli.com/index.md) · [llms.txt](https://corkcli.com/llms.txt) This page in HTML: https://corkcli.com/blog/agent-coordination-tool-data-privacy