Dotfiles for the AI era — secret-safe by design

Sync your AI agents across every tool and device.

Your agents, skills, slash commands, MCP servers and context are scattered across five tools and every machine you own. cnfgr keeps one canonical copy, projects it into each tool’s native format, and syncs every device in real time. Your secrets never sync.

Free while cnfgr is in Alpha · no account, no credit card · Pro coming later.

macOS, Windows & Linux · auto-updates built in.

Works with the tools you already use

  • Claude Code
  • Codex CLI
  • Gemini CLI
  • GitHub Copilot
  • Cursor

The problem

Your AI config is scattered — and drifting.

As of 2026 a working developer commonly uses several AI coding tools at once, on more than one machine. Each keeps its config in its own place and its own format.

one concept · five homes

agents

  • ├─~/.claude/agents/*.mdClaude Code
  • ├─(no direct equivalent)Codex CLI
  • ├─.gemini/agents/*.mdGemini CLI
  • ├─*.agent.mdGitHub Copilot
  • └─.cursor/agents/*.mdCursor

…and the same fan-out repeats for skills, commands, MCP servers and context files.

  • Duplicated effort

    A good agent or skill gets hand-copied into 3–5 different formats to be available everywhere.

  • Drift

    The version on your laptop and the one on your desktop slowly diverge. Which is right?

  • Format friction

    Gemini wants TOML. Copilot calls the key servers, not mcpServers. Get it wrong and the tool silently breaks.

  • No history

    Tweak an agent, regret it, and there's no undo beyond your memory.

  • Secret leakage

    The naive fix — git or Dropbox on your dotfiles — happily uploads the API keys in your MCP env blocks.

  • New-machine tax

    Setting up a fresh laptop means re-creating your entire AI toolchain by hand.

There’s no good off-the-shelf answer. Dotfiles managers don’t understand these formats or strip secrets. Git syncs blindly and leaks keys. A tool’s own settings sync is locked to one vendor. cnfgr is purpose-built for this exact problem.

How it works

Author once. Project everywhere. Sync every device.

cnfgr is a desktop app with a background daemon and a clean UI, for macOS, Windows and Linux.

  1. 01

    Author once

    Create or import your agents, skills, commands, MCP servers and context files. cnfgr stores everything in one canonical shape.

  2. 02

    Project everywhere

    A transpilation engine writes each item into the native on-disk format and location for every AI tool you have installed.

  3. 03

    Sync every device

    A local-first CRDT engine keeps every machine converged. Edits apply instantly and offline; they propagate within seconds when connected.

  4. 04

    Stay safe

    Secrets are stripped before anything is stored or sent. Conflicts get a real merge UI. Every sync is a version you can roll back to.

The architectural promise: the cloud is a coordinator and a backup, not the source of truth. Your config lives on your machines. If cnfgr’s servers vanished tomorrow, your files are still on disk — and you can export a plain ZIP of everything at any time.

Features

Everything that ships today.

cnfgr is in Alpha — every capability below is implemented and verified in the product right now.

Author once, project everywhere

Write your agents, skills, slash commands, MCP servers and context once. cnfgr writes them into each tool's native on-disk format — TOML for Gemini, the servers key for Copilot, and so on.

Local-first, multi-device sync

Built on Yjs CRDTs: edits apply instantly and fully offline, then converge across every device within seconds — with conflict resolution and version history, no clobbering.

Your secrets stay yours

API keys and tokens are stripped to placeholders before anything syncs and re-hydrated only on your own devices. cnfgr never syncs .env files or auth state.

Safe conflict resolution

A 60-second active-use window protects in-flight edits; true conflicts get a built-in 3-way merge view (base / yours / theirs) with per-chunk controls.

Version history & restore

A version is recorded on every sync; snapshot known-good states, roll back any item, or restore a whole device — all snapshot-protected.

Encrypted cloud

Cloud state is AES-256-GCM encrypted at rest. The sync server is a dumb relay that stores ciphertext and never interprets your data.

Clear sync visibility

Every item shows one of five states — Synced, Local only, Excluded here, Syncing, Conflict — with a legend always on screen.

Device management

See every machine you've installed cnfgr on: name, OS, last seen, and a per-device breakdown. Rename or remove devices remotely.

A genuinely nice editor

Dual-mode body editor: raw Markdown with a formatting toolbar, or a WYSIWYG rich-text mode that round-trips cleanly to Markdown.

ZIP export · no lock-in

One-click ZIP export of your entire effective on-disk state, organized per tool and restorable by hand even if cnfgr disappeared.

Cross-platform

macOS (.dmg), Windows (.exe + .msi) and Linux (AppImage + .deb), with auto-launch at login and auto-updates via a self-hosted feed.

Supported tools

Five tools, three operating systems, one config.

cnfgr surfaces every fidelity gap explicitly in the UI rather than failing silently — the candor is part of the product.

Supported configuration types per AI coding tool
ToolAgentsCommandsSkillsContextMCP servers
Claude Codereference
Codex CLI—*TOML
Gemini CLI
GitHub Copilot—*
Cursor—*

* Codex has no persona-per-file agent format, so Claude agents project to Codex as skills or are skipped. Copilot and Cursor context live in tool-specific places not covered by the canonical context record. Skills are near-universal.

Trust & security

Local-first sync that never leaks your keys.

This is a category where trust is the product. Scrubbing happens at the canonical boundary, before anything syncs — leaking a key is the hard path, not the default.

Stripped before anything syncs

Detected by field name (apiKey, token, Authorization, …) and by value pattern:

  • sk-…
  • ghp_…
  • xoxb-…
  • AKIA…
  • AIza…
  • JWTs
  • PEM blocks

Never touched — hard deny-list

Some files never enter the sync doc at all — by deny-list, not by hope:

  • .env
  • ~/.claude.json
  • auth.json
  • SSH keys
  • AWS creds
  • Kube config
  • cookie stores
  • logs

  • Encrypted at rest

    AES-256-GCM authenticated encryption on all cloud state. The sync server stores ciphertext and never interprets it.

  • Local-first

    Your config lives on your machines; the cloud is backup + coordinator. cnfgr can be paused entirely, and items can be kept fully local.

  • No lock-in

    One-click ZIP export of everything, organized per tool, restorable by hand. If cnfgr ever went away, you lose nothing.

  • Opt-in telemetry

    Off by default, self-hosted, no third-party processor. File contents, prompts and config data are never collected; IP addresses stripped.

  • No executable hooks

    Auto-syncing runnable code is a malware vector, so cnfgr deliberately refuses to sync executable hooks.

  • GDPR-minded

    Cookie consent on the site, a published privacy policy, and a documented deletion path.

Honest about the model

v1 is server-managed encryption — we could technically decrypt to debug, stated plainly — not zero-knowledge yet. Zero-knowledge encryption is on the roadmap, and we say so out loud. Your secrets are stripped regardless of the encryption model.

Why cnfgr

The three things only cnfgr does.

Dotfiles managers, blind file sync, and a tool's own settings sync each fall short in a different way. Here's the edge.

01

Understands the formats

It's not a file syncer; it's a transpiler that knows what an agent, skill, command, MCP server and context file are in each of five tools.

02

Local-first with correct convergence

CRDTs, not blind file copy — so offline edits on two machines merge correctly instead of one silently overwriting the other.

03

Secret-safe by construction

Scrubbing happens at the canonical boundary before anything syncs; the deny-list and pattern matcher make leaking a key the hard path, not the default.

AlternativeWhy it falls shortcnfgr’s edge
Git / dotfiles repoSyncs blindly; leaks API keys; no format conversion; manual conflict hell.Format-aware projection per tool; secrets stripped automatically; real merge UI; one-click restore.
Dropbox / iCloud / SyncthingSame file everywhere — but each tool needs a different file; clobbers; leaks secrets.Transpiles to each tool's native shape; CRDT convergence, not last-writer-wins file copy.
A tool's own settings syncLocked to one vendor; doesn't cross tools; often cloud-only.Tool-agnostic and device-agnostic; local-first; you own the data.
Copy-paste by handTedious, error-prone, drifts immediately.Author once; automatic fan-out; always converged.

Use cases

Built for how you actually work.

Whether you're setting up a fresh machine or juggling five tools across two desks, cnfgr removes the friction.

The new laptop

Install cnfgr, sign in, “restore to fresh state” — your entire AI toolchain across all five tools rebuilds itself. The new-machine tax goes to zero.

The two-desk developer

Tweak an agent on the desktop at home; it's on the work laptop before you sit down. No “which version is current?” ever again.

The careful tinkerer

Iterate aggressively on a prompt, snapshot the good ones, roll back the bad ones — with full local history even for items you keep off the cloud.

The work / personal split

Keep client-specific agents on the work machine only via per-device exclusion; keep experiments local-only so they never leave the laptop.

The multi-tool team-of-one

Build a killer skill once and have it instantly available in Claude Code, Cursor, Gemini, Copilot and Codex — each in its correct format.

FAQ

Questions, answered honestly.

  • Can't I just put my config in a git repo?

    You can — and you'll either leak the API keys in your MCP env blocks, or strip them by hand every time. Git also won't convert your Claude agent into Gemini's TOML or Copilot's format, and a two-machine edit becomes a manual merge conflict. cnfgr is format-aware, secret-safe, and converges automatically.

  • Is my source code or are my prompts being uploaded?

    No. cnfgr syncs your configuration (agents, skills, commands, MCP definitions, context files), not your codebase or conversations. Telemetry is opt-in and never includes file contents.

  • What happens to my API keys?

    They're detected and stripped to placeholders before anything leaves your machine, stored separately, and re-hydrated only on your own authenticated devices. .env and auth files are never touched at all.

  • Is it end-to-end encrypted?

    Not in v1 — it's AES-256-GCM encrypted at rest with keys cnfgr manages, and we state that plainly. Zero-knowledge encryption is on the roadmap. Your secrets are stripped regardless of the encryption model.

  • What if cnfgr shuts down, or I want to leave?

    Export a ZIP of your entire setup, organized per tool and restorable by hand, anytime. Your files are already on your disk. There's no lock-in.

  • I only use one AI tool. Is this for me?

    Yes — as a version-controlled, multi-device home for your config, with local-only mode and local history even if you never turn on cloud sync. And the day you add a second tool, you're already set.

  • Does it support my tool?

    v1 covers Claude Code, Codex CLI, Gemini CLI, GitHub Copilot and Cursor. More (JetBrains, Zed, Aider, Continue, Windsurf) are on the roadmap.

  • Will it overwrite my existing setup?

    Never silently. First run shows you exactly what will be pulled, pushed or kept, and waits for you to click Apply. Destructive actions take a snapshot first and ask for confirmation.

Pricing

Free during Alpha.

cnfgr is a free download right now — no subscription, no account billing, no credit card. Everything in the app is free to use during the Alpha.

Freewhile in Alpha
  • The full desktop app — every shipped feature
  • All five tools and all five item kinds
  • Local-first sync, version history, 3-way merge
  • Secret scrubbing, encrypted cloud, ZIP export
Download the free Alpha
ProPlanned · not yet available

A Pro tier is planned for after the Alpha. Subscription billing is a roadmap item — there’s nothing to buy today. The intended shape:

  • Unlimited devices
  • Unlimited agents / skills / commands / MCP servers
  • 30-day version history
  • Priority email support

Intended pricing (post-Alpha): around $12/mo, with an early-adopter rate planned for people who join during the Alpha.

Get notified when Pro launches

Your AI setup, everywhere you work.

Author once, project everywhere, and keep every device in sync — free while cnfgr is in Alpha.

no account, no credit card · Pro coming later