See the Impact
Before The Commit

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.

Built on open source

Runccc is built on ccc (Code Change Capture), which is free and open source. Read the code and run it locally.

View ccc
Change Impact

Know What a Change Reaches

Agents now write much of the code, which makes it harder to follow what changed. Runccc lays out each change before it lands.

Tests at Risk

See which pipeline tests run against your change, and which services need testing, before you push.

Cross-Service Calls

New or modified calls between services show up before you commit, even when the other side lives in another repository or language.

Lints & Security

Flags language lint violations, security findings and vulnerable dependencies checked against the OSV advisory database.

Features

One Map, Many Views

Runccc scans your project into an in-memory code map that stays current as you work. Everything below reads from that same map.

Static Analyser

Built on Tree-sitter. Can analyse the entire Go compiler in under a second, refreshed with every save. Usable in CI/CD.

MCP Server for Agents

A local MCP server gives Claude, Copilot, Cursor and other agents exact answers on definitions, references, dependencies and test targets.

Confined Edits

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.

Architecture Visualiser

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.

IDE Extension

The VS Code extension runs the analysis in the background for each workspace folder, over loopback only, with nothing to configure.

Pipelines

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.

Visualiser

Watch What Your Agent Did

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.

Every change, step by step

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.

  • Chapters named for what the agent said each step was for
  • Edits built up one function, type or constant at a time
  • Follow it live, or replay at varying speeds

Nothing it touched goes missing

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.

  • What the agent read shows too, before anything it wrote
  • Each view has its own URL, ready to bookmark or share
  • The same player in the browser and in VS Code

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.

For coding agents

Edits Go Through CCC

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.

  • One call per change — a rename follows the name through every file the map ties to it, and lists any same-named site it left alone
  • Safe by construction — no writes outside the project root, no symlinks, never .git
  • All or nothing — every staged file is checked before writing, then every file is written or none is
  • Traceable — every change can be reverted and credited to the request that asked for it
# 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 { ... }
~14x
Fewer tokens for a project-wide rename*
3
Calls to rename across 8 files, down from 29*
11
Languages mapped
5
Visualiser levels, system to logic

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

Why Runccc

Fewer Tokens, More Oversight

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

C99 C++20 C# Rust Go Python Zig Odin TypeScript JavaScript Protobuf
Install

One Command to Install ccc

On Linux or macOS, the installer puts the latest ccc release on your machine. No sudo, and nothing to build.

bash
curl -fsSL https://runccc.dev/install.sh | bash

Running in Minutes

Map your project and point your agent at it.

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

Rolling it out across teams?

Runccc Teams shares your agents' replays with your team, encrypted so only its members can open them. One team and one repository are free.