open source · vendor-neutral · local files

Mark your
trail.

Rate limited. Model died. Context compacted. You switched tools. The code is still in git—the working state is not.

Local CLI and MCP server for checkpoints and handoff packets. Resume after a crash. Move context across tools, repos, or agents—no cloud account.

Install npm install -g @3notch/cli
Or paste into your agent
Install @3notch/cli, run notch onboard in this repo, enable continuation checkpoints for Claude Code if needed. Use packets for cross-tool or cross-repo handoffs.

No account. Runs on your machine.

No cloud No account No telemetry No lock-in


THE PROBLEM

The code survives. The working state doesn't.

Git has the files. It does not have the objective you were mid-way through, the decisions you already made, or the landmines you already stepped on.

Vendors optimize for their own product. Claude will not make it easy to hand a live session to Codex. Codex will not make it easy to hand one to Cursor. That is not a bug in any one tool—it is the market structure.

3Notch is a neutral, local format for the state that falls between commits: what you were doing, what finished, what is blocked, and what is next. You decide what gets written. Nothing scrapes your chats in the background.

Session died
Resume from a checkpoint With Claude Code hooks enabled, 3Notch can write a fallback before the trail goes cold.
Switching tools
Write a packet, import it Outgoing agent records the handoff. Incoming agent reads it after you approve.
Async agents / repos
Durable inbox Pack, send to a shared mailbox, forward a text notice, pull and ack on the other side.

HOW IT WORKS

Session dies. Context survives.

Turn on continuation checkpoints for Claude Code. When the session fails for reasons that are not your fault, 3Notch can leave a checkpoint the next session can offer you.

Without 3Notch

Start over from memory.

New session. Blank agent. You reconstruct the plan from commits, chat scraps, and whatever you still remember. That reconstruction is slow and incomplete—and you pay for it every time the model flakes.

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...

~20 minutes to get back to where you were.
With 3Notch

Offer a checkpoint. You approve.

A fallback packet is already on disk: objective, tasks, git state. The next session can surface it once in chat. Nothing loads into the agent until you confirm.

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

agent Found a continuation for this stream.
agent Want me to load it and continue from Redis?
you yes, load it

✓ Loading packet after your confirmation.

USE CASES

Four common breaks. Same local format for all of them.

Session failed

Rate limit, overload, compaction.

Claude Code hooks can write a continuation checkpoint from task state and git—including model-down failures, not only rate limits. Next session can offer it once.

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

Claude today. Codex tomorrow.

Outgoing agent writes a handoff packet. Incoming agent imports it. No vendor bridge required—Markdown and optional artifacts on disk.

$ notch packet show <id>
  completed: 4 of 6 tasks
  blocked: API schema change
  next: update client types
Files need to travel

Pack a .notchpkt archive.

Hash-verified artifacts for the other machine or repo. Move the archive with scp, git, AirDrop, or whatever you already trust.

$ notch packet pack <id>
  auth-refactor.notchpkt
  3 files · sha256 verified
   your transport
Async agents

Durable inbox between stores.

Two repos share a mailbox root. Send a packed project packet, forward the text delivery notice (chat, Slack, Claude messaging), then pull, import, and ack.

$ notch send pkt.notchpkt --to local:review
  notice: pull delivery_…
$ notch inbox pull … --import
$ notch inbox ack …

You stay in control. Checkpoints are offered, not force-loaded. Packets do not auto-commit or leave the machine unless you move them. Local addresses are routing labels, not authenticated identity.


UNDER THE HOOD

Plain Markdown. No database. Local by default.

Packets are files under .notch/. You can open them, diff them, and keep them out of git when they should stay private.

Under the hood

Readable by you. Usable by the next agent.

  • Explicit writes only — you or the agent choose what to save. No chat scraping, no background daemon.
  • Secret scanning on write — credential-like content is blocked before it lands in a packet.
  • MCP where it helps — Claude Code, Desktop, Cursor, and other stdio clients; pack/import when MCP is not available.
  • Your transport — scp, git, AirDrop, Tailscale, a shared mailbox root. 3Notch does not host a relay.
  • No SQLite, no native addons — TypeScript on Node 20+.
.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.

Create a packet with the objective, completed work, blockers, and next steps—plus files if the other side needs them. Import it in the other tool, or pack a .notchpkt and move it yourself. npm install -g @3notch/cli

With Claude Code continuation checkpoints enabled, 3Notch can write a fallback on rate limits, model-down failures (overload, server error, and related cases), and compaction. The next session may offer that checkpoint once; you approve before anything is loaded.

Use the durable inbox: both stores register the same mailbox root, you send a packed project packet, forward the plain-text delivery notice through any channel you already use, then pull/import/ack on the receiver. Local addresses are labels, not auth.

Yes. MCP for clients that support it; pack/import for everything else. Packets are Markdown on disk, not a proprietary memory store.

No. Memory tools grow one vendor's context window. 3Notch moves selected working state across sessions and tools as files. No embeddings, no hosted index.

MIT. No SaaS tier, no account, no telemetry. Install from npm and run locally.


open source · MIT · local by default

Stop rebuilding
context.

Install once. Use checkpoints when a session dies. Use packets when work has to move.

$ npm install -g @3notch/cli
Paste this into your agent
Install @3notch/cli, run notch onboard here, enable continuation checkpoints for Claude Code if needed. Use packets for cross-tool or cross-repo handoffs. Read the package README before changing MCP config.