The Checkpoint Habit: Making AI Agent Work Crash-Proof with Git

Continue Press · July 2026 · Pillar: agent memory & continuity

Here's the failure that quietly kills naive autonomous-agent setups. The agent works brilliantly for four hours. It plans to save its progress notes "at the end of the session." The session dies at hour three and a half — crash, network, context limit, doesn't matter. What survives? This morning's notes. Four hours of work now exists only as mysterious half-written files, with no record of what they are or what was next. Tomorrow's session inherits a crime scene.

The fix is one habit, two tools, and zero programming knowledge. We run it in production across every project; it has turned actual mid-work crashes into non-events.

The habit: checkpoint every hour

Every ~1 hour of work, and after every completed task: bring the state file up to truth, then commit.

A checkpoint is small — two minutes. Update STATE.md (exactly where am I, what are the next steps — the memory system explained here), then take a git snapshot. That's it. But it changes the worst-case loss from "everything since this morning" to "the last few minutes."

The deeper principle is worth naming, because it shapes how a good agent works: crash-ready at all times. The system doesn't distinguish between a session that's ending and one that might end. Every hour, the files are left in a condition where a stranger could take over. Sessions stop "ending" — they just become unnecessary.

Best of all, you don't maintain this habit — the agent does. One line in its standing contract and checkpointing happens without anyone remembering to do it.

Git for people who will never write code

If "git" sounds like programmer territory: it's a version-history tool that lives quietly inside a folder. Every "commit" photographs the entire folder and files the snapshot with a timestamp and a note. Nothing is ever lost; any snapshot can be restored. That's the whole concept — a time machine for a folder.

Why bother, if files are already on disk? Because disk holds only the present. Git holds every past:

• Any mistake is reversible. Agent overwrote a great draft with a worse one? Restore yesterday's snapshot. This is the safety net that makes autonomy emotionally tolerable — nothing your agent does is permanent damage.
• The history is a free audit trail. Snapshot notes read like a work journal: "market research complete", "chapter 3 drafted", "pricing decided." Ninety seconds of scrolling = a full account of what your agent did all month. It's also proof — a tamper-evident receipt that the work actually happened.
• Crash recovery is trivial. Even the absurd case — a crash mid-checkpoint, files half-written — costs one hour: the previous commit is a complete, consistent snapshot. The agent restores, re-reads, resumes.

Setup, once: install git (git-scm.com, default options), then tell your agent: "initialize a git repository in this folder and make the first commit." The agent handles it — and every commit thereafter, per its contract. Your entire ongoing involvement is recognizing four commands when you see them:

Level up: the off-machine backup

Local git protects against bad edits and dead sessions. It does not protect against a dead disk. The upgrade costs five minutes: a free private repository on GitHub (or any git host), plus one more line in the agent's contract — "after each commit, push to backup." From then on, every checkpoint automatically lands in a second location. Your operation's memory becomes as durable as the cloud, for exactly zero dollars.

The rhythm, assembled

morning  →  agent reconstructs from files        (2 minutes)
work     →  task ... checkpoint ... task ... checkpoint
            (state + commit + push, every hour)
handoff  →  final checkpoint: state, journal, backlog, commit
tomorrow →  repeat, with zero memory and zero loss

Notice what's not in the rhythm: you. The system saves itself, documents itself, and hands itself off. The standard this buys is not "nothing ever goes wrong" — it's "nothing that goes wrong matters much." That's the standard autonomous work actually needs.

Do this now

If your agent's workspace isn't a git repository yet, one message fixes it: "Initialize git here, make the first commit, and from now on commit after every completed task." Then, after its next working day, ask for git log --oneline and read your operation's timeline. Watching it scroll past is the moment most people start trusting the system.