Code Change Capture shows everything a change touches: the functions, tests, services and cross-service contracts it reaches. It shows them in your IDE, in your pipeline, and to the coding agents making the change.
Open source core. Runs on your machine, and your code stays there.
Runccc is built on ccc (Code Change Capture), which is free and open source. Read the code and run it locally.
View cccAgents now write much of the code, which makes it harder to follow what changed. Runccc lays out each change before it lands.
See which pipeline tests run against your change, and which services need testing, before you push.
New or modified calls between services show up before you commit, even when the other side lives in another repository or language.
Flags language lint violations, security findings and vulnerable dependencies checked against the OSV advisory database.
Runccc scans your project into an in-memory code map that stays current as you work. Everything below reads from that same map.
Built on Tree-sitter. Can analyse the entire Go compiler in under a second, refreshed with every save. Usable in CI/CD.
A local MCP server gives Claude, Copilot, Cursor and other agents exact answers on definitions, references, dependencies and test targets.
Agents change code through Runccc's edit tools rather than raw shell writes. Each edit stays inside the project and is staged as a diff, applied all-or-nothing and revertible.
Drill down from the whole system to a single function's logic, following the C4 model. A timeline replays what an agent read and changed, one definition at a time.
The VS Code extension runs the analysis in the background for each workspace folder, over loopback only, with nothing to configure.
Run the same analysis in CI: changed services, dependency deltas, SAST and lockfile audits as JSON, with a non-zero exit on high-severity findings.
The visualiser draws your project from the whole system down to a single function's logic, and replays an agent's work on it one step at a time.
Each ask plays as a story: the agent's plan, every step it took and how it ended, in subtitles and read aloud. The lines a step wrote sit inside the function they changed, added in green and removed struck through.
A change to a file the map doesn't draw, such as a README or a stylesheet, shows on a card over the canvas. The rail beside it lists every step, so any one is a click away.
Open it with ccc run --vis, or from the RUN button in VS Code's activity bar.
To share replays with your team, encrypted, use Runccc Teams.
Agents read the map and also make their changes through it. A rename, a dead-code delete or a new function takes one previewed call, so the agent doesn't have to read and edit file by file.
.git
# AGENTS.md
This repo has a ccc map served over MCP at
http://127.0.0.1:6767/mcp. Use it as the
entry point for everything you do here.
- Navigation and questions go through the
ccc tools: find, references, dependencies,
test_targets, changes, ...
- ccc is the only writer: make every change
with edit_rename, edit_replace, edit_delete,
edit_insert or edit_text, then edit_apply.
{
"services": {
"auth": ["apps/auth/**"],
"billing": ["apps/billing/**", "libs/money/**"],
"gateway": ["apps/gateway/**"]
},
"relatives": {
// gateway calls auth over HTTP
"gateway": ["auth"]
},
"externals": {
"billing": { "repo": "acme/billing", "lang": "go" }
}
}
// gateway (rust)
fn checkout(cart: &[Item]) {
// ccc:calls grpc billing.v1.Charge
client.charge(total)
}
// billing (go), another repository
// ccc:serves grpc billing.v1.Charge
func Charge(account string, amount int) error { ... }
*Estimate: renaming a function used at 20 sites across 8 files of ~300 lines, by an agent that must read a file before editing it.
An agent's own tools read whole files to change a few lines. Runccc's edits act on the map, so agents need fewer turns and you can see each change before it's written.
| Task | Agent's own tools | Through Runccc | Saving |
|---|---|---|---|
| Rename a function used at 20 sites in 8 files | ≈ 33k tokens, 29 calls | ≈ 2.3k tokens, 3 calls | ~14x tokens, ~10x calls |
| Delete a dead 50-line function | ≈ 4.4k tokens, 3 calls | ≈ 1k tokens, 2 calls | ~4x tokens |
| Add a 25-line function beside an existing one | ≈ 4.2k tokens, 3 calls | ≈ 0.9k tokens, 2 calls | ~4.5x tokens |
| Change a few lines inside one function | read + edit | read + edit | about even |
Estimates assume 300-line source files at ~12 tokens a line, and an agent that must read a file before it edits it. Every call saved is also a model turn saved.
Languages
On Linux or macOS, the installer puts the latest ccc release on your machine. No sudo, and nothing to build.
curl -fsSL https://runccc.dev/install.sh | bash
Map your project and point your agent at it.
# Generate .ccc/map.json, then add your services to it
ccc init
# In-memory map & MCP server
ccc run # http://127.0.0.1:6767/mcp
ccc run --vis # visualiser at :6767/vis
# Claude Code
claude mcp add --transport http ccc http://127.0.0.1:6767/mcp
# GitHub Copilot
copilot mcp add --transport http ccc http://127.0.0.1:6767/mcp
# Then add the ccc block to AGENTS.md and work as usual
ccc changes --telemetry # services to test vs the base ref
ccc deps # dependency delta as JSON
ccc sast # non-zero exit on a high finding
ccc audit # lockfiles vs the OSV advisory db
ccc insights --html report.html
Runccc Teams shares your agents' replays with your team, encrypted so only its members can open them. One team and one repository are free.