bringyour.ai

Bring Your AI is built local-first: the CLI runs on your own machine, target config stays local, and your original files are never changed. Safety comes from three layers working together — read-only source files, snapshot-before-write with rollback, and review-gated plans you approve before anything moves. If you need to migrate agent context across Claude Code, Codex, and Cursor without handing your setup to a hosted service, this design is aimed at exactly that.

The privacy boundary: local-first by default

The product's stated position is that local-first is the product, not a setting you enable.

• The CLI runs on your machine. Migration, sync, and distillation happen locally rather than on a remote service.
• Target config stays local. Platform-native configuration is not centralized or uploaded.
• No hosted account required for sync. Machines sync through a local hub you can place in your own Git repo, so the "central" copy is one you control.
• No-data remote MCP. The remote MCP path is described as no-data, and safe MCP follow-up is included in the audit.
• License verification is local. Checkout produces a signed local license proof, and validation does not phone home.

One boundary is worth reading carefully: the page describes remote discovery as the edge of the local-first model. Local-first covers the CLI, the hub, and target config — it does not mean every optional capability is offline, so check the specific path you plan to use.

File safety: read-only sources, snapshots, rollback

The write behavior is the part most people care about, because a bad migration can wreck a working setup.

The preview step is where you verify this before committing:

$ bringyour preview --from claude-code --to codex
Claude Code found.
Codex found.
Move supported: yes
Existing setup can be kept: yes
Original files will not be changed.

Then the migration itself reports what it did and where the rollback point lives:

$ bringyour migrate --from claude-code --to codex --policy merge
rollback snapshot: ~/.codex/.bringyour-snapshots/...
validation: BRINGYOUR-VALIDATE.md
✓ memories + rules
✓ MCP review notes
✓ skills + validation
✓ rollback snapshots
! hook differences flagged
✓ PII scrub audit

Two details matter here. First, --policy merge is what preserves an existing Codex setup; a different policy may behave differently, so confirm before running. Second, the ! on hook differences is a flag, not a failure — hooks often can't be translated cleanly between harnesses, and the tool surfaces that instead of silently dropping them.

Review-gated execution and the audit artifact

Nothing runs unreviewed. Plans are review-gated, meaning you inspect the migration plan before it executes, and the output includes an audit artifact covering:

• hooks
• MCP review notes
• secrets
• AGENTS.md / CLAUDE.md scope
• validation notes

The MCP migration guide preserves command and environment references while flagging values that should stay in Keychain or environment variables rather than being written into config. The PII scrub audit in the migration output is the same idea applied to personal data.

Distillation: keeping the useful parts, stripping the risky ones

If your concern is sharing or archiving a setup, the distill path creates a sanitized Claude, Codex, or Cursor harness bundle with redaction metadata and verification. This is the right path when you want a portable snapshot rather than a live migration — the redaction metadata tells a reviewer what was removed, and verification confirms the bundle is intact.

What to check before you rely on it

• Run preview first, every time. It tells you whether the move is supported and whether your existing setup can be kept.
• Confirm your policy. merge preserves existing target setup; other policies may not.
• Read the flagged items. Hook differences and MCP values that belong in Keychain or env are the two places where a migration can look clean but behave differently.
• Keep the snapshot path. It's printed in the migration output — that's your rollback.
• Check the specific path's boundary. Local-first covers the CLI, hub, and target config; remote discovery is described as the edge of that model.

Pricing and access terms aren't covered here — the site lists a Pricing page, a Buy page, and a Team Migration Pack at $499 for up to 10 people, with lifetime access offered while the product is young. Check those pages directly for current terms rather than assuming what's included.

Bring Your AI splits its toolkit into four distinct jobs: Move an existing setup between tools, Sync machines through a local hub, Distill a sanitized snapshot, and Build a first setup from public GitHub history. Which one fits you depends on whether you already have a working agent setup, whether you work across multiple machines, and whether you need to share or hand off context safely.

All four paths share the same constraints: the CLI runs locally, source files are read-only, target files are snapshotted before any write, and platform-native config stays target-local.

The four paths at a glance

01 Move my setup

This is for keeping context you already built rather than rebuilding it. The migration carries memories, rules, voice, workflows, MCP review notes, hooks, validation files, and session analytics artifacts from a source harness to a target harness.

The workflow is preview-then-migrate:

$ bringyour preview --from claude-code --to codex
Claude Code found.
Codex found.
Move supported: yes
Existing setup can be kept: yes
Original files will not be changed.

$ bringyour migrate --from claude-code --to codex --policy merge
rollback snapshot: ~/.codex/.bringyour-snapshots/...
validation: BRINGYOUR-VALIDATE.md
✓ memories + rules
✓ MCP review notes
✓ skills + validation
✓ rollback snapshots
! hook differences flagged
✓ PII scrub audit

Two things to note in the output. First, --policy merge keeps your existing Codex setup rather than overwriting it. Second, hook differences are flagged, not silently applied — hooks are the part most likely to need manual review because they are platform-specific.

02 Sync machines

Sync keeps a central local hub without a hosted account. You place the hub in your own Git repo, and Claude Code, Codex, and Cursor sync through it.

The design constraint matters here: plans stay review-gated, and platform-native config stays target-local. So syncing does not mean one machine's config silently overwrites another's native settings — you review before anything lands.

Choose this path if you regularly switch between machines and are tired of drift between them. Skip it if you work on a single machine, where Move or Build covers you.

03 Distill a snapshot

Distill answers a different question: not "how do I move this" but "what is safe to keep or hand off?" It creates a sanitized harness bundle for Claude, Codex, or Cursor, with redaction metadata and verification attached.

The audit artifact checks hooks, MCP review notes, secrets, AGENTS.md/CLAUDE.md scope, and validation notes. The MCP migration guide preserves command and env references while flagging values that should stay in Keychain or environment variables rather than in the bundle.

Pick this path when you want to share a setup with a teammate, archive it, or publish it — anywhere the raw version would leak secrets or machine-specific paths.

04 Build from history

Build is for the blank-page problem. Instead of writing a rules file from scratch, it turns public GitHub work history into a first Claude Code or Codex setup, with confidence scores and source citations so you can see where each suggestion came from.

This is the only path that assumes you have no existing setup to move. If you already have context worth keeping, start with Move instead.

How to choose

• Have a working setup in one tool, want it in another? → 01 Move
• Work across multiple machines? → 02 Sync
• Need to share, archive, or publish a setup safely? → 03 Distill
• Starting from nothing? → 04 Build

The paths are not exclusive. A common sequence is Build (or Move) first, then Sync once you work across machines, then Distill when you need to hand context to someone else.

Pricing note

The site lists a Team Migration Pack at $499 for up to 10 people, alongside a Pricing page and a Buy page. The page also references "lifetime access while the product is young" and states "no subscription." Check the pricing page directly for current tiers and what each includes, since the available material does not break down per-path pricing.

Bring Your AI sells lifetime access rather than a subscription. The pricing page lists a Team Migration Pack at $499 for up to 10 people, and the site states there is no subscription. Licensing is handled through a signed local license proof issued after checkout, with no phone-home validation. If you are an individual buyer, the site's pricing and buy pages are the places to check for the current option that applies to you, since the indexed evidence only names the team pack explicitly.

What the pricing page shows

The phrase "lifetime access while the product is young" is the site's own framing. It signals that the lifetime model is tied to the product's current stage, so it is worth reading the pricing page directly before buying if long-term terms matter to you.

How licensing works

Licensing is local-first, matching the rest of the product. After checkout you receive a signed local license proof. Validation happens on your machine rather than by contacting a remote server, which the site describes as "no phone-home validation."

This matters if you work in environments where outbound license checks are blocked or undesirable. It also means the license proof is a file you keep, not an account state you log into.

What you are actually buying

The purchase is not just a license key. Bring Your AI is a toolkit for moving, syncing, distilling, and building AI agent context across Claude Code, Codex, and Cursor. A license covers use of that toolkit, including:

• Move an existing setup — memories, rules, voice, workflows, MCP review notes, hooks, validation files, and session analytics artifacts.
• Sync machines through a local hub you can place in your own Git repo, without a hosted account.
• Distill a sanitized harness bundle with redaction metadata and verification.
• Build from history — turn public GitHub work history into a first Claude Code or Codex setup with confidence scores and source citations.

Choosing between options

The evidence names one concrete SKU: the Team Migration Pack at $499 for up to 10 people. That fits a team standardizing agent context across several developers and tools. For a single user, check the pricing and buy pages for the individual option, because the indexed material does not state a solo price.

Two conditions to weigh before buying:

• Team size. The $499 pack covers up to 10 people. If your team is larger, confirm whether additional seats are sold separately.
• Tool coverage. The toolkit targets Claude Code, Codex, and Cursor. If your stack is outside those, the migration paths may not apply.

Practical notes before checkout

• Source files are read-only, and target files are snapshotted before any write, so a migration does not overwrite your existing setup.
• Merge policy keeps an existing Codex setup rather than replacing it.
• A rollback snapshot is created during migration, which gives you a way back if something looks wrong.
• The audit artifact checks hooks, MCP review notes, secrets, AGENTS.md/CLAUDE.md scope, and validation notes.

If you need a receipt of what changed, the validation file (BRINGYOUR-VALIDATE.md) and rollback snapshots give you a reviewable trail.

Bring Your AI is a local-first toolkit for moving, syncing, distilling, or building the context around AI coding agents — specifically Claude Code, Codex, and Cursor. It exists to solve one problem: every time you switch tools, you rebuild your agent setup from scratch. Bring Your AI carries that setup across instead. It's relevant if you already have memories, rules, skills, hooks, or MCP review notes invested in one harness and don't want to lose them when you try another.

The problem it addresses

Agent setups accumulate over time. Memories, rules, voice and workflow conventions, MCP review notes, hooks, validation files, and session analytics artifacts all live inside a specific tool's configuration. When you move to a different harness, none of that transfers automatically, so you either rebuild it manually or start over with a blank rules file.

Bring Your AI treats that accumulated context as portable property rather than tool-specific baggage.

Four product paths

The toolkit separates four jobs, which is useful because they have different risk profiles:

How the migration actually works

The CLI runs on your machine. A preview step shows what will happen before anything is written:

$ bringyour preview --from claude-code --to codex
Claude Code found.
Codex found.
Move supported: yes
Existing setup can be kept: yes
Original files will not be changed.

Then the migration itself:

$ bringyour migrate --from claude-code --to codex --policy merge
rollback snapshot: ~/.codex/.bringyour-snapshots/...
validation: BRINGYOUR-VALIDATE.md
✓ memories + rules
✓ MCP review notes
✓ skills + validation
✓ rollback snapshots
! hook differences flagged
✓ PII scrub audit

Three things are worth noting in that output. The --policy merge flag keeps an existing Codex setup rather than overwriting it. Source files are read-only, and target files are snapshotted before any write, so rollback is possible. Hook differences are flagged rather than silently copied, because hooks are the part most likely to behave differently across harnesses.

Privacy and write behavior

The privacy boundary is the product's central claim: the CLI runs locally, target config stays local, and there's no hosted account required for syncing. The license check is a signed local proof after checkout with no phone-home validation. Remote MCP is described as no-data.

On writes, the stated behavior is:

• Source files are read-only
• Target files are snapshotted before write
• Merge policy preserves an existing Codex setup
• MCP migration preserves command and env references, and flags values that should stay in Keychain or environment variables

Pricing

The site lists a Team Migration Pack at $499 for up to 10 people, described as lifetime access while the product is young. A pricing page and a general buy page also exist. No subscription is mentioned. Check the current pages before purchasing, since "while the product is young" implies terms may change.

Who this is for

You're a reasonable fit if you've built meaningful context in one agent harness and are considering another, or if you work across multiple machines and want a local hub instead of a hosted sync service. The review-gated, snapshot-before-write design matters most if you're migrating hooks or MCP configuration, where a silent copy could break things.

You're probably not the target if you only use one tool on one machine and have little accumulated configuration — there's nothing to move, and building from public GitHub history is a convenience rather than a necessity.

Bring Your AI audits the parts of an agent setup that are easy to break or leak when you move between tools: hooks, MCP review notes, secrets, the scope of AGENTS.md/CLAUDE.md, and validation notes. It also runs a PII scrub audit and produces a validation artifact (BRINGYOUR-VALIDATE.md) that records what was checked and which hook differences were flagged. This applies when you use the CLI to move, sync, or distill a setup across Claude Code, Codex, and Cursor — the audit is part of that flow, not a separate hosted service.

What the audit checks

The MCP migration guide preserves command and environment variable references, and flags values that should remain in Keychain or an environment variable rather than being inlined.

How validation runs

Validation happens as part of a migrate command. A preview first confirms what will move, then the migrate step writes a validation file and takes a rollback snapshot.

$ bringyour preview --from claude-code --to codex
Claude Code found.
Codex found.
Move supported: yes
Existing setup can be kept: yes
Original files will not be changed.

$ bringyour migrate --from claude-code --to codex --policy merge
rollback snapshot: ~/.codex/.bringyour-snapshots/...
validation: BRINGYOUR-VALIDATE.md
✓ memories + rules
✓ MCP review notes
✓ skills + validation
✓ rollback snapshots
! hook differences flagged
✓ PII scrub audit

• Input: a source harness (e.g. Claude Code) and a target harness (e.g. Codex).
• Action: preview, then migrate with a policy such as merge.
• Expected result: a BRINGYOUR-VALIDATE.md file, a rollback snapshot path, checkmarks for the categories that passed, and a ! flag for anything that needs review — here, hook differences.

What "review-gated" means in practice

The audit doesn't silently rewrite your setup. Source files are read-only, target files are snapshotted before any write, and a merge policy keeps an existing Codex setup. Anything the audit flags (hook differences, secrets that belong in Keychain or env) is surfaced for you to review rather than auto-applied.

Where the audit fits

The audit and validation run inside the four product paths: moving an existing setup, syncing machines through a local hub, distilling a sanitized snapshot, and building a first setup from history. In the distill path, the audit is what produces the redaction metadata and verification for a sanitized bundle.

Limits to keep in mind

• The audit reports and flags; it does not guarantee a conflict-free migration. Hook differences are flagged, not resolved.
• Local-first is the stated design: the CLI runs on your machine, target config stays local, and license verification is a signed local proof after checkout with no phone-home validation.
• Pricing and access terms aren't covered here — check the site's pricing and buy pages for current details, including the Team Migration Pack listed at $499 for up to 10 people.