Code, work, and knowledge as living maps — read them in the browser, and let your agents write to them over MCP as they work.
Reverse-engineered from your source — every screen, how they navigate, the data each one calls. Always current. Share it as a link; your team reads it in the browser.
Your coding agents read and write every map over MCP. When they hit a call only you can make, it becomes a question on the issue — and Alkahest brings it to you.
Markdown documents in an Obsidian-style notebook — a folder tree, [[wikilinks]], the graph draws itself. Agents distill decisions into notes — session knowledge stops evaporating.
Two tiers — Free and Pro. Gating rides on the same capability ladder as [[Auth strategy]], so Pro-only maps stay private by default.
Open question tracked on the issue; see the thread for the token-rotation call.
/settings/billingThe loop, in three moves
Agents are great at doing and bad at guessing. Alkahest is the shared surface where the work is recorded and the decisions come to you.
Mid-task forks post as a question on the issue. It blocks until you answer — nothing ships on a guess.
A per-project webhook drops open decisions into Slack or Discord, and alkahest publish prints what's waiting right in the terminal.
Your home is a journal of what agents did while you were away — publishes, issues, notes — every row signed agent, you, or widget.
How it works
Run alkahest scan at the root of your app. Alkahest parses the source and builds a screen-level map locally — preview it any time with alkahest view.
Create a publish token on your account page, then alkahest login --token <token>. The token links the CLI to your account.
alkahest publish uploads the map and returns a shareable URL. Send it to your team — they open the interactive graph in the browser.
# 1 · install the CLI (from GitHub — not yet on npm) npm install -g @cr8rcho/alkahest # 2 · map your project (preview locally) alkahest scan alkahest view # 3 · connect your account alkahest login --token <your-token> # 4 · publish a shareable link alkahest publish # → https://alkahest.app/p/your-project
Quickstart
Paste one prompt and your agent installs Alkahest, connects it over MCP, scans the project, and builds the map for you — no manual setup, no API key. Pick your tool:
Set up Alkahest in this project for me, end to end:
1. Install the CLI: npm install -g @cr8rcho/alkahest
2. Connect it to you over MCP: claude mcp add alkahest -s project -- alkahest mcp
3. Build the product map: alkahest scan
4. Give me an overview of the screens, then write a one-line summary and a short PRD for the most important ones (use the alkahest set_summary / set_prd tools if they're available).
5. Open the dashboard: alkahest viewHeads up: after the MCP server is added, restart Claude Code once so the alkahest tools load — then it can write the summaries and PRDs into the map.
Set up Alkahest in this repo for me, end to end:
1. Install the CLI: npm install -g @cr8rcho/alkahest
2. Register it as an MCP server by adding this to ~/.codex/config.toml:
[mcp_servers.alkahest]
command = "alkahest"
args = ["mcp"]
3. Build the product map: alkahest scan
4. Give me an overview of the screens, then write a one-line summary and a short PRD for the most important ones (use the alkahest set_summary / set_prd tools if they're available).
5. Open the dashboard: alkahest viewHeads up: after editing config.toml, restart Codex once so the alkahest MCP tools load — then it can write the summaries and PRDs into the map.
Want to share the map? Create a free account for a publish token, then ask your agent to run alkahest login --token <token> and alkahest publish— you'll get a link anyone can open. Prefer the manual route? See How it works.
FAQ
A screen-level product map: a graph where each screen of your app is a node, navigation between screens are edges, and the API/data calls a screen makes are attached to it. It's the bird's-eye view of how your product is wired, derived from the code itself.
Three. A code map reverse-engineered from your source; an issue map — a dependency-first issue tracker where blocks/contains edges surface what's ready to start; and a note map — markdown documents arranged on a canvas, each note linkable to the issues and code nodes it concerns. You can plan in an issue or note map before any code is scanned, then attach the code map later. A project isn't limited to one of each, either — keep several of any type side by side (say web and api code maps in a monorepo), each at its own link.
Yes — that's the decision channel. When an agent hits a fork mid-task it posts a question on the issue over MCP; the issue stops being actionable until you answer and the question is resolved. You answer on the web (or from another agent session), the agent picks the answer up and continues. Decisions stay attached to the work they decided.
Three ways. Set a per-project webhook and open decisions land in Slack or Discord with a deep link (setup guide). alkahest publish prints a “waiting on you” line right in the terminal. And your home page pins a Needs-you list above a journal of everything your agents did while you were away.
Today: React (Next.js — app & pages router —, Vite/CRA via React Router, and Remix/React Router 7), Vue (Nuxt and Vue Router), Angular, Svelte (SvelteKit), Astro, React Native (Expo Router and React Navigation), SwiftUI and UIKit (iOS), Jetpack Compose (Android), Flutter, server-rendered Django, Flask, and Rails, and plain multi-page HTML. The data model is platform-agnostic, so more stacks land as pluggable adapters. Alkahest reads your source statically — it does not run your app, so there's nothing to instrument.
Yes — drop a one-line snippet into your app and anyone can file a report from the live page. It lands as an issue in your project with the reporting URL attached, ready to triage (ADR-025).
No. Only the derived map (screens, navigation, and data-call metadata) is published — not your source files.
Yes — it's open-core. The CLI and the graph renderer are MIT-licensed and on GitHub. The hosted service (accounts, sharing, team plans) is the paid layer on top.
Create a free account, generate a publish token, and ship your first link.