open source · works with every AI tool · nothing leaves your machine

Mark your
trail.

Your AI session died. Six hours of decisions, constraints, and working state—gone. The next agent starts from scratch because nothing portable survived the switch.

3Notch saves the working state your AI tools won't. Local checkpoints that survive rate limits, context compaction, and model switches. Portable packets when context needs to move across tools, repos, or machines.

Paste this into your agent
Install 3Notch and set up context checkpoints for this repo. When a session crashes or I hit a rate limit, save where I was so the next session can pick up. When I switch tools, package the handoff.
Or run npm install -g @3notch/cli
No cloud No account No telemetry No lock-in


THE PROBLEM

The code survives. The working state doesn't.

Rate limited at 2 AM. Context window compacted mid-refactor. Switched models because the cap hit at the worst moment. Every time, you rebuild from zero—re-explaining the goal, the constraints, what you already tried.

Your commits, docs, and wiki hold durable knowledge. But the objective you were chasing, the decisions you'd made, the blockers you'd identified, what you'd already verified—that state dies with the session. No AI vendor will fix this. Anthropic won't ship "easily move your context to Codex." OpenAI won't ship "easily move to Claude."

A neutral, locally-owned format is the only place this problem gets solved.

Session crashed?
Pick up where you left off 3Notch already saved your working state. The next session offers to resume.
Switching models?
Take your context with you The outgoing agent writes what's done, what's blocked, what's next. The incoming agent reads it.
Different tool?
Package the handoff Bundle the relevant files, decisions, and next steps into a portable packet.

HOW IT WORKS

Session dies. Context survives.

When a session hits a rate limit or compacts, 3Notch saves the working state automatically. When you start a new session, it offers to pick up where you left off.

Without 3Notch

Start over. Every time.

Your session crashes at 2 AM. You open a new one, re-explain the project, re-describe what you were building, re-list what's done and what isn't. Forty minutes later you're back where you were—if you remembered everything.

new session
agent How can I help you today?

you ok so we were working on the auth
you middleware refactor and we'd already
you finished the token validation but the
you session management piece still needs...
you actually wait, let me check what we
you committed vs what was in progress...

40 minutes to get back to where you were.
With 3Notch

Resume in seconds.

3Notch saved a checkpoint when the last session ended. The new session finds it, shows you what it contains, and picks up with full context after you approve.

new session · 3notch
3notch Found checkpoint: auth-middleware-refactor
  objective: refactor auth middleware
  completed: token validation, route guards
  blocked: session store migration
  next: implement Redis session adapter

agent Resume from this checkpoint? (y/n)
you y

✓ Resuming. Picking up at Redis session adapter.

USE CASES

Three ways your context breaks. One tool to fix all of them.

Session crashed

Rate limited. Compacted. Model went down.

Doesn't matter why—3Notch already saved where you were. Your next session offers to pick up exactly where this one stopped.

$ notch packet list
  auth-refactor  checkpoint
  next: Redis session adapter
   ready to resume
Switching models

Moving from Claude to Codex because the cap hit?

The outgoing agent writes a checkpoint: what's done, what's blocked, what's next. The incoming agent reads it and confirms before continuing.

$ notch packet show latest
  completed: 4 of 6 tasks
  blocked: API schema change
  next: update client types
   portable across tools
Different tool, different repo

Built in Claude Code, need to continue in Cursor?

Package the relevant files, decisions, and next steps into a portable packet. The receiving tool picks it up with full context.

$ notch packet pack latest
  auth-refactor.notchpkt
  3 files · sha256 verified
   move it however you want

You stay in control. A new session offers the checkpoint once and loads it only after you approve. Nothing commits, pushes, or travels automatically.


UNDER THE HOOD

Plain Markdown. No database. Completely local.

A 3Notch checkpoint is a Markdown file you can read, edit, and version like any other file in your repo. Selected files travel alongside it, hash-verified. Everything stays on your machine unless you move it yourself.

What you'd expect from a CLI tool

Readable by you. Useful to the next agent.

  • You control what's saved — only context you or your agent explicitly supply. Nothing runs in the background.
  • Secret scanning built in — every write is scanned for credentials. Packets land clean or not at all.
  • Works with any AI tool — Claude Code, Codex, Cursor, ChatGPT, or whatever ships next. MCP server included.
  • Your transport, your call — move packets via Git, email, AirDrop, Tailscale, or anything else you trust.
  • Zero dependencies — no SQLite, no native compilation. Pure TypeScript, runs everywhere Node does.
.notch/outbox/auth-refactor/
auth-refactor/
  ├─ packet.md
  │  stream: auth-refactor
  │  completed: token validation
  │  next: Redis session adapter
  ├─ manifest.json   sha256 verified
  └─ artifacts/
     ├─ session-store.ts
     └─ migration.sql

 Readable now. Portable anywhere.

FAQ

Common questions.

3Notch creates portable checkpoints that capture your current objective, completed work, decisions, blockers, and next steps. When you switch from one AI tool to another—say Claude to Codex—the outgoing agent writes a checkpoint and the incoming agent reads it to resume with full context. One install command: npm install -g @3notch/cli

3Notch saves working state when a session hits a rate limit or compacts its context window. When you start a new session, 3Notch offers the latest checkpoint for review and loads it after you approve. You resume in seconds instead of spending 30–40 minutes re-explaining your project.

Yes. 3Notch is vendor-neutral and works with any AI coding tool. It includes a built-in MCP server for tools that support Model Context Protocol (Claude Code, Claude Desktop, Cursor), and portable .notchpkt archives that can be imported into any tool. Checkpoints are plain Markdown files readable by any agent.

Neither. Memory tools help a single AI tool remember more. 3Notch makes working context move between tools. Checkpoints are plain Markdown files with structured frontmatter—no database, no embeddings, no cloud service. You can read, edit, and version them like any other file in your repo.

Completely free, open-source software under the MIT license. No cloud service, no account, no telemetry, no paid tier. Everything runs locally on your machine.


open source · MIT · works everywhere

Stop rebuilding
context.

One command to install. Works with Claude, Codex, Cursor, and whatever you switch to next.

$ npm install -g @3notch/cli
Paste this into your agent
Install 3Notch and set up context checkpoints for this repo. When a session crashes or I hit a rate limit, save where I was so the next session can pick up. When I switch tools, package the handoff.