Quick start

C’mon, your agent will do this automatically, meatbag.

curl -fsSL https://arc.daystra.com/install.sh | sh
cd my-project
arc init

arc init starts capture and sets up the agent:

Path	Purpose
`.arc/`	Snapshot database and object store
`.arcignore`	Default ignore patterns
`.mcp.json`	MCP server config, auto-discovered by Claude Code
`.claude/settings.local.json`	Pre-authorizes `mcp__arc__*`, so Arc tools never trigger permission prompts
`.claude/skills/arc-source-control/`	Teaches new agent sessions the Arc workflow

First commands:

arc status                            # is capture live?
arc snapshots                         # history
arc snapshot diff 20 25               # what changed between two points
arc reset 15                          # go back
arc intent declare "refactor auth"    # start a unit of work
arc intent complete                   # finish it

Joining a project that already lives on a relay takes one command, which creates the directory, pulls the full history, and writes the files:

arc clone /Volumes/backup/arc         # filesystem relay, no credential needed
arc clone --bundle invite.json        # R2 relay, from a read-only invite

If you already ran arc init in that directory, connect the relay instead: arc remote add <path-or-bundle> --pull, then arc sync pull --materialize. Materialize is a merge: it folds every live peer's work into your files, and any path changed on both sides is refused by name and left untouched, with its fix in the output.

How capture works

Continuous snapshots. The daemon captures when changes settle. Each snapshot is immutable, has a parent, and is stored by BLAKE3 hash. A file that appears in a hundred snapshots is stored once.
Secret-safe capture. Every change is scanned before it is stored. Depending on your policy, Arc blocks the snapshot or masks the matched bytes. Tune it with arc secrets policy.
Signed identity. Every actor, human or agent, has an Ed25519 identity, and records are signed when synced.
Layered config. Settings come from ~/.arc/config.toml (global), then .arc/config.toml (project), then environment variables on top.
Everything in .arc/. SQLite holds metadata, events and intents, and the object store holds content. Capture and history need no external service; relays, narration and feedback are the only network paths, each described below.

The timeline. A base timeline has worktree spurs. Declaring an intent forks an isolated physical copy of the project (an APFS clone on macOS; a btrfs reflink on Linux when the filesystem supports it, otherwise a full copy), and its snapshots form a separate chain tagged with the worktree, kept out of base until merge. A merge writes one new base snapshot. An abandoned spur stays in history for inspection and never reaches base. Nothing is rewritten.

Many agents, one project

Each agent session runs its own arc mcp-server process. All of them talk to one daemon per project (arc serve), which owns the file watcher and the capture pipeline. A kernel lock (flock on .arc/daemon.pid) enforces the one-daemon rule: a second daemon sees the lock and exits. If no daemon is running, the MCP server starts one.

Architecture diagram — agents → MCP → core → storage

How it’s wired — sessions, sockets, and the lock

A stopped daemon is usually dormant, not broken. A daemon stops itself after three idle days (daemon.idle_exit_after_secs, 0 = never). The next arc command or agent session restarts it, captures everything that changed while it was down, and records the gap. arc daemon status exits 3 for dormant and 1 only for a crash. Don’t keep a daemon alive just to avoid the dormant state; that state is by design.

Host mode (1.6, opt-in). Set [daemon] mode = "host" in ~/.arc/config.toml, and a single arc host process serves every project on the machine. On the developer’s machine, 24 projects run in one process of about 90 MB, instead of 24 processes at 8–10 MB each. Each project keeps its own lock, log and lifecycle, so a fault restarts that project alone. The arc daemon commands work unchanged and route to the host. arc host status reports JSON.

Persistence across logins (macOS). arc daemon install adds a launchd agent that starts the daemon at login and restarts it if it crashes. A supervised daemon does not idle-exit. In host mode, arc host install adds one agent for the whole machine: after a reboot or crash, the host comes back with every project it held, and it retires any per-project agents it finds. On Linux this is not implemented yet, so run arc serve under a supervisor you manage.

Relay sync

A relay is an off-machine copy of your substrate: every snapshot, intent and signed record. It serves as a backup, keeps a second machine current, and brings a fresh clone up to date. Pushes are incremental and deduplicated by hash. There are no force-pushes, no conflict markers, and no history rewrites.

arc remote add /Volumes/backup/arc                       # any mounted path: volume, NAS, server
arc relay provision --backend r2 --bucket my-arc --push  # Cloudflare R2: bucket, scoped token, wired
arc store add my-s3 --backend s3 --bucket my-arc --endpoint https://s3.example.com
arc relay add --store my-s3                              # any S3-compatible store (MinIO, RustFS, B2, ...)

arc relay invite --relay my-arc --out invite.json        # read-only invite; share it like a password
arc sync                                                 # where you stand, plus the one command to fix it
arc sync verify                                          # full parity verdict

You hold the keys. The bucket is yours. Arc mints a least-privilege token scoped to that one bucket, and every record stays signed by its author. File contents on the relay are not encrypted, so choose storage whose access you trust.
Roles per machine. arc config set sync.push false makes a machine receive-only. arc config set sync.materialize_target self makes an origin judge its tree against its own work, not a peer’s copy.
Quiet when idle. Sync runs every 30 seconds while you work. After a day untouched it slows to every 30 minutes (5 minutes on a receive-only machine), and it speeds back up as soon as you make a change.

Retroactive purge

Sometimes a leaked secret, a 33 GB build directory or a client file ends up in history. You declare what should never have been captured: the content leaves history and the relay, and the timeline stays. The machine you purge on keeps its local copy by design, as the backup.

arc purge preview "config/prod.env"                          # dry run: exactly what it hits
arc purge declare "config/prod.env" --reason "leaked credential"
arc purge remote 3 --relay my-arc --execute                  # expunge it from the relay too
arc purge list                                               # every purge is an audit record
arc purge restore 3                                          # reversible until GC

No rewrite and no re-clone. Snapshot ids stay stable, so other machines keep working.
Shared bytes are safe. Content that paths outside the pattern still reference is kept, and the declare step tells you when that happens.
Doctor finds the bulk. If you add a directory to the ignore list after it was already captured, arc doctor reports it and gives you the reclaim command to paste.

Narration

Narration is off by default, so nothing leaves your machine until you enable it. When it is on, each snapshot’s change context goes to the backend you pick: Anthropic, OpenAI, Gemini, Grok, any OpenAI-compatible endpoint, or local Ollama, which keeps everything on the machine. The API key is read from an environment variable, the Keychain, or sigil, and narration never prompts for it.

[narration]                              # ~/.arc/config.toml or .arc/config.toml
mode = "auto"
base_url = "http://localhost:11434/v1"   # Ollama
model = "llama3.2"

Feedback

Agents run Arc, so agents file the reports, without leaving the session, through the CLI or the arc_feedback MCP tool:

arc feedback --bug "what broke"
arc feedback --feature "what you want"
arc feedback --open                                              # what's unresolved
arc feedback --resolve <id> --resolved-in <version> --note "how"

Entries go to ~/.arc/feedback.md and to the Arc team (turn that off with arc config set feedback.remote false). Resolutions record the version that shipped the fix, so “is this fixed yet?” has an answer.

Update with arc update. To pin a version: VERSION=1.6.1 curl -fsSL https://arc.daystra.com/install.sh | sh.

Platforms and clients

macOS (Apple Silicon): fully supported, Developer ID-signed and notarized.
Linux (x86_64, musl-static): early. Capture, snapshots, intents and worktrees work. The daemon doesn’t persist across logins, because there is no systemd unit yet. No arm64 Linux build is published.

Clients. Arc speaks standard MCP over stdio and doesn’t depend on any particular model or vendor.

Claude Code: the primary integration. Tools are auto-discovered, and the onboarding skill is installed for you.
Cursor, Windsurf, Cline, and any MCP client: add arc mcp-server in the client’s settings, and the agent gets all 50+ Arc tools.

Setup notes — permissions, paths, upgrades

Permission prompt for Arc tools? Run arc init in that project. It writes mcp__arc__* to .claude/settings.local.json.
MCP server won’t start on a freshly pulled project? .mcp.json names the absolute path of the binary that ran arc init. Run any arc command in that directory, and Arc rewrites the path for the local machine.
Where things live. Global config is in ~/.arc/config.toml, the binary is ~/.arc/bin/arc, feedback goes to ~/.arc/feedback.md, and project data is in .arc/.
After arc update. Arc re-wires .mcp.json, permissions and the skill in each project on next use, merging with what is there. Restart running agent sessions to pick up new tools. The daemon picks up the new binary on its next restart.

Aside: the macOS Spotlight tax

On a Mac, Spotlight indexes build output and agent churn that nobody searches for. arc init drops a .metadata_never_index sentinel in .arc/, and arc doctor flags it if the sentinel goes missing. The sentinel only stops new indexing, so if Arc has been running for a while, clear the existing index once with mdutil -E /path/to/project/.arc. For other build directories, this script drops the same sentinel across a project.

macOS (Apple Silicon) · Linux (x86_64, early) · MIT License · Built by humans and agents, tracked by Arc