Cookies on Kythene

We use cookies and similar technologies for the things below. You can accept all, reject everything except what's essential, or pick what you're OK with.

Preferences
Theme, language, dismissals. Improves the experience but the site works without.
Improvement
Anonymous usage measurement so we can fix bugs and prioritise work.
Marketing
Lets us measure whether ads we run send people who actually use the site. We don't share personal data with advertisers.

Read our cookies policy and the privacy policy. California residents: Do Not Sell or Share My Personal Information.

Loading…
kythene
Open the app

Getting started

You connect to Kythene two ways, and most people use both: your AI assistant over MCP, and the kythe CLI in your terminal. This page gets each one working and walks you through your first publish and recall.

Everything below assumes the hosted app at https://kythene.com. If you self-host, swap in your own URL.

1. Sign in and find your workspace

Sign in with GitHub. Your first sign-in creates a workspace for you - the container that holds your work, your members and your billing. Inside it you organise work into projects (see Concepts).

Everything you publish lives in a workspace. You can belong to several.

2. Connect your AI assistant (MCP)

This is the important one: it lets an instance publish, recall memory and see what the team is building, in-session.

Fastest - one paste. Copy this into your assistant (Claude Code, Cursor, Codex, Copilot - any of them) and it connects itself over MCP, no config or keys:

You are my AI assistant. Connect yourself to Kythene - my team's shared memory and
output layer - by fetching https://kythene.com/setup-prompt.md and doing exactly
what it says. Then tell me it worked.

Cursor users get a one-click Add to Cursor button on the Kythene home page. Prefer to wire it up by hand? The per-client steps are below.

In the app, open Connect your AI (in the workspace nav). It shows your MCP endpoint - it looks like:

https://kythene.com/mcp/kythene

Claude Code:

claude mcp add --transport http kythene https://kythene.com/mcp/kythene

The first time your instance calls a Kythene tool, Claude opens a browser to log you in and authorise it (OAuth). No API key is needed for MCP - the assistant registers itself and you approve it.

Claude desktop / web: Settings -> Connectors -> Add custom connector, paste the MCP URL, then authorise when prompted.

Cursor: Settings -> MCP -> Add new MCP server, choose an HTTP server and paste the same URL. Authorise in the browser when it prompts.

Codex, Copilot and other MCP clients: add Kythene as a remote (streamable HTTP) MCP server pointing at the same URL. Kythene registers your client automatically over OAuth, so there is no key to copy anywhere.

Your team does not have to agree on one assistant: everyone connects whatever they already use, and they all read and write the same workspace.

Plugin + skill bundle (recommended for Claude Code): one install that sets up the connection and teaches your instance the Kythene workflow. Download the bundle (no sign-in needed) and install it:

curl -O https://kythene.com/kythene-plugin.zip
unzip kythene-plugin.zip
# in Claude Code:
/plugin marketplace add ./kythene
/plugin install kythene@kythene

(Signed in, you can also grab the bundle from the Connect your AI page.)

Once connected, your instance can publish, recall, remember, walk the timeline and review work - ask it to, or let the skill prompt it.

3. Connect the CLI (kythe)

For scripts and terminals. The CLI uses an API key, not the browser login.

Download the archive for your platform from github.com/kythene/cli/releases (linux / macOS / Windows, amd64 / arm64), extract the kythe binary and put it on your PATH. On macOS/Linux:

tar xzf kythe_*_$(uname -s | tr A-Z a-z)_*.tar.gz kythe
sudo mv kythe /usr/local/bin/
kythe --help

Create a key: in the app, Connect your AI (or Settings) -> create an API key. Copy it once - it is shown only at creation. Then:

export KYTHENE_URL=https://kythene.com
export KYTHENE_TOKEN=twk_...          # the key you just created

Tip: put those in your shell profile so kythe just works in every terminal.

4. Your first publish and recall

Publish a file:

kythe publish ./bench.json --title "Nightly benchmark" --tag api

That creates a collection (one publish, one or more artifacts) tagged api. See it land:

kythe timeline --tag api

Now write a memory and recall it - this is the bit your instances lean on:

printf '# Deploy order\nRestart db, then app, then www.\n' | kythe remember - --project infra --title "Deploy order"
kythe recall --project infra

From an AI instance connected over MCP, the same thing happens in one call: ask it to "recall the infra deploy order" and it pulls that memory back, with its provenance, mid-session.

5. Prefer to self-host?

Run the whole of Kythene on your own infrastructure - your servers, your data. See Self-hosting for the quick start (Docker Compose, the first-run admin, and licensing).

Where to next

  • Understand the model: Concepts.
  • Pick the way you work and follow it end to end: the walkthroughs on the docs home.