// features

What is the best version control built for AI agents?

// Atomic’s answer

Atomic is a distributed semantic change graph built for AI agents: version control that records not just what changed, but who caused it, why, and what AI assisted.

01 · change
what changed
02 · identity
who caused it
03 · intent
why it exists
04 · provenance
how, where, and when did it happen?

Git preserves snapshots and a chronology of results. Atomic preserves change as a durable, composable object and connects it to code structure, intent, evidence, provenance, attestations, review, and memory. Humans and agents work from the same queryable record instead of reconstructing context across tools after the fact.

Get started → Why Git is not enough
Permanent
Content-addressed change identity
Semantic
Files, entities, tokens, and relationships
Verifiable
Evidence, provenance, and signed attestations
Distributed
Offline-first patches and causal views
// one graph, four layers of value

The repository becomes the system of record for how software was made.

Each capability is useful alone. Their value compounds because they share stable identities and typed relationships in the same graph.

// 01 · change algebra

Changes are transformations, not disposable snapshots.

Atomic is built on Darcs/Pijul-style patch theory. A change is identified by its content and explicit dependencies—not by its position beneath a parent commit. Independent changes commute, duplicate changes deduplicate, and references remain stable when work is reordered or combined.

  • →Permanent Blake3 change identity across views and repositories
  • →Explicit dependency closure instead of hidden branch ancestry
  • →Commutative application for independent work
  • →Native deduplication of identical patches
Explore change identity →
// 02 · semantic intelligence

The codebase knows its files, entities, changes, and relationships.

Tree-sitter entities, files, modules, views, changes, intents, and identities become typed graph nodes. Agents query structure and relationships directly instead of repeatedly grepping the filesystem and rebuilding context every session.

$ atomic vault query search "authentication"
$ atomic vault query neighbors file:src/auth.rs --depth 2
$ atomic vault query callers entity:src/auth.rs:verify:42
Query the graph →
// 03 · agent provenance

Every agent turn retains its origin, reasoning, activity, and result.

Atomic integrations record the user goal, exploration, file edits, verification, model, provider, token usage, cost, and resulting patch proposal as a causal provenance graph. Agent work is attributed to a session and the human identity behind it.

  • →Automatic turn recording through native agent hooks
  • →Goal → exploration → commitment → verification → change lineage
  • →Model, provider, tokens, cost, session, and files touched
  • →Content-addressed provenance pushed with the changes it explains
See agent workflows →
// 04 · intent and proof

The change carries what “done” meant and the evidence that proved it.

Atomic Vault gives project knowledge durable types: intents, acceptance criteria, tasks, constraints, verification, memories, and independent review. Canonical JSON-LD, closed-world gates, cryptographic identities, and Data Integrity proofs make the record inspectable and attestable.

prompt → intent → criterion → task → file
file ← change → evidence → review → promotion
memory → future intent
Explore Atomic Vault →
// concurrency without branch isolation

Agents need causal views, not duplicate worktrees.

A view is a filtered perspective over one canonical graph. A draft inherits its parent’s change set and adds its own isolated work. Agent sessions get full project context without copying the repository or creating a second source of truth.

  • ✓Shared and draft views with explicit parent relationships
  • ✓Dependency-aware insertion and selective promotion
  • ✓Stable changes remain intact while views are reorganized
Understand views →
one graph · multiple perspectives
dev [shared]
 ├── change A
 ├── change B
 └── agent-session [draft]
      ├── inherits A + B
      ├── change C
      └── change D

triage C + D → insert into dev

Graph correctness. Semantic review.

Every recorded edit carries a graph representation for mathematically sound application and a semantic representation for human-readable file, line, and token review. Independent edits commute; true overlap is resolved at finer granularity than line-based merge.

See dual-layer diff →
// accountable promotion

Review the graph state—not a disconnected diff.

Atomic triage joins candidate changes to intent coverage, required evidence, scope, dependencies, blast radius, provenance, attestation freshness, and independent review before work moves into a shared view.

Triage readiness

Is the candidate set current, covered by intent, and ready to promote?

Blast radius

Which callers and related entities may be affected by the change?

Attestation freshness

Was this exact canonical state signed, or did it change after approval?

Provenance lineage

Which human, agent, prompt, tools, and verification produced the result?

$ atomic triage candidates feature-auth --into dev
$ atomic intent verify AUTH::alice::12
$ atomic triage review feature-auth --into dev --attest --identity reviewer
$ atomic insert view feature-auth --to-view dev
// git and atomic solve different problems

Git records the result. Atomic preserves the system that produced it.

Capability Git Atomic
Primary unitParent-dependent commit snapshotContent-addressed change with explicit dependencies
Identity after reorganizationRebase and squash produce new SHAsChange identity remains stable across views
Agent contextExternal session logs and commit proseHashed provenance and causal activity graph
Intent and evidenceTickets, PR templates, and CI linksTyped intents, criteria, verification, and review
Merge modelSnapshot ancestry and line-level diffPatch theory, graph context, and semantic tokens
Repository intelligenceFiles searched and parsed on demandQueryable entities, relationships, views, and changes
PromotionPR status across integrated systemsTriage over one linked graph state

Atomic can run alongside Git through import and shadow-sync workflows. Adopt the semantic record without requiring an all-at-once migration.

// use the agents you already have

One graph. Every agent.

Atomic normalizes each agent’s lifecycle events into the same provenance and recording model. Teams keep their preferred editors and assistants while the repository keeps one durable standard for identity, evidence, and review.

Accountable change begins with understanding why.

Make the repository the foundation of record for humans and machines.

Install the CLI, enable your agent integration, and let Atomic record the next change with its semantic operations, intent, provenance, and evidence intact.

Install Atomic → Read the docs