Getting the Most Out of Continue On: Token-Aware Briefings

When you export your development context to another AI tool, you run into a quiet problem: every tool has a different appetite for context.

Paste a short briefing into a fresh Claude Code session and you leave out decisions that matter. Paste your entire session history into a Claude Project system prompt and you might overflow the available space, or bury the important parts under a wall of historical detail that the model has to wade through.

Token-aware briefings solve this. KeepGoing now generates context exports in three sizes, each designed for a specific use case.

The three tiers

Short (~500 tokens)

Key facts only. The short briefing includes your project name, current branch, last checkpoint summary, and the single most important next step. Nothing else.

It looks something like this:

# Project Context: my-app

**Branch:** feat/auth-flow
**Last worked:** 3 hours ago
**Status:** Implementing OAuth token refresh logic

**Next step:** Write integration tests for the refresh flow

**Recent decisions:**
- Switch from session cookies to JWT with refresh tokens

Use this when you are adding context to a persistent system prompt, like a Claude Project or a custom GPT. Those prompts get sent with every message, so shorter is better. You want the model to know the shape of what you are building without spending tokens on last week’s architecture discussions.

Medium (~2000 tokens)

Recent decisions and context. The medium briefing adds your last few checkpoint summaries, the files you touched in your most recent session, recent commit messages, and the last several high-signal decisions captured by KeepGoing.

This is the default for most Continue On exports. It gives the receiving tool enough to understand not just where you are, but how you got here. It fits comfortably within the input limits of ChatGPT, Gemini, and similar tools while still carrying meaningful context.

Full (complete history)

Everything. All checkpoints, all decisions, all recent commits. The full briefing is for situations where you want nothing left out, like starting a fresh Claude Code session or handing off to a long-context model that can actually use all of it.

It is not always the right choice. More context is not automatically better. But when you are resuming a multi-week project and want the receiving tool to have the complete picture, the full briefing is there.

How Continue On picks a tier

When you run keepgoing continue, the CLI defaults to the medium briefing. When you target a specific tool, KeepGoing applies a sensible default for that target:

--target claude: full briefing (Claude’s context window is large, and a fresh Claude Code session benefits from complete history)
--target chatgpt, --target gemini, --target copilot: medium briefing
No target: medium briefing

You can always override this explicitly:

# Short briefing for a system prompt
keepgoing continue --tier short --target claude --open

# Full briefing for a deep dive
keepgoing continue --tier full

Using the MCP tool directly

If you are working in Claude Code, Cursor, or Windsurf, the get_reentry_briefing MCP tool accepts a tier parameter:

get_reentry_briefing({ tier: "short" })
get_reentry_briefing({ tier: "medium" })
get_reentry_briefing({ tier: "full" })

This is useful when you want a briefing formatted for a specific purpose inside your current session. For example, you might ask your AI agent to generate a short briefing to paste into a Claude Project you are setting up, without leaving the editor.

Practical examples

Setting up a Claude Project for an ongoing codebase. You maintain a long-running side project and want Claude Projects to always have context when you start a conversation. Use keepgoing continue --tier short to generate a compact briefing, then paste it into the project’s system prompt. The model will know your branch, your current focus, and your most important recent decision without the system prompt eating into every message’s token budget.

Switching from Claude Code to ChatGPT mid-session. You have been working in Claude Code and want to move a debugging question to ChatGPT. Run keepgoing continue --target chatgpt --open. The medium briefing covers your last session summary, the files you touched, and enough decision history for ChatGPT to understand the context of your question. The browser opens automatically and the prompt is on your clipboard.

Onboarding a fresh Claude Code session for a complex project. You are picking up a project after a few weeks away, starting a new Claude Code conversation, and want it to have the full picture. Run keepgoing continue --tier full --target claude --open. The complete history goes in, and you can ask Claude to summarize the state before diving into work.

Why this matters

Most developers working across multiple AI tools do not think about token limits until something breaks. You paste a briefing into a system prompt, things seem fine, and later you notice the model ignoring parts of it. Or you paste a minimal briefing and spend the first five minutes of a conversation explaining context that KeepGoing already had.

Token-aware briefings make the tradeoff explicit and give you control over it. The tiers are not arbitrary size limits. They reflect different use patterns: persistent context for system prompts, conversational context for mid-session hand-offs, and complete history for deep resumption sessions.

To try it, make sure you have the latest KeepGoing CLI installed and have at least one saved checkpoint in your project:

npm install -g @keepgoingdev/cli
keepgoing continue --tier short

You can read more about Continue On and the full set of export options on the Continue On page.

The right amount of context is not the maximum amount. It is the amount the tool can actually use.