KeepGoing for Cursor and Windsurf: Stay in Context Between AI Coding Sessions

You spend an hour deep in a Cursor Composer thread. The AI knows your schema, your constraints, the three approaches you already ruled out. You close the editor. You come back the next morning, open a new Composer thread, and type “let’s continue the auth work.”

The AI has no idea what you mean. It starts fresh. You spend the first fifteen minutes re-explaining what you were building, why you made certain choices, and where you got stuck. The context you built up is gone.

This is not a bug in Cursor or Windsurf. It is how these tools work. Each new thread is a blank slate. The intelligence lives in the model, not in your project history.

KeepGoing fills that gap.

What KeepGoing captures

KeepGoing records checkpoints as you work: what you accomplished, what comes next, which files you touched, and any blockers you hit. These live in a .keepgoing/ directory at your git root, plain text files that go nowhere.

When you start a new session, KeepGoing can brief your AI tool with that history. Instead of starting from zero, the AI opens with full context.

For developers using decision detection (a Pro feature), KeepGoing also tracks high-signal architectural choices from your commit history. When you reach for a pattern you used three weeks ago, the briefing can surface why you made that call.

How the MCP integration works

Both Cursor and Windsurf support the Model Context Protocol, which means they can connect directly to the KeepGoing MCP server. Once configured, two tools become available in every session:

get_momentum returns a compact summary of your last checkpoint: when it was, what you did, what comes next, your current branch, and which files were active. It fits comfortably in a context window even on a short-context model.

get_reentry_briefing goes deeper. It pulls in recent decisions, the arc of your last few sessions, and any blockers you flagged. This is the one to reach for when you’ve been away for a few days and need the full picture.

You can invoke these yourself by asking the AI to use them, or configure a session-start hook so they run automatically every time you open the project.

Starting a session in Cursor

Once the MCP server is connected, open a new Composer thread and say:

“Use get_momentum to see where I left off, then let’s continue from there.”

Cursor calls the tool, reads the response, and you get something like:

You were working on the webhook handler for Stripe events. Your last checkpoint was 18 hours ago. The next step is to add signature verification before processing the payload. You touched src/api/webhooks.ts and src/lib/stripe.ts. No blockers noted.

From there, the session has real context. You can dive straight into code.

For automatic briefing on every session open, configure a SessionStart hook that runs npx -y @keepgoingdev/mcp-server --print-momentum. Cursor will print the summary before your first message, so context is there before you even ask.

Starting a session in Windsurf

The setup is the same. Connect the MCP server through Windsurf’s MCP configuration, then start a new Cascade and ask it to call get_momentum or get_reentry_briefing.

Windsurf’s Cascade is particularly good at acting on structured context. When you hand it a clear next step from your last session, it tends to stay on track without needing as much back-and-forth to establish what you want.

The setup guide for Windsurf walks through the MCP configuration step by step.

Token-aware briefings

One practical concern with injecting session context is token cost. A full briefing with decision history, session arc, and file lists can get long.

KeepGoing offers three tiers:

Short (get_momentum): one-liner summary, branch, next step. A few hundred tokens. Good for quick re-entry or when you are mid-session and just need a nudge.
Medium (get_reentry_briefing default): last session detail, recent decisions, recent commits. Around 500-800 tokens. The right choice for most morning re-entries.
Full (get_reentry_briefing with full context): everything, including the last few sessions and extended decision history. Use this after a long break or when you are handing off to a different AI tool entirely.

Pick the tier that fits the moment. You are not locked in to one approach.

The “Continue On” feature

Sometimes you want to move context from Cursor to a different tool. Maybe you want a second opinion from Claude, or you need to share the situation with a teammate who uses a different editor.

The Continue On feature handles this. It assembles your KeepGoing session data into a formatted markdown prompt you can paste anywhere. Run it from the CLI:

keepgoing continue

Or from within Cursor or Windsurf, ask the AI to use the continue_on MCP tool. The output is a self-contained briefing that any AI tool can act on without needing KeepGoing installed.

This is useful when you spend the morning in Cursor and want to move to Claude for a design review in the afternoon. The context follows you.

Getting set up

The fastest path is the MCP server. Add it to your Cursor or Windsurf MCP configuration:

{
  "mcpServers": {
    "keepgoing": {
      "command": "npx",
      "args": ["-y", "@keepgoingdev/mcp-server"]
    }
  }
}

Then run keepgoing setup cursor or keepgoing setup windsurf to configure hooks. The setup is idempotent, so you can re-run it without worrying about duplicating config.

For detailed instructions with screenshots, the integration pages have everything:

Or start from the general setup guide if you want to understand the full picture first.

Why this matters for AI-first workflows

The promise of AI-powered editors is that they make you faster. That is true when you are in flow. The problem is re-entry. Every new Composer thread, every new Cascade, starts from zero. You pay a context tax at the beginning of every session, and you pay it again every time you switch tools.

KeepGoing does not change how these editors work. It just keeps a record of what you were doing and hands it back when you need it. The context you built up does not disappear. It waits for you.

Your next session should start where your last one ended.