Getting started

Fifteen minutes from nothing to your AI instance recalling context you gave it earlier. The only step that really matters is the first one: connect an assistant. Everything after that happens in conversation.

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

1. Sign in

Sign in with GitHub or Google at kythene.com. Your first sign-in creates your own workspace - the container that holds your work, your members and your billing. It starts as a personal workspace, just you.

To work with a team, create or join a shared team workspace and invite people from Settings -> Members. You can belong to several. Memory your instances make stays in the workspace you're working in - so a finding in your personal workspace is yours until you promote the parts worth sharing into the team workspace, where an owner approves it before the team's instances recall it. Promotion always moves a memory between two workspaces you belong to, which is why the team shape needs both.

Inside a workspace you organise work into projects. A project is just a tag, so they're free and you can make one per repo, per client, per initiative. See Core concepts.

2. Connect your AI assistant

This is the step that turns Kythene on. Once an instance is connected it can publish, recall, remember and review without you leaving the session.

The fast way - one paste. Copy this into your assistant (Claude Code, Claude desktop, Cursor, Codex, Copilot, anything that speaks MCP) and it connects itself:

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.

No config file, no API key. The instance registers itself over OAuth and you approve it in a browser tab.

Cursor users get a one-click Add to Cursor button on the Kythene home page.

Wiring it up by hand. Your MCP endpoint is on the Connect your AI page in the app, and looks like:

https://kythene.com/mcp/kythene

The --scope user flag on the Claude Code command makes the connection available across every project and session - without it Claude Code scopes it to the current directory, and starting a new session (below) finds no Kythene tools.

The first time your instance calls a Kythene tool, it opens a browser to sign you in and authorise the connection. No API key is needed for MCP.

Your team doesn't have to agree on one assistant. Everyone connects whatever they already use, and they all read and write the same workspace.

Claude Code users: take the plugin. One install sets up the connection and teaches your instance the workflow - recall at the start of a session, remember what it learns, publish its output, pick up feedback. In Claude Code:

/plugin marketplace add kythene/plugin
/plugin install kythene@kythene

Self-hosting? Point it at your own instance instead, so the plugin talks to your box rather than the hosted service:

/plugin marketplace add https://your-instance.example.com/.claude-plugin/marketplace.json
/plugin install kythene@kythene

(The archive install needs Claude Code v2.1.224 or newer. On an older version, download kythene-plugin.zip from your instance and /plugin marketplace add ./kythene from the unzipped folder.)

There's more on what it teaches in the skill reference.

3. Publish something

Ask your instance, in whatever words you like:

"Publish that benchmark you just ran to the api project, call it Nightly benchmark."

It creates a collection - one publish, one or more artifacts - tagged api, and hands you back a link. Open it in the app and you'll see the file rendered, the revision number, and who and which instance produced it.

Try the same thing with a markdown document. Markdown renders inline in the app, so a published .md is readable immediately by someone who will never open a terminal.

4. Remember something, then recall it

This is the bit your future sessions lean on. Tell your instance something worth keeping:

"Remember for the infra project: the migration has to run before the worker boots, or it deadlocks on the advisory lock. Call it Deploy gotcha."

Then start a new session, on any machine, and ask:

"Recall what we know about deploys on infra."

The gotcha comes back - with its title, its project, who wrote it and which instance produced it - before your instance repeats the mistake. That's the whole product in two prompts.

Recall returns published work as well as memory by default, so "what do we know about X" pulls back the artifacts too, not just the notes.

5. Set up your workspace guide

Every workspace carries a short operating manual that connecting instances read automatically - house style, your tag taxonomy, what belongs in memory and what doesn't. New workspaces start from a sensible default. Ten minutes editing it in Settings -> Workspace guide pays for itself the first time somebody's instance writes a memory the way you'd have written it. See The workspace guide.

6. Optional: the CLI

For scripts, cron jobs and CI. The kythe CLI uses an API key rather than the browser login.

Download the archive for your platform from github.com/kythene/cli/releases, extract the binary and put it on your PATH:

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 on Connect your AI (or Settings) - it's shown once, at creation. Then:

export KYTHENE_URL=https://kythene.com
export KYTHENE_TOKEN=twk_...

Full command list in the CLI reference.

Where next

• The model, once: Core concepts.
• Pages your team and your customers read: Wikis.
• The way you actually work: pick a walkthrough.
• Running it yourself: Self-hosting.