--- title: "Cork vs Augment Intent: a shared plan, or live shared state · Cork" description: "Cork vs Augment Intent: Intent coordinates agents around a living spec in isolated worktrees; Cork shares what every agent is changing, per symbol, as it writes." canonical: "https://corkcli.com/blog/cork-vs-augment-intent" last_updated: "2026-11-14" published: "2026-10-19" author: "Kevin Vera" --- # Cork vs Augment Intent: a shared plan, or live shared state Cork vs Augment Intent: Intent coordinates agents around a living spec in isolated worktrees; Cork shares what every agent is changing, per symbol, as it writes. By Kevin Vera · October 19, 2026 · [Comparisons](https://corkcli.com/blog/c/comparisons) · 9 min read How is Cork different from Augment's Intent? Intent is a desktop workspace for running coding agents: a coordinator agent writes a living spec for each task, implementor agents work from that spec in isolated [git worktrees](https://corkcli.com/blog/git-worktrees-parallel-ai-coding-agents), and a verifier checks the result against it. You can bring your own agent (Claude Code, Codex, OpenCode and others), and Augment recommends its Context Engine for the coordinator. Cork does not plan work or host agents: it is the layer under the agents you already run that tells each one, live and per symbol, what every other agent on the repo, yours and your teammates', is changing. The short version: Intent gives agents a shared plan; Cork gives them shared state. Of all the tools we compare against, Intent is the closest in spirit: both are built on the idea that agents fail for lack of shared context. They put that context in different places. ## Cork vs Intent at a glance | Topic | Cork | Intent (as of October 2026) | | --- | --- | --- | | What it is | [Coordination layer](https://corkcli.com/blog/coordination-layer-ai-coding-agents) for multiple AI coding agents and teammates on one codebase | A workspace app for coordinating coding agents around a living spec | | What agents share | Live state of the code: who changed which symbol, new signatures, callers, notes and messages | A spec "that evolves as agents make progress", written by a coordinator agent | | Isolation | Agents can work on the same code; edits against live work are held | "Every task is isolated in a workspace", each backed by a git worktree | | Agents | Claude Code, Codex and Cursor via hooks, plus any MCP client | Augment Auggie, Claude Code, Codex, OpenCode, Google Antigravity, Grok Build, Pi, Unsloth, and custom agents | | Codebase context | Symbol structure parsed on your machine (names, signatures, docstrings, line hashes) | Augment's Context Engine, recommended for the coordinator; also available over MCP | | Where it runs | Hooks in your existing agents; local server for Cork Free | Desktop app (macOS; Windows and Linux in alpha) and a mobile remote-control app | | Teams | Teammates' machines and agents share one state (paid plan) | We found no page describing several people sharing one Intent workspace | | Pricing | Free (local, and 10 agent hours a month in the cloud); $20 a month per 100 agent hours, pooled | Intent is a free app; agent and Context Engine usage is billed under Augment's plans ($20 and $100/mo tiers, Enterprise custom) when you use Augment | ## What is Intent? Augment Code introduced Intent on February 10, 2026, in "Intent: A workspace for agent orchestration." Its home is now intentapp.dev (augmentcode.com/intent redirects there). The site's pitch: "Large-scale agent coordination for developers." How it works, in Intent's and Augment's words: - **A living spec.** "Work starts from a spec that evolves as agents make progress." The docs: "Each workspace can start with a living spec that captures assumptions, requirements, and design decisions." - **Coordinator, implementors, verifier.** "A coordinator agent uses Augment's Context Engine to understand your task and propose a plan as a spec ... the coordinator fans work out to implementor agents ... a verifier agent checks the results against the spec." On the homepage: "A Coordinator agent writes a spec for every task, so each agent in a workspace works from the same plan instead of its own guess." - **Isolation.** "Every task is isolated in a workspace, so agents never step on each other," and "each workspace is backed by an isolated git worktree" on its own branch. Git is built in: "commit, review, and merge happen in place." - **Bring your own agent.** "Everything's swappable: run your favorite CLI agents, mix them per workspace, and easily add your own custom agents." Augment says it recommends "using Augment for its Context Engine, but developers aren't locked in to a single provider." The Context Engine is Augment's semantic index of a codebase, and it is also offered on its own over MCP, locally through the Auggie CLI or hosted over HTTP. ## What is Cork? Cork (corkcli.com, by Lithometric) keeps several AI coding agents, and the people running them, from overwriting each other on one codebase, and hands each agent what the others already learned. It does not host agents or machines: your agents run where they already run. Hooks in Claude Code, Codex and Cursor do the protocol with no extra model calls, and an MCP server (https://mcp.corkcli.com) serves any MCP client. The hooks send the structure of your code (symbol names, signatures, docstrings, line hashes), never the file text, and the server keeps no source lines. - **Briefing**: the exact signatures, callers and recent changes of the code an agent is about to touch, delivered at start and with each prompt. - **Live awareness**: a rename or new signature from another agent reaches yours on its next step. - **[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. - **[Semantic lint](https://corkcli.com/blog/semantic-lint)**: teammates' renames and signature changes become lint rules. - **Landing**: `git push` rebases onto teammates' commits, reruns tests and pushes in one step. - **Agent messaging** anchored to code, notes that go stale when their code changes, and a team dashboard (cloud plans). ## A shared plan vs live, symbol-level shared state Intent's answer to "agents step on each other" is to agree first and then separate: a coordinator writes down what everyone is doing, and each task runs in its own worktree. The spec is the shared context, and it is good at what a plan is good at: intent, requirements, decisions, the order of work. What a plan cannot hold is what happened in the code a minute ago. When the implementor in one worktree renames a function the implementor in another worktree calls, the spec does not change; the two worktrees meet at merge. When a teammate on another machine, outside the Intent workspace, edits the same module, the spec never hears of it. Cork's shared context is the code's own state, kept per symbol as agents write: this function was renamed by that agent; this signature gained a parameter; this agent is mid-change on that class right now. Each agent gets the slice it is about to touch in its briefing and in short deltas on its next step, and an edit against live work is held until the agent has the new version. No one has to write it down, and it covers every agent on the repo, planned or not. The two are not exclusive: a plan says what should happen, shared state says what did. ## Where Intent stands out - **Planning and verification.** A coordinator turns a request into a spec and a verifier checks results against it. Cork does neither. - **One app for the whole loop.** Workspaces, diffs, commit, review and merge in one place, plus a mobile app to steer work. - **Many agents, mixed per workspace.** A long list of supported CLI agents, plus custom ones. - **Deep codebase retrieval.** The Context Engine is a semantic index of the codebase, usable from Intent or over MCP. ## Where Cork wins - **Agents that can share code safely.** Intent keeps agents apart in worktrees until merge. Cork lets agents work on the same code at the same time and catches renames, removals and signature changes before a write lands. - **State nobody has to write down.** The briefing comes from the code: callers, signatures and who changed what, not from a document an agent kept up to date. - **Teams, not one desk.** Teammates' agents on other machines see the same live state (paid plan). We found no Intent page describing several people in one workspace. - **Your source stays home.** Cork's hooks parse files on your machine and send structure only; the server keeps no source lines. Cork Free runs entirely on your machine. - **Measured.** In Cork's [Study 5](https://corkcli.com/benchmarks/study-5-twelve-agents-53-percent) (12 Claude Code agents at once on one repository, hard tasks), agents with Cork used 53% fewer tokens than the same agents without it. ## Can you use both? Yes, in principle: Intent runs CLI agents such as Claude Code and Codex, and Cork's hooks are installed per machine for those same CLIs, so Claude Code or Codex sessions started from Intent on a machine with Cork installed would be briefed and gated like any other session. We have not tested this combination, so treat it as untested. The natural split is Intent's spec for what each agent should do, and Cork for what the other agents just did to the code they share. ## Pricing compared Intent's docs call it "a free desktop app". When it uses Augment's agent and Context Engine, usage comes out of Augment's plans; Augment's pricing page lists Standard at $20 a month and Business at $100 a month (each including that amount of usage, up to 50 seats), and custom Enterprise pricing, with "a flat 40% fee on LLM usage". With your own agents, you pay those agents' providers. Cork Free runs unlimited agents and repos on one machine with no account, with all data on the machine. 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. Beyond that you pay for agent hours, not seats: $20 a month per unit of 100 hours, pooled across the workspace, graduated to $17 (units 11 to 50) and $15 (51 and up), with 15% off a year. Every member is a player, with teammates' machines, prompt-to-code matching by meaning, shared knowledge and 90-day history. Enterprise starts from about 100 units. ## Bottom line Intent is the right tool if you want an app that plans work, fans it out to agents in isolated worktrees and verifies it against a spec. Cork is the right layer if your agents, and your teammates' agents, keep touching the same code: it shares what changed, per symbol, the moment it changes. A shared plan and live shared state solve different halves of the same problem. ## Frequently asked questions ### Is Intent made by Augment Code? Yes. Augment announced it on its blog in February 2026; it now lives at intentapp.dev, and augmentcode.com/intent redirects there. ### Does Intent require Augment's Context Engine? No. Augment recommends it for the coordinator, but says developers "aren't locked in to a single provider", and Intent runs other CLI agents. ### Does Intent stop two agents editing the same code? It keeps them apart: each task runs in its own isolated workspace backed by a git worktree, so their changes meet at merge. Cork lets them work on the same code and holds an edit that would collide with live work. ### Is Cork a spec or planning tool? No. Cork does not plan or assign work. It shares the live state of the code between agents, and shows it to people on the team dashboard (cloud plans). ### Which is closer to "shared context for agents"? Both, in different places: Intent's shared context is a spec the agents work from; Cork's is the code's current state, per symbol, kept for every agent on the repo. ## Sources Checked October 19, 2026: - (February 10, 2026; updated June 18, 2026) - - - - - - - ## Related reading - [Cork vs Cursor Projects: a coordinator for Cursor agents, or shared state for every agent](https://corkcli.com/blog/cork-vs-cursor-projects): Cork vs Cursor Projects: a Projects coordinator plans work and directs Cursor's agents with shared context files; Cork keeps any agents on one codebase aware of each other. - [Cork vs Vibe Kanban: a board for agents vs a guard for shared code](https://corkcli.com/blog/cork-vs-vibe-kanban): Cork vs Vibe Kanban: Vibe Kanban plans and runs coding agents in worktrees from a kanban board. Cork keeps parallel agents from colliding at merge. - [Cork vs Sculptor: an app for parallel agents, or a layer that keeps them from colliding](https://corkcli.com/blog/cork-vs-sculptor): Cork vs Sculptor: Imbue's Sculptor runs coding agents in parallel in isolated workspaces. Cork coordinates parallel agents and teammates on shared code. - [Cork vs Tutti VM: two answers to agents editing the same code](https://corkcli.com/blog/cork-vs-tutti-vm): Cork vs Tutti VM: Tutti VM shares agents' working state in a cloud Room. Cork coordinates multiple AI coding agents in your repo with hooks and git. [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-vs-augment-intent