Keeping Claude Code, Cursor, and Codex on Track with ContextSwitch

Working with AI coding agents is great until you switch between tools. You spend an hour getting Claude Code set up with context, then a new great model comes out and you need to jump into Cursor to try it out, and suddenly you’re re-explaining the entire project plan. Again.

The same happens when the projects get truly large and complex. For a toy project the internal agents’ project management tools work well, but for a large application or long term development that project context gets lost in the noise (or in 20 markdown files in the repo).

I got tired of this context-switching penalty, so I built ContextSwitch: a native macOS app that’s basically a kanban board your AI agents can read and write to via Model Context Protocol (MCP). The idea is simple: keep one source of truth for what needs to be done, and let agents pull from it regardless of which tool you’re using.

How ContextSwitch Works

ContextSwitch stores your project tasks in a SQLite database that lives right in your git repo (as todo.db). Each project gets its own database, and the macOS app gives you a nice kanban view to manage everything:

The key is the MCP server built into the app. It exposes tools that let AI agents:

• List all current tasks
• Add new tasks with priorities and tags
• Mark tasks as done
• Update task status and details
• Create dependencies between tasks
• Search across your backlog

Because it’s MCP, any agent that supports the protocol can connect to the same database. Claude Code, Cursor’s AI, and Claude Desktop all see the same task list.

Agent-First Design

The real insight was designing the database schema for agents, not just humans. Each task includes:

Structured metadata:

• Status (open/in progress/done/archived)
• Priority (high/medium/low)
• Tags for filtering
• Due dates and creation timestamps
• Long-form description fields for context

Dependency tracking:

• Tasks can block other tasks
• Agents can check if prerequisites are complete
• Prevents working on things out of order

Rich context capture:

• Full markdown support in descriptions
• Links to relevant files or documentation
• Notes about implementation decisions

This gives agents enough context to pick up work without you having to re-explain everything.

Real Usage Example

Here’s what it looks like in practice:

In Claude Code:

Me: "Review the current project tasks and start working on what's next"

Claude Code: [calls list-items MCP tool]
"I see you have 'Build data table component' marked as in progress.
The prerequisites are complete. I'll continue with that implementation..."

Later in Cursor:

Me: "What should I work on next?"

Cursor AI: [calls list-items with status filter]
"You have 2 high-priority tasks in the backlog:
1. Update typography scale (#4)
2. Document API endpoints (#7)

The data table component is currently in progress by another session.
Should we tackle the typography work?"

Same database, different tools, consistent state.

The Multi-Database View

The macOS app manages multiple projects simultaneously. The sidebar shows all your active databases with task counts:

You can drag tasks between databases (for when you realize something belongs in a different project), search globally across all databases, and see a unified timeline of upcoming work.

The “Overview” mode gives you a rolled-up view of everything across all projects:

Task Details and Editing

Click any task and you get a detail panel with full editing capabilities:

You can set priorities, add tags, define blockers, and write detailed context in the long description field. This is what agents see when they query for task details.

Archived Items

Completed tasks move to an archive view so they don’t clutter your active board but remain searchable:

This gives you project history without losing the ability to reference how something was built.

Creating New Tasks

Both humans and agents can create tasks. The UI has a simple modal with all the fields an agent might need to set:

When an agent creates a task, it can set priority, tags, and descriptions just like you would manually. This means Claude Code can say “I noticed we need tests for this feature” and create a properly tagged, prioritized task for later.

Model-Agnostic Coordination

Because everything goes through MCP, you can switch between:

• Claude Code for exploratory work and file operations
• Cursor for inline editing and refactoring
• Claude Desktop for planning and breaking down features
• Any other MCP-compatible tool

Each agent sees the same state, so you’re not locked into one tool for the duration of a project.

Configuration

Setup is straightforward. Build the app, then add it to your Claude Desktop config:

{
  "mcpServers": {
    "contextswitch": {
      "command": "/Applications/ContextSwitch.app/Contents/MacOS/contextswitch-mcp"
    }
  }
}

This gives Claude Desktop access to all your bookmarked databases. For project-specific access, you can scope it to a single database:

{
  "mcpServers": {
    "contextswitch": {
      "command": "/Applications/ContextSwitch.app/Contents/MacOS/contextswitch-mcp",
      "args": ["--database", "/path/to/project/todo.db"]
    }
  }
}

What I’ve Learned

Agents need more context than humans: When I create a task, I remember the surrounding decisions. Agents don’t have that implicit context, so task descriptions need to be more detailed. These of course can also be written by other agents, and ContextSwitch helps with that. Use a deep research model to search the web and

Dependencies matter more than I thought: Having agents check blockers before starting work prevents a lot of wasted effort on things that can’t be completed yet. For very large features the dependency web is complex!

Tags enable better filtering: Agents can query “show me all frontend tasks” or “list high-priority bugs” without me having to manually organize things.

The database living in the repo is key: It gets versioned with the code, so when you switch branches, your task context switches too. Checkout an old branch and you see the tasks from that point in time. This lets you roll back database state as well, if you do a large planning exercise, that itself is a commit and versioned.

What’s Next

I’m experimenting with MCP Prompts that help provide common prompt patters to users for things like backlog grooming, ticket context development, and dependency mapping.

The goal is to make project coordination transparent enough that switching tools is just… switching tools. No overhead, no lost context, just continuity.

Personal Software

ContextSwitch is personal software I built for myself and use daily. It’s not published anywhere, at least not yet. Like Evergreen, it solves a specific problem in my workflow well enough that I keep coming back to it.

I might release it on the App Store at some point, but for now it’s just a tool that makes my day-to-day development smoother. Building native macOS apps for personal use has this nice property: you can optimize for exactly your workflow without worrying about edge cases or making things configurable for other people.

The bigger idea is that MCP enables tools to compose in ways that weren’t possible before. Your task management doesn’t need to live inside your editor, it can live in a purpose-built app that any editor can talk to. Same with debugging tools, documentation systems, or test runners.