CRM for the AI operator

Memory and intent layer for people who work with agents

Name: Throne
Author: gently-whitesnow

Throne amplifies the operator. It doesn't replace your IDE or your agents — it accumulates context, holds intents, and feeds instructions into every session.

Connect Open on GitHub

What it is

A second brain for the operator

Throne stores the operator's intents and preferences and serves them to any agent on demand. Each conversation moves the next result closer to the expected one.

Memory layer

Intents and instructions live outside the IDE and survive sessions. No re-explaining context every time.

Intent shaping

An interview turns «something must be done» into a ready-to-work intent with acceptance criteria.

Boundary

Throne does not replace IDEs or agents. It is the memory layer any agent can plug into.

Demo

Demo video coming soon

A short walkthrough — from install to the first intent — will land here. For now, a quick visual of the operator → throne → agent loop.

Demo video coming soon

Capabilities

What's inside

Intents

A unit of intent with an interview, links and history. Throne helps shape the wording before the agent touches code.

Instructions

Operator-wide rules and per-mode bundle instructions, delivered to the agent through the MCP mini-router.

Dream-loop

Throne watches conversations and proposes instruction refinements that the operator accepts or declines.

Instruction patches

Targeted edits arrive as patches and apply cleanly — no rewriting the memory corpus.

MCP routing

The mini-router in InitializeResult.instructions picks the right bundle on the fly so the agent knows the current mode.

Open core

The core is open at github.com/gently-whitesnow/throne. Data and infrastructure stay with the operator.

Connect

How to wire up an agent

Throne.Api runs locally. The agent spawns the thin STDIO proxy throne-mcp-stdio, which forwards every call to http://localhost:5008. No auth — everything runs under the local user.

Three steps: install the proxy, run the Throne stack, register the server with your agent.

Step 1 — install the STDIO proxy

throne-mcp-stdio ships as a global .NET tool. Requires the .NET 10 SDK. The install command is identical across OSes, but GUI apps on macOS don't see ~/.dotnet/tools — a symlink is required.

macOS / Linux

dotnet tool install -g Throne.Mcp.Stdio

# GUI apps (Claude.app, Cursor) don't pick up ~/.dotnet/tools.
# A symlink into the system PATH makes throne-mcp-stdio visible everywhere:
sudo ln -sf "$HOME/.dotnet/tools/throne-mcp-stdio" /usr/local/bin/throne-mcp-stdio

# upgrade
dotnet tool update -g Throne.Mcp.Stdio

Windows

dotnet tool install -g Throne.Mcp.Stdio

REM %USERPROFILE%\.dotnet\tools is already in PATH.
REM Open a new terminal/IDE window so PATH gets re-read.

REM upgrade
dotnet tool update -g Throne.Mcp.Stdio

Step 2 — run Throne locally

API + UI + Mongo. One command, one docker compose profile. UI at http://localhost:8080, API at http://localhost:5008.

git clone https://github.com/gently-whitesnow/throne
cd throne
docker compose --profile full up -d

Step 3 — register the server in your agent

Same command everywhere: throne-mcp-stdio. No checkout paths, no args. The config path is in each card's description.

Claude Desktop

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "throne": {
      "command": "throne-mcp-stdio"
    }
  }
}

Claude Code

Via CLI: claude mcp add throne -s user -- throne-mcp-stdio · manual: ~/.claude.json (mcpServers).

{
  "mcpServers": {
    "throne": {
      "type": "stdio",
      "command": "throne-mcp-stdio"
    }
  }
}

Cursor

macOS/Linux: ~/.cursor/mcp.json · Windows: %USERPROFILE%\.cursor\mcp.json.

{
  "mcpServers": {
    "throne": {
      "command": "throne-mcp-stdio"
    }
  }
}

Codex

macOS/Linux: ~/.codex/config.toml · Windows: %USERPROFILE%\.codex\config.toml.

[mcp_servers.throne]
command = "throne-mcp-stdio"

Local tool

Memory stays with the operator

Throne builds and runs on the operator's own infrastructure. Open core, owner-controlled data. No middleware between the agent and your context.

Open core: github.com/gently-whitesnow/throne
Compose stack: throne-api + MongoDB
Persistent memory under the operator's control
STDIO proxy installs with one command: dotnet tool install -g Throne.Mcp.Stdio

Roadmap

Where we're heading

A direction vector, no dates — areas where the operator gets stronger.

Positioning Throne as a CRM for the AI operator
Adaptive code-review fork with diagrams and static analysis — less verification time
Improving the CRM for executing real work with AI
Per-iteration project memory — short state
Per-project long-state memory
Plugins: Kaiten, Mattermost, and the rest of the work toolbox
Multi-tenant and collaborative use

Contact

Reach the author

Throne is run by an operator-author. Open channels — GitHub and Telegram.

GitHub · github.com/gently-whitesnow/throne Telegram · t.me/gently_whitesnow