One line: Jump Mode lets a digital asset live either on Bitcoin or on Tondi—never both at the same time—and move (“jump”) between them with a single, verifiable Bitcoin transaction. It keeps things simple, safe, and audit-friendly without running a complex cross-chain bridge.

Why Jump Mode exists

Most systems force you to pick either:

Speed & features (a fast execution layer), or
Rock-solid finality (Bitcoin’s public, neutral record).

Jump Mode gives you both, on demand:

Run fast and cheap on Tondi when you’re doing lots of activity.
Move back to Bitcoin when you want maximum assurance, offline verifiability, and an audit-ready checkpoint.

Think of it like working on a draft (Tondi) and notarizing the finished version (Bitcoin) whenever you choose.

What Jump Mode is (and is not)

Is: A simple, switchable home for an asset: its “home” is Bitcoin or Tondi.
Is not: A custodial bridge. No one holds your funds “in the middle.”
Is: A clean handover ritual recorded on Bitcoin each time you switch homes.
Is not: A rollup that streams data to Bitcoin every few minutes. (In Jump Mode, Bitcoin is touched only when you jump.)

The key idea: one “control coin”

Your asset is tied to one special Bitcoin output we’ll call the control coin.

When you jump, you spend this control coin in a new Bitcoin transaction that includes a tiny “note” (a commitment).
That note says where the asset lives next (Bitcoin or Tondi) and what exact state it’s in at the moment of the move.
Because only the owner’s Bitcoin key can spend that control coin, no one else can move your asset or fake a jump.

This is what gives Jump Mode its security without a bridge.

How a jump works (in plain steps)

A) Jump from Bitcoin → Tondi (“Go fast”)

You make a small Bitcoin transaction that spends the control coin.
The transaction carries a short note: “This asset now lives on Tondi; here’s the starting snapshot.”
After a few Bitcoin confirmations, Tondi recognizes the proof and activates the asset there.
From now on, your day-to-day actions (transfers, program logic) happen on Tondi—fast and low-fee.

B) Jump from Tondi → Bitcoin (“Lock in”)

Normal way (recommended):

On Tondi you press Freeze: no more changes; take the final snapshot.
You make a Bitcoin transaction that says: “This asset now lives on Bitcoin; here’s the final Tondi snapshot I’m locking in.”
After confirmations, Bitcoin becomes the asset’s home again.

Emergency way (if Tondi is unavailable or censoring):

You can still spend the control coin on Bitcoin—without anyone’s permission—with a note that returns the asset to Bitcoin.
Later, when Tondi is reachable again, it follows the already-public Bitcoin fact.

This is your permissionless exit: nobody can trap your asset off-chain.

What you gain

Simplicity: No ongoing cross-chain plumbing. You just jump when you choose.
Safety: The jump is secured by your Bitcoin key and recorded on Bitcoin.
Auditability: Each jump creates a public, time-stamped checkpoint anyone can reference.
Cost control: You pay Bitcoin fees only when you jump, not continuously.
User confidence: If anything goes wrong off-chain, you can exit to Bitcoin on your own.

What you trade off

While the asset is on Tondi, outsiders who aren’t connected to Tondi can’t verify your latest moves via Bitcoin until you jump back and create a checkpoint.
If you need continuous Bitcoin-level checkpoints (e.g., regulated per-trade settlement), a different mode (like “btc-led” or “tondi-led”) is a better fit.

When Jump Mode fits best

Phased operations: Run a quarter on Tondi (high activity), then jump to Bitcoin for the quarter-end snapshot.
Jurisdiction or policy changes: Switch your asset’s home to match local requirements.
Small teams / simple ops: You want Bitcoin’s security and Tondi’s UX without running a full rollup pipeline.
“Exit is sacred” mindset: You insist users can always pull back to Bitcoin without permission.

Not ideal if you need every action continuously anchored to Bitcoin. Use continuous-anchoring modes instead.

“Is this like a rollup?”

No. A rollup keeps executing on L2 and regularly posts data or proofs to L1.
Jump Mode keeps things simpler: your asset lives in one place, and you publish to Bitcoin only when you move homes. It’s more like changing the official venue with a notarized handover, not a constant feed.

How do others verify a jump?

They don’t need to call any special service:

They look up the Bitcoin transaction that spent the control coin.
They read the tiny note (standard format) that says: where the asset lives next + the exact state at the moment of handover.
That’s enough to trust the move, because only the legitimate owner could spend the control coin, and Bitcoin recorded it publicly.

If they also care about what happened while it was on Tondi, you can share a small receipt package (a few proofs) so they can check those specific steps. But the jump itself is guaranteed by Bitcoin.

Why this is not a bridge

Bridges hold assets in custody while issuing a copy elsewhere.
Jump Mode has no middleman custody. The original asset’s authority is tied to the control coin on Bitcoin; you alone can trigger a move.

Frequently Asked Questions

Q1: What if Bitcoin fees are high when I want to jump?
You can wait for lower fees or use fee-bumping tools. You only pay when jumping, not every day.

Q2: Do I lose data if I jump back to Bitcoin?
No. The jump includes a snapshot of the last state. Think of it as filing the latest version at the notary.

Q3: Can someone fake a jump?
No. They’d need your Bitcoin private key to spend the control coin. Without it, the move won’t exist on Bitcoin.

Q4: What if someone tries to move on Bitcoin while we’re still active on Tondi?
Your Tondi app can auto-pause when it sees a valid Bitcoin move and roll back to the last checkpoint. Bitcoin’s record wins.

Q5: Do I need to trust special servers?
No. Anyone can read the Bitcoin jump transaction. Optional helper services can make it easier, but they aren’t trusted for correctness.

A small mental picture

[ Bitcoin Home ]  <-- notarized handover -->  [ Tondi Home ]
      ^                                          ^
      |                                          |
   Control coin (your BTC output)            Fast, rich activity
   Only you can spend it                     Cheap, smooth UX

Jump = Spend the control coin + tiny note on Bitcoin.
Exit = You can always jump back to Bitcoin on your own.

TL;DR for executives

What: A single-switch model—your asset lives on Bitcoin or Tondi, and you move it with a one-time Bitcoin transaction.
Why: Keep operations simple, retain permissionless exit and public checkpoints, and pay Bitcoin fees only when switching.
When: Great for phased operations, audits, policy shifts, and teams who want both Bitcoin assurance and Tondi UX without rollup complexity.

If you later need continuous anchoring, you can still migrate to our other RGBX modes; Jump Mode doesn’t lock you in.

RGBX “Jump Mode”