Skip to content

Coming from Git

If you know Git, you already know most of TOVIO. The object graph, content hashing, commits, branches, merges — all here, all recognizable. What's new is a handful of concepts and two mental flips. This page maps your existing knowledge onto TOVIO so you can stop translating in your head as fast as possible.

The mapping table

TOVIO concept Closest Git idea The key difference
Change A branch and its commits as one named unit Stable ID survives rewriting; lanes are landing targets, not workspaces; no staging area
Commit Commit Same idea; carries a Change ID and structured intent/provenance
Conflict object Merge-conflict markers Stored as data; doesn't block work; resolution propagates
Policy object .gitignored file + external secrets manager Lives in the repo, enforced cryptographically, survives cloning
Capability token Fine-grained PAT Scoped to paths + agent identity, expires, provenance on every commit
Forge A hosted Git service Runs inside your perimeter today (a hosted TOVIO service is not yet available); stores protected objects as ciphertext, while public content and coordination metadata remain visible
Operation log (tovio undo) git reflog Reverses supported retained local mutations; does not recall remote or external effects
tovio sync git push + git pull One operation; CRDT refs mean "diverged history" is never an error
Stacked changes Branching off a branch A change's parent is another change; landing the base auto-rebases the rest
tovio land git merge / rebase a feature in Integrates a change onto a lane and cascades the rebase to its descendants
(no equivalent) git add / staging Removed. The working copy is always the current change
Behavioral version (none) Versions an AI system's prompts/model/tools/memory alongside code

You don't have to absorb the whole table at once. The two rows that change how you work — change versus lane, and the missing staging area — are the mental flips below. The rest you'll meet when you need them.

Mental flip 1 — lanes are destinations, not workspaces

This is the big one.

In Git, you live on a branch. "I'm on feature/x." The branch is your workspace; your commits accumulate on it; you switch branches to switch tasks, often stashing first.

In TOVIO, you live in a change, and a lane is a place you land finished work onto. Changes are where you work; lanes are where finished work goes.

git switch -c feature/x      # create + move onto a branch
# ...work, commit, commit...
git switch main              # leave the branch (stash if dirty)
git merge feature/x          # fold the branch into main

You are always on a branch. The branch is both your scratch space and the unit you merge.

# ...just start editing — you're in a change already...
tovio commit -m "wire up CGM sync"   # finalize this change, start the next
tovio land --into main               # land the finished change onto the lane

You work in a change. main is a target you land onto, not a place you sit.

Because a change knows its parent, you can stack changes — one on top of another, the equivalent of "branching off a branch." TOVIO keeps the stack intact: when you tovio land the bottom change onto a lane, the ones above it automatically re-base onto the new lane state, with their Change IDs unchanged. You switch between changes with no stashing, because there is no working-copy state to stash — the working copy is the current change.

Why this matters

Most of what you used long-lived feature branches for in Git, you do with stacked changes in TOVIO — and you never accumulate the "this branch is 200 commits behind main" integration debt, because landing the base of a stack cascades the rebase up automatically.

The full treatment is on The change model.

Mental flip 2 — there is no staging area

There is no git add. There is no index.

The working copy is continuously tracked as the current change. Every time you run a command, TOVIO snapshots your working tree into the current change's commit. Unchanged subtrees are reused, so the snapshot is fast. tovio commit finalizes the current change and starts a new one — it does not "stage then commit."

The Git veteran's surprise

"Everything is always staged." There is no half-staged state, no git add -p dance before a commit. If you want the granularity that staging gave you, you reach for explicit operations after the fact rather than an index before the commit:

  • tovio change split — split a change into a landable sub-change and a work-in-progress remainder.
  • tovio change absorb — distribute fixup edits into the earlier changes that own the affected files.
  • tovio commit --amend — fold further edits into the last commit, keeping its Change ID.

This removes a whole class of beginner errors — the "forgot to git add" footgun — and it is what makes continuous undo and crash recovery trivial: there is always a tracked state to return to.

The commands that feel familiar but behave better

A few everyday operations look like their Git counterparts and quietly remove a recurring pain:

  • tovio sync replaces git push + git pull with one operation. Because lane pointers are CRDTs, "the remote has work you don't have" is never an error and you are never told to force-push. Divergence reconciles automatically.
  • tovio undo is git reflog with teeth: it reverses the supported local mutations the op-log retains — a land, a rebase, a lane delete — not just commit movement, and it tells you how to tovio redo. What a peer has already received is not recalled.
  • tovio land integrates a change onto a lane and cascades the rebase to that change's descendants, so a stack lands cleanly in one motion.

Git-compat aliases meet you where you are

You don't have to memorize new verbs on day one. TOVIO ships git-compat aliases: type tovio branch or tovio checkout -b and it does what you meant while naming the native verb (lane, switch); type a bare tovio push or tovio pull and it tells you, without scolding, that tovio sync is the one-step equivalent; tovio add, tovio stash, and tovio reset explain why there is nothing to stage, stash, or reset. The aliases teach gently — the tone is a calm colleague, never a fatal: lecture. More on that voice in Fearlessness.

Where to go next

Last reviewed September 9, 2026

Suggest an improvement to this page Not for security reports — see disclosure