// graph-driven development

You can't trust a changeyou can't explain.

Git records what changed, Atomic can tell you why.

Atomic is source code management reimagined at the primitive level: a distributed, agent-native Git alternative. A single CLI connects semantic call graphs and enhanced code search to intents, acceptance criteria, tasks, changes, evidence, provenance, attestations, reviews, views, and memories in one causal graph shared by every agent you already use. Stable change identities keep those relationships intact as work is combined or reorganized, so the graph becomes the state agents work from. Not another audit trail assembled after the fact.

Install Atomic→ Why the graph is the system
// measure your software factory

From prompt to production, know what AI actually delivers.

Atomic follows each change from the request that started it through cost, verification, review, and release. The result is a small set of KPIs your engineering team can improve, not another dashboard of AI activity.

Prompt

What outcome was requested?

Build

What did the agent do?

Verify

Did the requirements pass?

Review

Did someone independent approve it?

Release

What was accepted and shipped?

90%
accepted-change rate

Up from 60% for the same frontier model.

32%
lower cost per accept

$0.15 instead of $0.22 for the same open-weight model.

0
product files outside scope

All 11 changed product files were authorized.

Increase Software Change Success

Description

Are agents producing software changes that are more likely to be accepted?

Atomic measurement

Work counts only after tests pass, real code is produced, the run completes, and independent scoring accepts it.

Result
90% vs 60%
Objective met

Increase return on AI investment

Description

Can we connect AI spending to accepted changes, cost reduction, avoided work, and revenue?

Atomic measurement

Models, tokens, turns, review cost, and accepted results stay connected to the work that produced them.

Result
32% lower
$0.15 vs $0.22 per accept
Objective met

Expand Engineering Capacity

Description

Can each engineer govern more accepted software change without increasing coordination overhead?

Atomic measurement

Each requirement links to the changes that delivered it and the evidence used to approve it.

Result
5 / 5
requirements verified
Objective met

Reduce AI exposure

Description

Are agents limited to the data, tools, code, and authority required for their assigned change?

Atomic measurement

The files actually changed are compared with the product files and limits authorized by the task.

Result
0 of 11
files outside scope
Objective met

Improve agent assurance

Description

Can we prove how every agent-produced change was created, verified, reviewed, and authorized for production?

Atomic measurement

Signatures prove who approved the evidence. Policy checks whether that approval came from an independent reviewer.

Result
0 / 4
independently reviewed
Release blocked

Measured on real work. Delivery and ROI use matched arms from a 90-run blind-scored benchmark. Quality, scope, and assurance use a live Atomic project and measurements uses atomic vault query for results

How verification works →
// 01 · semantic understanding

Your agents answer better questions when the codebase knows itself.

Atomic enriches every repository with AST analysis, tree-sitter entity extraction, and a semantic graph that operates at the function, class, and token level. Agents stop grepping through files and start querying a graph that understands what your code means, not just what it contains.

44%
Faster sessions
Measured against baseline agents on the same task set.
82%
Less context read
Token budget saved by querying the graph instead of grepping files.
1 call
Replaces 5 tool turns
A single query returns what would take a standard agent five reads.
// 02 · provenance & attestation

Every agent turn. Every decision. Every model. Permanently recorded.

Atomic captures the full causal graph of every agent session: what was requested, what was explored, what was read, what was modified, and why. The record is cryptographically signed, content-addressed, and bound to an immutable change identity.

  • ●
    Travels with the code
    Provenance is bound to the change, not the branch. Squash, rebase, or cherry-pick: the record follows.
  • ●
    Your favorite agent is already supported
    Atomic plugins pre-configured to integrate into your existing agents supporting custom prompts and skills to drive your agent workflows with intent
  • ●
    Cryptographically signed
    Each session is ed25519-signed and content-addressed. Tamper with one byte and the chain breaks.
  • ●
    Queryable by intent
    Find every line of code produced under a specific intent, by a specific model, on a specific file.
CHANGE · cas-addressed 0xa9c4·f1e2·8b03
intentrefactor stream API to use AsyncWrite
humanlee@atomic.dev
agentclaude-code · sonnet-4.5
duration4m 12s · 38 turns
files3 modified · 47 read
signed✓ ed25519 · attested
▸session.startt+0s
›query "stream"12 hits
›read tinyhttp.rs37–58
›graph(callers, AsyncWrite)8 nodes
▾decision: extract Framedrationale ⌗
✎edit tinyhttp.rs:46+12 −8
✎edit mod.rs:194+3 −1
✓session.commitattested
// 03 · agent compatibility

Works with the agents you already use.

Atomic works alongside the agents you already use. A few lines of configuration wire up provenance capture per agent: you don't change your workflow, you gain a complete record of everything your agents have ever done, queryable by intent, model, file, or decision. Learn more in the agent workflows guide ↗

Claude Code
Supported
$ claude code
Cursor
Supported
$ cursor agent
GitHub Copilot
Supported
$ gh copilot
Gemini CLI
Supported
$ gemini --interactive
OpenCode
Supported
$ opencode session
+
Custom agent
Supported
$ atomic record --auto
Backed by
Slow Vermilion