Make it known.
The shared context layer for AI-native teams. Publish what you and your AI make, see what everyone is building, and grow a memory the whole team recalls.
One paste and an OAuth prompt - connected in a few minutes, no keys to copy.
kythene · in chemistry, -ene means a double bond
You
Publish what you and your AI just worked out.
A teammate's AI, later
Recalls it and builds straight on top.
No re-explaining, no lost context - it picks up where you left off.
Connect your AI
Set up in one paste.
Copy one prompt, paste it into Claude Code, Cursor, Codex, Copilot - whatever you use - and your assistant connects itself to Kythene over MCP. No config files, no keys to wire up - you're connected in a few minutes. On Cursor, one click does it.
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.
This connects to the hosted Kythene at kythene.com. Self-hosting? Install your instance first - it serves this same prompt at your own domain.
Prefer to click around first? Open the app and connect from there, or read the getting-started guide.
The problem
Your best work is trapped in a chat.
In an AI-native team the real work happens between a person and their AI instance - and it stays there. You paste outputs into Slack, screenshot results, and re-explain context a teammate's AI already worked out. Nothing accretes. Everyone re-derives.
The shift
Context your AI actually uses, in the flow of work, with sign-off you can trust.
Kythene is a shared context layer. People and their instances publish outputs, see what everyone is producing, read each other's work over MCP, and write to a memory that grows instead of evaporating. The context is the product.
What you get
Ship the work, not a screenshot
Publish artifacts, binaries, JSON and datasets to a durable, versioned home - permissioned and read by your whole team and their agents, not pasted into a thread.
Feedback that comes back to your AI
Comments, approvals and change requests reach your instance over MCP, so it acts on the notes instead of you relaying them by hand.
Your AI reads your team's work
Connect over MCP and your instance recalls a teammate's outputs and builds on them - Claude, Cursor, Codex, Copilot, or whatever each of you uses.
Context that accretes, not evaporates
Per-project and team-wide memory your instances write and recall in one call - so nobody re-derives what was already worked out. See how memory works →
A memory in Kythene isn't a line in a file. It's a first-class thing - written as markdown and rendered as markdown, scoped to a project, typed, tagged, linked to related memories, and stamped with who wrote it and which instance. Your team reads it, your instances recall it, and it's citable when an output leans on it.
The hard part
Will my AI actually use it?
Storing knowledge was never the hard part - getting an instance to apply it is. That is the problem Kythene is built around, not an afterthought bolted onto a database.
Recalled in the flow of work
One recall call at the start of a
session brings back the project's memory and the outputs behind it.
The skill we ship tells your assistant to do it before anything else,
so it starts caught up instead of guessing.
Only what the team agreed
A memory promoted to the team is held for review. Instances don't recall or apply it until an owner approves it - so what your AI acts on is what your team actually signed off, not whatever someone's session happened to conclude.
Traceable when it's used
Every memory records the human who wrote it and the instance that produced it, and carries a citable link - so an output can point at the knowledge it leaned on and you can check the reasoning rather than trust it.
Stale knowledge stops surfacing
Deprecate a memory when it's superseded and recall stops returning it, so instances stop applying it. Re-use a title and the old version is superseded rather than duplicated - no contradictory copies for an agent to pick between.
How it works
You kythe an output
Publish a result from your session - versioned, tagged and permissioned.
Your team sees it - and feeds back
It lands on the shared timeline; teammates review, comment and sign off - pinned to the version.
The feedback comes back to your AI
Comments, approvals and change requests reach your instance over MCP, so it picks up the notes and acts on them - instead of you relaying them by hand.
The context stays - and compounds
It accretes into project and team memory; any teammate's instance recalls it over MCP and builds straight on top.
Who it's for
From an AI pathfinder to a regulated team.
AI Pathfinder
You're ahead on AI; your edge compounds across every tool, and the team can build on it.
Dev and stakeholder
Show a cofounder what's shipping, async, without a demo call.
AI-native team
One shared context, so nobody re-derives a teammate's work.
Working with a client
Share specific outputs with an outside party - no account, no full access, and they review free. Guests and AI instances never cost a seat.
Regulated and enterprise
Self-host, permissioned, audit-logged. Velocity inside the boundary.
Why Kythene
Works with your tools
Kythene speaks MCP, so your instances read and write it directly - Claude, Cursor, Codex, Copilot and any other MCP-capable assistant. No new workflow to learn, and your team need not all use the same tool.
Versioned and permissioned
Every output is a durable, versioned artifact behind tag-level access - not a blob that scrolls out of a chat.
Self-host when you need to
Run Kythene on your own infrastructure with an offline licence. Read about self-hosting →
Make it known.
Give your team and their instances one place to publish, read and remember. One paste to connect - a few minutes, no keys.