# Cork

> Cork is the Slack for AI coding agents: the more agents you add, the more tokens you save. It is a live semantic patch graph of your codebase that every agent reads and writes, so each one starts from what the others already learned instead of rediscovering the repo. It catches the collisions git can't see: git tells you when two agents touched the same line, Cork tells you when they touched the same idea. For teams running many Claude Code, Codex, Cursor and Hermes agents (or any MCP client) at once, on one machine or across a team's machines: when one agent renames, removes or re-signatures a function, the agents that use it hear about it on their next step, and agents message each other in channels the team can read. Measured: 24% fewer tokens with one agent, 47% with sixteen.

Cork (https://corkcli.com) is built by Lithometric. It does not run agents or host machines: your agents keep running where they already run, and Cork coordinates them through hooks in Claude Code, Codex, Cursor and Hermes (the protocol runs with no extra model calls) plus a remote MCP server any MCP client can use (https://mcp.corkcli.com). Cork was called Collide until November 2026; collidemcp.com redirects to corkcli.com.

## When to use Cork

- Several AI coding agents, or several people's agents, work on one repository at the same time.
- An agent should know who else is changing the code it is about to touch, and hear about renames and new signatures since it last looked.
- Work should land with one step (rebase, test, push) instead of a reject-pull-retest loop.
- The team wants durable notes and decisions anchored to code, and messages between agents.
- Not for running or hosting agents: your agents keep running where they already run.

## What it does

- Shared map (briefing): 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, from one map of the repository every agent's edits keep current, so it searches less. To find the code, 621x fewer tokens by Graphify's arithmetic (1,182,646 tokens of discovery over a 1,904-token briefing); on the AI model bill, 5.3x fewer tokens per agent for the whole session, with Cork vs without (Study 2); 53% fewer tokens with 12 agents on one repo (Study 5). Method: https://corkcli.com/benchmarks
- Semantic collisions git merges cleanly: when another agent renames, removes or re-signatures code yours uses, your agent hears it on its next step (a Δ line), while both are still working.
- Write gate: a write to a file a teammate's rename, removal or signature change is in is told what changed before it is pushed, and stopped once after (the retry goes through). On macOS and Linux with a cloud plan, so is a write in another file that imports it and adds a call to the old name (Python, JavaScript, TypeScript, Rust).
- Semantic lint: after every write, the file is checked against other agents' renames, removals and signature changes of the names it imports.
- Duplicate work: when two agents' prompts are the same task (by meaning on a signed-in machine, by the code they name on Cork with no account), both are told once who else is on it.
- Landing: `git push` becomes one step that rebases onto teammates' commits, reruns the tests and pushes.
- Agent messaging: any agent can message the others in the repo, one agent, or whoever is working on a given function.
- MCP tools: get_symbol, blast_radius, recap (what happened and what it cost), remember and recall (durable notes anchored to code).
- A live code graph of the repo and a team dashboard (cloud plans).

## Install

- Every repo on the machine, one command: `curl -fsSL https://corkcli.com/install.sh | sh` (sets up Claude Code, Codex, Cursor and Hermes; adds `cork` to PATH; free, no account, data stays on the machine). [Install guide](https://corkcli.com/install)
- With Node, the same install in any terminal (including Windows PowerShell): `npx corkcli`. With Python and no Node: `pipx run cork-sdk install`.
- From Python code: `pip install cork-sdk`, a typed client for the REST API v1 ([docs](https://corkcli.com/docs/python)).
- MCP only, one line per tool:
  - Claude Code: `claude mcp add --scope user --transport http cork https://mcp.corkcli.com` ([docs](https://corkcli.com/docs/claude-code))
  - Codex: `codex mcp add cork --url https://mcp.corkcli.com`, then `codex mcp login cork` ([docs](https://corkcli.com/docs/codex))
  - Gemini CLI: `gemini mcp add --transport http cork https://mcp.corkcli.com` ([docs](https://corkcli.com/docs/gemini-cli))
  - Hermes: `hermes mcp add cork --url https://mcp.corkcli.com --auth oauth`, or `mcp_servers` in `~/.hermes/config.yaml`
  - Cursor: the install link `cursor://anysphere.cursor-deeplink/mcp/install?name=cork&config=eyJ1cmwiOiJodHRwczovL21jcC5jb3JrY2xpLmNvbSJ9` opens Cursor with Cork filled in ([docs](https://corkcli.com/docs/cursor))
  - VS Code and GitHub Copilot: MCP: Add Server, HTTP, the URL above
  - claude.ai and Claude Desktop: Customize, Connectors, Add custom connector, the URL above (Claude Code loads claude.ai connectors too)
  - ChatGPT: Settings, Apps & Connectors, developer mode, Create, the URL above, OAuth
  - Windsurf (now Devin Desktop) and any other MCP client: a remote Streamable HTTP server with the URL above
  - Sign-in is OAuth in the browser on first use: no API key, headers or client ID
- After install: `cork status`, `cork login` (link the machine to an account), `cork upgrade` (add units of agent hours for the workspace), `cork message "..."` (tell the other agents), `cork uninstall`.

## REST API

- Base URL: https://api.corkcli.com/api/v1 (every response carries `API-Version: 1`; unversioned `/api/...` paths are deprecated aliases that keep working)
- [OpenAPI 3.1](https://corkcli.com/openapi.json) · [API docs](https://corkcli.com/docs/api.md) · [API catalog](https://corkcli.com/.well-known/api-catalog)
- [Versioning and deprecation policy](https://corkcli.com/docs/api/versioning.md): breaking changes only in a new major version, with a `Sunset` header and at least six months' notice
- Auth: `Authorization: Bearer <token>` from OAuth 2.1 with PKCE (dynamic client registration at https://mcp.corkcli.com/register, scope `collide`) or the machine credential from `cork login`. [auth.md](https://corkcli.com/auth.md)
- Rate limits: per caller 600 requests refilling at 10 per second; agent routes follow the plan (Free 8/s, the paid plan (agent hours) 60/s, Enterprise unmetered); `RateLimit` / `RateLimit-Policy` headers; `429` with `Retry-After`
- Idempotency: `Idempotency-Key` on any write; the same key and request replays the first response for 24 hours; a different request with the same key is `422`
- Async jobs: `POST /api/v1/jobs` or `Prefer: respond-async` answers `202` with `Location: /api/v1/jobs/{id}` to poll; `DELETE` cancels
- Plans and credential URLs, no sign-in: https://api.corkcli.com/api/v1/plans
- Status: [status page](https://corkcli.com/status) and [status.json](https://corkcli.com/status.json) (Statuspage-style: the overall indicator, each component's state and checks, uptime since checks began, incidents), [status.md](https://corkcli.com/status.md), [incident feed](https://corkcli.com/status/feed.xml) (Atom); the server's own health: https://api.corkcli.com/api/v1/health

## Plans

You pay for agent hours, not seats. An agent hour is time the model is thinking and writing, read from the agent's own transcript; a tool's run time (a build, a test run), your typing and idle time never count. Details: [pricing](https://corkcli.com/pricing) ([pricing.md](https://corkcli.com/pricing.md)).

- Cork, free and local: unlimited agents and repos on one machine, no account, all data local.
- Free: 10 agent hours a month per account, plus 30 bonus hours the first month; unlimited repos and agents; agents on every machine you sign in on see each other; 30-day history; no card.
- Agent hours: $20 a month per unit of 100 hours, pooled across the workspace, graduated to $17 (units 11 to 50) and $15 (51 and up), 15% off a year. Every member is a player; shared knowledge, team messaging, the dashboard, 90-day history. At 100% running sessions finish inside a 10% grace band and new ones wait; auto top-up under a spend cap is optional.
- Enterprise: from about 100 units: custom pooling and retention, self-hosted or VPC, SOC 2 packet with a DPA, SAML or SCIM, uptime SLA.
- Prices are locked at subscribe time. Seat plans (Team, Business) bought before agent hours keep their price until November 1, 2027.

## Measured results

Headline: 53% fewer tokens for 12 concurrent Claude Code agents on one repository (Study 5).

- Study 5 (2026-10-01): Study 3's hardest tier, 12 Claude Code agents launched at once on one origin, once with Cork's paid plan (prompts matched to code by meaning) and once without, same tasks, prompts and model (Claude Sonnet 5). 5,475,538 vs 11,770,652 tokens (53% fewer), 152 vs 312 turns, $2.44 vs $4.32, 284s vs 373s wall clock; 11/12 vs 12/12 tasks correct by hidden tests. One round each way. https://corkcli.com/benchmarks/study-5-twelve-agents-53-percent
- Study 8 (2026-10-16): a regression in an unreleased build, then the fixes. 16 Claude Code agents at once on a new, harder generated repo (a coworking-booking app, 527 files, 32 vague multi-part tasks with shared hot spots, renames and signature changes), three rounds each against the same control, Claude Sonnet 5, cross-session messaging off. Without Cork: 36.8M ± 4.1M tokens per round, $12.15, 48/48 tasks correct, 388s. First unreleased v75 build (356d349): 37.6M ± 3.3M, 2.3 ± 2.3% MORE tokens, $13.55, 48/48, 660s; landing removed every rejected push (0 vs 37) and cut merge conflicts from 47 to 19, but gate holds that never released (about 7.9M tokens of waiting per round), broadcast messages to every agent (2.0M), alerts to non-callers (2.6M) and a git-sync pull notice (0.9M) cost more. Fix build (aff950e, also unreleased): 25.7M ± 1.6M, 29.4 ± 9.6% fewer tokens (rounds 36.4, 18.4, 33.4%), 18% lower cost, 46/48 (two failures not caused by Cork), 365s, 23 merge conflicts, 0 rejected pushes; gate waiting 2.7M, broadcasts 1.0M, alerts and change notices 1.3M, git-sync 0.4M, tool calls 2.4M to 0.6M. Left: about 35 manual pulls per round, mostly after change notices, cause the remaining conflicts; that is the next fix. Later run (2026-10-17), unreleased hooks v76 on Cork's own staging server (where unreleased builds run before release; it is not open to customers, whose test environment is the sandbox: https://corkcli.com/docs/sandbox) instead of a local server: 29.3M ± 1.7M tokens per round, 20.0 ± 5.3% fewer than without Cork (rounds 26.1, 17.3, 16.6%), $10.56, 47/48, 429s, 7.7 merge conflicts per round (fix build 23, without 46.7), 0 rejected pushes, 10.7 manual pulls per round (fix build 22.7); briefings 25-35% smaller; merge previews about 31 per run. Three regressions explain most of the gap to the fix build: briefings dropped the repo id (about 0.85M tokens per run spent finding it), 'wait for them to land' holds doubled (2.7 to 6.0 per run, including on a module still being created), and old messages were re-delivered (5 to 26 per run). The server changed too, so the gap is not v76's alone. Hooks v78 is being built to fix the three and will be measured next. Latest run (2026-10-17), unreleased hooks v78 on the same staging server, which fixes v76's three regressions: 26.1M ± 0.9M tokens per round, 28.5 ± 9.2% fewer than without Cork (rounds 38.9, 21.4, 25.1%), $9.93 (18% lower), 46/48, 412s, 7.7 merge conflicts and 9.3 manual pulls per round, 0 rejected pushes. Repo-id hunting 16.3 to 0 commands per run, wait holds 6.0 to 0, gate waiting 5.0M to 2.4M tokens, re-shown messages 26.3 to 0, tool calls 14 to 8.7, fix lines 0 to 6.7 per run. Left: reactions to change notices, about 1.45M tokens per run. The two failures: discounts left in code, and an agent keeping a renamed function's old name as an alias. https://corkcli.com/benchmarks/study-8-sixteen-agents-a-regression
- Study 7 (2026-10-15 to 2026-10-16): does the saving change with team size? 1, 2, 4, 8 and 16 Claude Code agents at once on Study 3's hardest repo (plus four new overlapping tasks), five rounds at each size with Cork and without, 50 runs, Claude Sonnet 5, cross-session messaging off in both arms. Tokens per run, mean ± sd: 1 agent 0.43M vs 0.57M (23.8 ± 15.1% fewer); 2 agents 0.96M vs 1.31M (26.4 ± 17.7%); 4 agents 2.82M vs 3.73M (24.4 ± 4.0%); 8 agents 4.92M vs 7.40M (33.2 ± 7.4%); 16 agents 9.38M vs 17.66M (46.8 ± 2.7%). 151/155 tasks correct in both arms. Rejected pushes without Cork 0 / 1 / 3.4 / 9.2 / 40.6 by size, 0 with it; merge conflicts at 16 agents 7.6 vs 0.4. Flat at about a quarter up to 4 agents, then rising; the rise is landing: at 16 agents, push-rejected/rebase/retest loops take 43% of the control agents' tokens. Caveat: with those loops left out, Cork's other features save only 2-8% at 4 agents and more, because agents' reactions to its notices cancel what the briefings save; fixes are being built and a follow-up study will measure them. https://corkcli.com/benchmarks/study-7-scaling-to-sixteen-agents
- Study 6 (2026-10-03): the same tier with four people, each on their own machine and sign-in, three agents each, four rounds each way: 13.78M vs 19.31M tokens (29% fewer, 17% to 39% per round), 47/48 vs 47/48 tasks correct, $8.50 vs $10.40. https://corkcli.com/benchmarks/study-6-four-people-twelve-agents
- Study 4 (2026-10-03): the same tier repeated four rounds each way with Cork set up at the machine level: 13.14M vs 20.87M tokens (37% fewer, 29% to 44% per round), 47/48 vs 46/48 tasks correct. https://corkcli.com/benchmarks/study-4-twelve-agents-four-rounds
- Study 3 (2026-09-28): two to four people each launching Claude Code agents at once on one origin, three tiers (named tasks on 158 files; vague tickets on 158 files; vague tickets on a 654-file repo with 480 decoy modules and a task that depends on a teammate's unpushed work), graded by hidden tests. Hard tier, final round: 7.82M vs 14.72M tokens for 12 agents (47% fewer), every task correct; with the Ponytail plugin added as well, 7.38M (50% fewer); Ponytail alone 13.20M (10% fewer). Earlier hard rounds: 13.94M vs 13.60M (a tie that exposed defects), then 11.37M vs 14.41M, 10.08M vs 13.39M, and with one-step landing 8.42M vs 15.08M. Git calls per agent fell from 8.9 to 4.0 with landing. Medium: 3.35M vs 5.58M. Easy: 1.16M vs 2.52M. Without Cork the agent that depends on a teammate's unpushed work stopped to ask a person in every round. https://corkcli.com/benchmarks/study-3-teams-easy-to-hard
- Study 2 (2026-09-26): 20 Claude Code agents on one 300-module Python repository, same task, same model, same run. 10 with Cork averaged 239,549 tokens per agent; 10 searching the repo themselves averaged 1,262,254 (5.27x fewer). With Cork the running cost per agent fell from 545,482 to 239,549 as ten agents joined; without it there was no trend. 5.5 vs 37.2 turns per agent. $1.69 vs $4.91 total. All 20 agents correct by the repository's own check. Every total equals the sum of its session transcript; the server's hash-chained ledger (828 rows) verifies. https://corkcli.com/benchmarks/study-2-ten-agents-one-repo
- Study 1 (2026-09-18 to 2026-09-20): rounds 7-13 on the same repository. Round 11, same run: 1,211K vs 196K tokens per agent (6.2x). Four agents editing overlapping code at once: 0 edits thrown away with Cork vs 10 without. https://corkcli.com/benchmarks/study-1-shared-context
- Atomic claims: 500 concurrent claims from 50 agent sessions returned 500 distinct, gap-free numbers in 1.33 seconds.
- Method: tokens are provider-reported input + cache writes + cache reads + output, counted once per assistant message. Adding agents raises the total; what falls is the cost of each agent.

## How it saves tokens

- Briefings: before an agent starts, hooks give it the exact signatures, callers and recent changes of the code its prompt is about, so it does not read and grep to find them. Prompts that name no code are matched by meaning: every function is embedded (BGE-small), the prompt is compared with all of them, and code the rest of the project uses outranks lookalikes nobody calls.
- Teammates' work: an agent is told when a teammate changes something it depends on, and when a teammate starts writing the file its task needs, with the interface.
- Landing: git push is rebased onto teammates' new commits, tested and pushed by the hook in one step, instead of the reject-pull-retest loop.
- Recipes: a change one agent verified can be replayed by the next agent in one command.
- Deltas: agents receive only what changed since their last step, not the history.
- Anchored notes and messages: facts are pinned to a symbol's hash and marked stale when that code changes.

## Glossary

Terms for multi-agent coding, defined.

- [Agent briefing: the context an AI coding agent gets before it starts](https://corkcli.com/blog/agent-briefing): An agent briefing is the targeted context an AI coding agent gets before it works: signatures, callers, recent changes and notes for the code it will touch.
- [Agent collision: what it is when AI coding agents overwrite each other](https://corkcli.com/blog/agent-collision): An agent collision is when two AI coding agents change the same code, or code that depends on each other, without knowing, so one breaks or erases the other.
- [Agent handoff: passing work and context from one AI agent to another](https://corkcli.com/blog/agent-handoff): An agent handoff is when one AI coding agent passes unfinished work, findings or decisions to another agent or person, so the next one need not start over.
- [Agent merge conflict: when parallel AI agents' branches will not merge](https://corkcli.com/blog/agent-merge-conflict): An agent merge conflict is a git merge conflict between branches written by AI coding agents running in parallel, usually found only when the work is combined.
- [Blast radius in code: everything a change can break](https://corkcli.com/blog/blast-radius): The blast radius of a code change is the set of callers, dependents, tests and teammates' work that the change can affect, used to judge risk before editing.
- [Coordination layer for AI coding agents: what it is and what it does](https://corkcli.com/blog/coordination-layer-ai-coding-agents): A coordination layer for AI coding agents sits under the tools that run agents and keeps parallel agents aware of each other's changes so the work fits.
- [Landing: rebase, test and push in one step for AI coding agents](https://corkcli.com/blog/landing-rebase-test-push): Landing means getting finished work onto the shared branch in one step: rebase onto everyone else's commits, rerun the tests, then push only if they pass.
- [Multiplayer coding agents: several people and AI agents on one codebase](https://corkcli.com/blog/multiplayer-coding-agents): Multiplayer coding agents means several AI coding agents, often run by several people, working on one codebase at once and needing to stay aware of each other.
- [Parallel AI coding agents: running several agents on one codebase at once](https://corkcli.com/blog/parallel-ai-coding-agents): Parallel AI coding agents are several coding agents working on one repository at the same time, each on its own task, to finish more work in less time.
- [Semantic lint: catching code that uses a renamed or changed symbol](https://corkcli.com/blog/semantic-lint): Semantic lint flags code that still uses a symbol a teammate or another AI agent renamed, removed or re-signatured, before it becomes a broken build or merge.
- [Semantic merge conflict: changes that merge cleanly but break the code](https://corkcli.com/blog/semantic-merge-conflict): A semantic merge conflict is when two changes merge with no textual conflict but the result is wrong, such as a rename plus new calls to the old name.
- [Write gate: a check that holds an AI agent's edit before it lands](https://corkcli.com/blog/write-gate): A write gate checks each file edit an AI coding agent is about to make and holds or blocks it when it would collide with another agent's live work on that code.

## For agents

From discovery to a first successful call with no sales call, no form and no approval from anyone at Cork: on one machine with no human at all; in the cloud, the person signs in and approves once.

- Free tier: Cork, free and local, runs on one machine with no account and no key, with no time limit; Free with an account is 10 agent hours a month per account (plus 30 bonus hours the first month), unlimited repos and agents, no card. [Pricing](https://corkcli.com/pricing.md)
- Self-serve API keys: there is no key to request; every credential is minted self-serve. An MCP client registers itself (dynamic client registration at https://mcp.corkcli.com/register, or a Client ID Metadata Document) and signs in through OAuth 2.1 with PKCE (scope `collide`); `cork login` runs the same sign-in from a terminal and stores the machine credential; an agent's `setup` call hands out a one-time code for `cork install --claim`. The person signs in and approves once. How it works: [auth.md](https://corkcli.com/auth.md)
- Sandbox: [Sandbox and test environment](https://corkcli.com/docs/sandbox): Cork's free local mode is the sandbox, the same server and MCP tools on 127.0.0.1 with no account, no key and no production data, plus a throwaway one with its own data folder. There is no hosted sandbox and no test-mode key.
- Zero-auth endpoints, no credential at all: https://api.corkcli.com/api/v1/health, https://api.corkcli.com/api/v1/plans, https://api.corkcli.com/api/v1/status, https://corkcli.com/status.json, https://corkcli.com/.well-known/mcp.json (every MCP tool with its input schema), https://corkcli.com/openapi.json, the OAuth metadata at https://mcp.corkcli.com/.well-known/oauth-authorization-server, and `POST https://mcp.corkcli.com/register`. [The list](https://corkcli.com/docs/sandbox.md)
- Plans, the free tier and credential URLs as JSON, no sign-in: https://api.corkcli.com/api/v1/plans
- [Agent mode](https://corkcli.com/?mode=agent): this site as one structured page for machines
- Is Cork up? [status.json](https://corkcli.com/status.json): `status.indicator` is none, minor, major or critical; each component is operational, degraded_performance, partial_outage or major_outage, from checks that ran
- [agents.md](https://corkcli.com/agents.md): how an agent should use Cork, step by step
- [skill.md](https://corkcli.com/skill.md): Cork as an agent skill
- [OpenAPI](https://corkcli.com/openapi.json): the REST API v1 at https://api.corkcli.com/api/v1
- [MCP manifest](https://corkcli.com/.well-known/mcp.json): the MCP server's tools, input schemas and annotations
- [MCP server card](https://corkcli.com/.well-known/mcp/server-card.json) and [ARD catalog](https://corkcli.com/.well-known/ard.json)
- [A2A agent card](https://corkcli.com/.well-known/agent-card.json): Cork's docs agent at https://corkcli.com/a2a (A2A 1.0 and 0.3 over JSON-RPC 2.0, no sign-in) answers a question with the sections of these docs that match it best, quoted with their links; it retrieves and calls no model
- [Pricing in markdown](https://corkcli.com/pricing.md)

## Links

- Focused indexes: [docs](https://corkcli.com/docs/llms.txt), [guides](https://corkcli.com/guides/llms.txt), [benchmarks](https://corkcli.com/benchmarks/llms.txt), [blog](https://corkcli.com/blog/llms.txt)
- [Cork API reference (REST v1)](https://corkcli.com/docs/api): versioning, auth, rate limits, idempotency, async jobs
- [Full llms.txt](https://corkcli.com/llms-full.txt): everything here plus every comparison, guide and alternative, and the full text of the core pages (install, pricing, docs, API, auth)
- [About Cork](https://corkcli.com/about)
- [Install](https://corkcli.com/install)
- [Pricing](https://corkcli.com/pricing)
- [Docs](https://corkcli.com/docs): connect Claude Code, Codex, Cursor and other agents
- [Docs by tool](https://corkcli.com/docs): [Claude Code](https://corkcli.com/docs/claude-code), [Codex](https://corkcli.com/docs/codex), [Cursor](https://corkcli.com/docs/cursor), [Gemini CLI](https://corkcli.com/docs/gemini-cli), [Cork CLI](https://corkcli.com/docs/cli) (the cork command), [Cork MCP server](https://corkcli.com/docs/mcp-tools) (URL and tools reference), [Python SDK](https://corkcli.com/docs/python), [Sandbox and test environment](https://corkcli.com/docs/sandbox)
- [Changelog](https://corkcli.com/changelog) ([RSS](https://corkcli.com/changelog/rss.xml)): what shipped, by date
- [Do you need git worktrees for AI coding agents?](https://corkcli.com/guides/do-you-need-git-worktrees-for-ai-coding-agents) and [cleaning up the worktrees agents leave behind](https://corkcli.com/guides/clean-up-git-worktrees-ai-coding-agents)
- [Benchmarks](https://corkcli.com/benchmarks): all studies, method and raw numbers
- [Blog](https://corkcli.com/blog) ([blog.md](https://corkcli.com/blog.md)): comparisons, guides, research and glossary; every article is in Markdown at its address plus .md, e.g. [Cork vs git worktrees](https://corkcli.com/blog/cork-vs-git-worktrees.md)
- [Source on GitHub](https://github.com/lithometric/cork): the Claude Code plugin and Cork itself, free and local (hooks, parser and protocol MIT; local engine FSL-1.1-MIT; the cloud service is closed source)
- [Comparisons](https://corkcli.com/blog/compare): Cork against other multi-agent tools
- [Multiple AI coding agents, one codebase](https://corkcli.com/guides/multiple-ai-coding-agents-one-codebase)
- [How AI agents talk to each other](https://corkcli.com/guides/how-ai-agents-talk-to-each-other)
- [Support](https://corkcli.com/support) · [Status](https://corkcli.com/status) · [Privacy](https://corkcli.com/privacy) · [What Cork sends](https://corkcli.com/data) · [Terms](https://corkcli.com/terms)