---
title: "Cork Free: set up multiplayer coding agents on one machine in one command · Cork"
description: "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."
canonical: "https://corkcli.com/blog/cork-free-setup-one-machine"
last_updated: "2026-11-14"
published: "2026-10-03"
author: "Kevin Vera"
---

# Cork Free: set up multiplayer coding agents on one machine in one command

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.

By Kevin Vera · October 3, 2026 · [Guides](https://corkcli.com/blog/c/guides) · 6 min read

To run several coding agents on one machine without them overwriting each other, install Cork Free with one command: `curl -fsSL https://corkcli.com/install.sh | sh`. It sets up every repo on the machine, wires hooks into Claude Code, Codex and Cursor, and registers Cork's MCP tools for all three. There is no account and no sign-up: Cork Free covers unlimited agents and repos on one machine, and all data stays on the machine.

## The problem on one machine

Running two or three agents at once is now normal: Claude Code fixing a bug in one terminal, Codex writing tests in another, a Cursor agent refactoring in the editor. On one checkout, they share files. When two of them edit the same function, the second write wins and the first agent never knows. When one renames a function, the others keep calling the old name until the tests fail.

The usual workarounds each give something up:

- **Separate worktrees** keep files apart while the agents work, but the changes still meet at merge time.
- **Splitting work by directory** avoids collisions by avoiding parallel work on related code.
- **Watching every terminal** works for two agents and stops working at four.

Cork takes a different approach: let agents share the code, and give each one awareness of the others.

## Install

Run this once per machine:

```bash
curl -fsSL https://corkcli.com/install.sh | sh
```

What the install does:

- Covers **every repo on the machine**. You do not set Cork up per project.
- Adds **hooks** to Claude Code, Codex and Cursor, which run the protocol for your agents with no extra model calls.
- Registers **Cork's MCP tools** for Claude Code, Codex and Cursor.

If you already have an agent session open when you install, you do not need to restart it: a session already open is told about Cork at its next prompt.

To confirm what Cork did on the machine:

```bash
cork status
```

## What changes for your agents

Once installed, you keep working the way you did. Start agents in any repo, in any of the three tools. Cork's hooks add four things.

**A briefing before work starts.** When an agent starts or gets a prompt, it is handed the exact signatures, callers and recent changes of the code it is about to touch. It searches less, because it already knows what is there and what just changed.

**Live awareness.** When another agent changes code yours depends on, such as a rename or a new signature, your agent hears it on its next step instead of finding out from a failing test.

**A [write gate](https://corkcli.com/blog/write-gate).** An edit against code another agent is changing right now is held until your agent has their version. This is the case where two agents would otherwise overwrite each other.

**[Semantic lint](https://corkcli.com/blog/semantic-lint).** A rename or signature change by one agent becomes a lint rule the other agents are checked against, so stale call sites are caught.

There is also a landing step: `git push` becomes one step that rebases onto other commits, reruns the tests and pushes.

## Try it: two agents, one function

A quick way to see Cork work:

1. Open a repo you know. Start a Claude Code session in one terminal and a Codex session in another, in the same checkout.
2. Ask the first agent to rename a widely used helper function and update its callers.
3. While it works, ask the second agent to add a new feature that calls that helper.
4. Watch the second agent's output. It hears about the rename on its next step, and if it tries to edit the same code the first agent is changing, its edit is held until it has the first agent's version.

You can also have the agents talk. From your shell:

```bash
cork message "I'm refactoring the payment client; hold off on billing/ for 10 minutes"
```

That messages the other agents in the repo. See our guide on messaging between your coding agents with `cork message` for targeting one agent or whoever is working on a given function.

## Add Cork's section to AGENTS.md

Cork's hooks do the work, but it helps if every agent also reads a short description of the protocol in the repo's instructions. Run this in a repo:

```bash
cork agents-md
```

It adds Cork's section to the repo's `AGENTS.md`.

## Use the MCP tools

Because the install registers Cork's MCP tools, your agents can call them when they need more than the briefing:

- **get_symbol**: the facts about one symbol.
- **blast_radius**: what depends on the code you are about to change.
- **recap**: what happened, and what it cost.
- **remember / recall**: durable notes anchored to code.

Ask in plain language, for example "use blast_radius before changing `parse_config`." Our guide on getting started with Cork's MCP tools covers each one.

## What Cork Free is, and is not

Cork Free is:

- Unlimited agents and unlimited repos on one machine.
- No account.
- All data stays on the machine.

It does not cover agents on other people's machines; that is the paid plan. Cork also does not run agents, host machines, provide sandboxes or a code editor. Your agents keep running where they already run.

If you later want an account, Cloud Free gives each account 10 agent hours a month (30 bonus hours the first month), unlimited repos and agents, and a 30-day history window; `cork login` links a machine to an account.

To remove Cork:

```bash
cork uninstall
```

That removes the hooks and keeps your local data in `~/.cork/local`.

## 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.

On one machine, that means you can run as many agents as your work needs on the same checkout, in different tools, without babysitting their terminals. Install once:

```bash
curl -fsSL https://corkcli.com/install.sh | sh
```

## Frequently asked questions

### Do I need an account to use Cork Free?

No. Cork Free has no account, and all data stays on the machine. You only link an account with `cork login` if you want Cloud Free or a paid plan.

### Does Cork work with Claude Code, Codex and Cursor at the same time?

Yes. The install adds hooks and registers Cork's MCP tools for all three, so agents in different tools on the same repo coordinate through the same protocol.

### Do I have to restart my agent sessions after installing?

No. A session already open when Cork is installed is told at its next prompt.

### How do I uninstall Cork?

Run `cork uninstall`. It removes the hooks and keeps your local data in `~/.cork/local`.

## Sources

- <https://corkcli.com>

## Related reading

- [Cork vs Amp: one agent in many orbs, or many agents on one codebase](https://corkcli.com/blog/cork-vs-amp): Cork vs Amp: Amp runs its agent in cloud orbs you can share. Cork keeps Claude Code, Codex and Cursor agents from overwriting each other on one repo.
- [What data an agent coordination tool needs (and what it should not see)](https://corkcli.com/blog/agent-coordination-tool-data-privacy): 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.
- [How to stop Claude Code agents from overwriting each other's changes](https://corkcli.com/blog/stop-claude-code-agents-overwriting-changes): Why parallel Claude Code agents overwrite each other's edits, and how to stop it with worktrees, file ownership, deny rules, PreToolUse hooks and a write gate.
- [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.

[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/cork-free-setup-one-machine