ken

Ken is a self-hosted MCP server that keeps the current state of your life: one linked record of your tasks, people, projects and preferences, shared by every AI app you use. Not what was said, but what is true now. We call that record "your world". One SQLite file, Python, alpha. It uses a model for its checks: OpenAI, any OpenAI-compatible API, a local model, or your Claude Code login.

Get started  ·  Ken Cloud  ·  Benchmark  ·  FAQ  ·  How it works  ·  Discussions

What your agent receives

Over a few chats you told Claude about the kitchen renovation; on Monday, that the plumber sent a quote. On Tuesday, you ask any agent, in any app, to work on "approve the quote from Tomas for the kitchen renovation". The task names only Tomas and the renovation. Ken adds the rest through the links (trimmed):

{
  "task": "approve the quote from Tomas for the kitchen renovation",
  "related": [
    {"kind": "person",  "name": "tomas",
     "why": "named in the task",
     "note": "The plumber; sent a quote on Monday."},
    {"kind": "project", "name": "kitchen renovation",
     "why": "named in the task",
     "note": "New kitchen by December; budget 18k EUR."},
    {"kind": "person",  "name": "maya",
     "why": "linked: maya is a member of kitchen renovation",
     "note": "Your partner; owns the plumber question."},
    {"kind": "asset",   "name": "floor plan",
     "why": "linked: floor plan is part of kitchen renovation",
     "note": "The kitchen floor plan."}
  ],
  "last_report": "Maya asked Tomas to keep the old sink"
}

The agent starts with the budget, who owns the plumber question, the floor plan and the last thing that happened. You typed none of it into this chat. Each item also carries the evidence it rests on (left out above to keep it short).

What Ken stores

What your own apps send (Claude Code on your machine, or any client with your own token) is saved after the judge checks it for duplicates and conflicts. Ken asks you with a card, in the chat you are already in, when a write would change an existing record, when the judge is unsure, when an app saves its own guess rather than your words, or when the write comes from an agent with its own token.

Get started

Rather not install anything? See Ken Cloud.

brew install uv     # skip if you have uv. Linux: curl -LsSf https://astral.sh/uv/install.sh | sh
uv tool install 'ken-engine[mcp] @ git+https://github.com/kenning-labs/ken#subdirectory=engine'
ken init

ken init asks three things: which model Ken uses, whether to add Ken to Claude Code, and whether to run it in the background. Then it tells you what is ready.

Install Ken, a local MCP server, from https://github.com/kenning-labs/ken (README, "Get started"):
1. If `uv --version` fails, install uv: `brew install uv` on macOS with Homebrew, otherwise
   `curl -LsSf https://astral.sh/uv/install.sh | sh`.
2. uv tool install 'ken-engine[mcp] @ git+https://github.com/kenning-labs/ken#subdirectory=engine'
3. Ask me which model Ken should use: my Claude Code login, or an OpenAI API key (never print a key).
   Then run `ken init --claude-code --add-to-claude --service`, or `ken init --api-key <key>
   --add-to-claude --service`.
4. Run `ken status` and `claude mcp list`. Tell me whether the engine is live and which server name
   reaches it, then what to say to start and how to undo the install.

Then, in Claude (Code or Desktop), say "set up my world". Claude reads what it can reach (connected mail, calendar, files) and proposes your people, projects and documents in batches. Ken saves nothing until you say yes.

Connecting an agent. Any MCP client works: Claude Code, Codex, a script on a schedule. Give each agent its own token under http.agent_tokens, and every write from it becomes a card for you. Only your own token can answer a card.

{
  "mcpServers": {
    "ken": { "command": "/full/path/to/ken-mcp" }
  }
}

http:
  host: 127.0.0.1
  port: 8765
  token: "a-long-random-secret"

ken-mcp --http

claude mcp add --transport http ken https://<your-host>/mcp --header "Authorization: Bearer <token>"

ken cards              # the open cards
ken decide <id> yes    # or: no

Ken Cloud

Rather not run it yourself? We run Ken for you: the same engine as this repo, on a small virtual machine and disk of your own in Frankfurt (EU). Sign in with Google, paste one URL into Claude (or ChatGPT, where custom connectors are on), and see your day and your world in a web app. Model calls are included, so you need no API key. Get early access →

What changes when we host it:

• Where your world lives: a 1 GB disk attached only to your machine. Accounts share the sign-in and the URL gateway, not the engine or the database.
• Who can reach it: your own token, and us as the operators of the machine. We do not read it unless you ask us to debug something.
• Model calls: the text of a write goes to OpenAI, under our account, so it can be judged.
• Calendar: if you link Google Calendar, the gateway keeps its token encrypted and reads today's events live for the web app. It stores no events.
• Moving to self-hosting: ask us, and we hand you your SQLite file to run with ken.

Benchmark (alpha)

Alpha run, not proof. 2 scenarios × 3 runs, written by us and used while fixing bugs. We will publish the scenarios, prompts, raw answers and grader, with a run on unseen scenarios and Graphiti added, before these numbers mean more than direction.

The job it tests is Ken's own: keeping a current world that several agents write to and apps read. Read it as a check on that job, not a neutral comparison. The same agent (gpt-5.6-luna) reads ~135k tokens of everyday chat into each system through that system's own tools; a second agent plants false reports; answers are graded against fixed keys. mem0 is the open-source mem0ai 2.2.1 on the same model and text-embedding-3-small.

• mem0 scores 0 on app readability by design: it stores free text, not records. Without that row the score is Ken 86, to-do file 61, mem0 58.
• Ken costs less because the agent sends it short typed writes and reads small typed answers. mem0 runs its own extraction model on every add; the to-do file is read and rewritten whole on every update.
• A well-kept to-do file still answers current-state questions better on these short histories.
• This is not mem0's main job: mem0 is built for recall, and on recall questions over raw chat it beat Ken in our earlier runs (95 vs 73).

Privacy

This is self-hosted Ken. For Ken Cloud, see what changes when we host it.

• Ken stores everything in ~/.ken/: one config file and one SQLite database, both private to you.
• The text of a write goes to the model you configure so it can be judged: OpenAI by default, your Claude Code login, or a local model that keeps it all on your machine.
• Ken sends no telemetry. Apart from those model calls, only ken push sends anything, and only if you turn it on.
• Ken never reads your mail, chats or calendar itself. Your agents read those with their own tools and send Ken the result: who is who, what was decided, what is due.
• Agents you connect run with your permissions. Connect only agents you trust; give each one its own token so its writes come to you as cards.

To remove Ken and everything it stored: uv tool uninstall ken-engine && rm -rf ~/.ken.

FAQ

Questions and ideas: Discussions  ·  Bugs: Issues  ·  Security: SECURITY.md

Contributions are welcome: read CONTRIBUTING.md and the Code of Conduct. Your first pull request asks you to accept the CLA with one click. Changes are in CHANGELOG.md.

Ken is licensed under the AGPL-3.0. Made by Kenning Labs.