> **TL;DR:** If you've been burned once by auto-compaction quietly eating something you needed, you don't trust it anymore — so you babysit the context meter and scramble to save your work right before the boundary. That vigilance is a real tax on your focus. It's also unnecessary: capture the work continuously and cheaply *while you work*, and the boundary stops being a cliff you have to watch for.

I used to watch my context window like a pot on the stove.

Every long session, some part of my attention was parked on the meter — `/context` in Claude Code, `/status` in Codex — waiting for it to creep toward full. And when it got close, I'd stop whatever I was actually doing and type some version of: *"before you compact, write down everything important — the decisions, what we ruled out, what's still open."* Then I'd hold my breath through the compaction and hope the save was good enough.

I did this because I'd been burned. Anyone who's run long agent sessions has felt it: auto-compaction fires, the session keeps going, and three prompts later you realize something you needed is just… gone. Not wrong — gone. After that happens once, you stop trusting the boundary. So you appoint yourself the early-warning system.

## The vigilance is the cost

Here's the thing I didn't want to admit: the babysitting *was* the tax.

Every glance at the meter was attention pulled off the actual problem. Every pre-emptive "save everything now" was an interruption I scheduled for myself, at the worst possible moment — mid-thought, right when the work was flowing. I'd traded one pain (losing context) for another (never fully dropping into the work, because part of me was always on meter-watch).

This is a different pain than [compaction amnesia](/blog/compaction-amnesia) itself. That post is about what you lose *after* the boundary — decisions flattened to one-liners, failed paths erased, the *why* turned to soup. This one is about what the fear costs you *before* the boundary: the hypervigilance, the compulsive checking, the flow you never quite reach because you're guarding a save you have to trigger by hand.

And if you've ever solved this by having your agent maintain a set of Markdown notes it rewrites each session — a [memory-bank-style habit](/blog/agents-md-memory-bank-pbc) — you already know the instinct. You're doing crystallization by hand: manually deciding, at the last second, what's worth keeping. The instinct is right. The *timing* is the problem: you're forced to make the perfect save at exactly the moment you have the least attention to spare.

## The fix isn't better watching. It's cheaper saving.

The move that finally killed the ritual for me was small and slightly counterintuitive: stop treating the save as a rare, high-stakes event you time perfectly, and start treating it as something cheap you do continuously while you work.

That's the whole design of [agent-crystallize](https://github.com/stewie-sh/agent-crystallize). Its own docs put it bluntly: *don't wait until the context window is nearly full.* Frequent lightweight **checkpoints** are the primary workflow — what changed, what was decided, what's next — dropped as you go, not scrambled together at the cliff edge. When capture is cheap and constant, the boundary stops being a moment you have to see coming.

You can also hand the timing off entirely. The CLI ships a hook that writes a checkpoint before compaction — best-effort by default, and you can make it fail-closed (strict mode) if you'd rather the harness stop than proceed without a save. Those hooks are one harness's way of automating it; the CLI itself is just a shell command, so it works with Codex, Claude Code, Cursor, or your own loop. Point is: the meter-watch becomes the machine's job, not yours.

## "Won't that bury me in files?"

That was my first worry — continuous capture sounds like artifact soup. It isn't, and the design is deliberate about it. Cadence checkpoints only fire after there's actually been uncheckpointed work and enough time has passed, not on every tool call. The post-compaction path won't write a duplicate if a pre-compaction checkpoint already exists. Superseded intermediates are kept for trace but routed *out* of the normal resume flow, and there's a `manifest` command that indexes what's active versus superseded. Automation here means *less* noise to manage, not more.

## Raw now, structured later

The part that actually dissolved my anxiety: I no longer have to make the *perfect* save at the panic moment, because the raw material is already captured. Checkpoints are cheap provenance — recent paths, titles, timestamps, focus excerpts — explicitly "provenance, not final synthesis." They just sit there.

Then, when a real insight or finding actually arrives — usually well after the moment — `now --from-checkpoints latest` rolls that checkpoint trail up into a fuller **crystal**: git state, changed files, instruction files, decisions with their authority, open loops, and a resume prompt. Raw capture during the flow; structured synthesis when you're ready to think. The two are separate on purpose, and that separation is exactly what lets you stop guarding the boundary.

## What it doesn't do

To keep this honest: agent-crystallize does not preserve hidden chain-of-thought, and it isn't a hosted memory service. It's local-first in the concrete sense — no account, no login, no runtime network dependency, no hosted database, no server to stand up. The artifacts are plain Markdown under `.agent-crystals/`, committed next to the code they explain. If you want provenance without leaking raw transcripts, it stores pointers — a session id, a transcript reference — not the transcript itself.

## The pot doesn't need watching

Since I set this up, I don't watch the meter anymore. Compaction happens; a checkpoint is already there. A new day, a new machine — I resume from the latest crystal instead of from my memory of what I told it last time. The work I care about isn't riding on me catching the boundary in time, so I actually stay in the work.

The ritual I used to perform by hand — the pot-watching, the last-second scramble — turned out to be a symptom, not a duty. The information was never really safe on my vigilance. It's safer sitting in the repo.

```bash
npm install -g @stewie-sh/agent-crystallize
```

[agent-crystallize](https://github.com/stewie-sh/agent-crystallize) is open source under Apache-2.0 and works with Codex, Claude Code, Cursor, or your own loop. Stop watching the pot.

— Vinh, founder of [Stewie](https://www.stewie.sh)