You open three terminal tabs. Claude Code in one, reviewing a PR. Cursor in another, writing tests. A third session deploying to staging. Each one is smart. Each one is fast. And none of them know the other two exist.
This is the default state of AI-assisted development in 2026. Every session starts from zero. No shared tasks. No message passing. No way to say "the PR review found a type error in auth.ts — hold off on the deploy."
You become the coordination layer. Copy-pasting context between windows. Manually sequencing work that should be automatic. The agents can write code in seconds, but they can't pass a note.
I built CacheBash to fix that.
What It Does
CacheBash is an MCP server. You point your AI client at it, give it an API key, and your sessions gain 34 tools for coordinating with each other.
Task dispatch. One session creates a task. Another claims it, works it, marks it done. Priority queues, lifecycle tracking, claim-based ownership so two agents don't grab the same work.
Message relay. Direct messaging between sessions. Multicast to groups. Threaded conversations. An agent reviewing code can send a finding directly to the agent writing tests — no human relay required.
Sprint orchestration. Break work into stories, assign them to waves, run them in parallel. Wave 2 doesn't start until Wave 1 finishes. The server tracks progress, not you.
Persistent memory. Each agent writes operational state — what it was doing, what it learned, what's unfinished. Next session reads that state and picks up where the last one left off. No context lost between sessions.
Mobile notifications. Questions that need a human decision get pushed to your phone. Approve a deploy from the grocery store. Answer a clarifying question from the couch. The agent waits for your response, then continues.
How It Works
The architecture is straightforward:
AI Clients (Claude Code, Cursor, VS Code, Gemini CLI)
|
MCP Protocol (Bearer auth)
|
CacheBash MCP Server (Cloud Run, TypeScript)
|
Firestore (tasks, messages, sessions, program state, telemetry)
|
Mobile App (iOS + Android — monitoring, approvals)
The server runs on Cloud Run. Firestore handles persistence. The mobile app is React Native + Expo. Auth is dual-layer: API keys (SHA-256 hashed, never stored in plain text) for MCP clients, Firebase JWT for the mobile app.
Thirty-four tools across nine modules:
| Module | Tools | What It Does | |--------|-------|-------------| | Dispatch | 4 | Task lifecycle — create, claim, complete. Priority queues with interrupt/queue/backlog actions. | | Relay | 6 | Inter-agent messaging. Direct, multicast groups, threaded conversations, dead letter queue. | | Pulse | 4 | Session health — status, heartbeat, progress tracking. Fleet health dashboard. | | Sprint | 5 | Parallel work coordination. Stories, waves, dependencies, completion tracking. | | Signal | 3 | Push questions and alerts to your phone. E2E encrypted. Agents wait for your response. | | Dream | 2 | Autonomous scheduling. Agents peek for overnight work, activate sessions with budget caps. | | Program State | 2 | Persistent operational memory. Context summaries, learned patterns, handoff notes. | | Keys | 3 | Per-agent API key management. Create, list, soft-revoke with audit trail. | | Observability | 5 | Audit log, cost/token tracking, comms metrics, operational metrics, execution traces. |
Rate limiting is built in: 120 reads and 60 writes per minute per user.
Client Compatibility
CacheBash uses Streamable HTTP transport with Bearer token auth. It works with any MCP client that supports those two things.
| Client | Status | |--------|--------| | Claude Code | Production driver. Used daily. | | Cursor | Works out of the box. | | VS Code + Copilot | Works out of the box. | | Gemini CLI | Works. Supports env var expansion for the API key. | | ChatGPT Desktop | Incompatible. Requires OAuth 2.1 — no Bearer token auth. |
Four out of five. No backend changes needed for any of them.
Quick Start
Add this to your MCP config:
{
"mcpServers": {
"cachebash": {
"url": "https://your-instance.run.app/v1/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}
Restart your client. Create a task in one session:
> create a task titled "Review auth module" with priority high
Claim it in another:
> check for pending tasks and claim the highest priority one
Two sessions, coordinated. No shared filesystem. No custom scripts. No clipboard.
What Agents Actually Do With This
The interesting part isn't the individual tools. It's what happens when agents chain them together.
A code review agent finds three issues. It creates a task for each one, tagged with priority and file path. A builder agent polls for tasks, claims one, fixes it, and marks it complete. A third agent watches for all tasks to resolve, then opens the PR.
Nobody copy-pasted anything. Nobody said "now do the next one." The agents coordinated through the server.
Program state makes this durable. Each agent writes what it was working on, what it learned, and what's still open. When a session ends and a new one starts — even hours later — it reads that state and picks up mid-task. The context is in Firestore, not the chat window.
Sprint orchestration takes this further. Define stories with dependencies — "run tests" depends on "fix type errors" — and the server schedules them in waves. Wave 1 runs in parallel. Wave 2 starts when Wave 1 finishes. You watch progress from the mobile app while doing something else.
The Signal module closes the human-in-the-loop gap. An agent hits a decision it can't make. It sends the question to your phone with options. You tap an answer. The agent picks up where it left off. No terminal switching. Just a push notification and a tap.
What's Next
CacheBash is open source under MIT. Self-hostable on GCP. The server, mobile app, and all 34 tools are in the repo.
Short-term roadmap: OAuth 2.1 support to unlock ChatGPT Desktop, webhook integrations for Slack and Discord, and GitHub sync so tasks mirror to Issues automatically.
The MCP ecosystem is growing fast. Every week, more clients ship MCP support. CacheBash doesn't care which client you use — it speaks the protocol.
If you're running multiple AI sessions and coordinating them by hand, you don't have to. The agents are already smart enough. They just need a way to talk.