openwiki: the repository wiki that writes and maintains itself
openwiki is a command-line tool from langchain-ai with an interactive terminal surface. It reads your repository and builds a Markdown wiki, then updates on its own whatever changed, keeping every claim tied to the file that supports it. In our test the 0.7.2 package downloaded and ran, the workspace command refused outside a git repository with exit code 1, answered inside one with code 0, and the dependency tree reached 215.15 MB across 40,962 files. It is MIT, it needs Node 22.22.0 or newer, it is not an MCP server, and generating the wiki spends tokens on your own model — a figure we did not measure.

What it does
Every repository hides knowledge nobody sits down to write: why it is built the way it is, what each folder does, which file depends on which. openwiki writes that knowledge itself, as pages, and then keeps it alive as the code changes.
The keyword is “wiki”. This is not comments inside your code and not auto-generated function documentation. It is Markdown pages, like the pages of a wiki, inside the repository’s openwiki/ folder. The important part is not the pages; it is what they hold: every statement points back to the source file behind it, so a later update knows what moved and reworks only the pieces that did.
And since we wrote about graphify yesterday, one clarification. graphify writes nothing: it reads the syntax tree of your code, builds a graph of nodes and edges with no model at all, and then you query it. openwiki builds no graph: it puts a model agent to work writing prose — pages you read as text — and maintains that prose over time.
openwiki is built by langchain-ai and written in TypeScript (repository). Its surface is the terminal: an interactive application, not a server; you do not declare it in a config file, you hand a command to the shell.
One finding from the test, because you will hit it too: openwiki --help does not print help, it starts the interactive application itself. Outside a real terminal that stops with the raw-mode error from the ink library, so you cannot run it from a pipe or a script and expect text back.
What the registries say. On npm the latest version is 0.7.2, with a publish date from the time["0.7.2"] field of 9 October 2026, 22:27 UTC, and 30 releases in total since June — a steady cadence, not a single burst (package). The license field is MIT. The engines.node field declares >=22.22.0: on an older Node the tool does not start. The package on disk is 2,273,842 bytes, that is 2.17 MB, across 358 files. Downloads are 66,251 over the week of 23 to 29 October and 191,287 over the month from 30 September to 29 October (npm statistics). On GitHub the repository holds 17,672 stars, 1,306 forks, around 190 open issues and the TypeScript language; it was created on 22 June 2026, its last push is today, 2 November 2026, and it is not archived (repository).
And the caveat up front. The version is 0.7.2, short of 1.0, and the project is a few months old. Thirty releases in four months mean a live tool, but also movement: what you learn today can change.
Who it is for
For anyone whose repository is known well by one person and by nobody else, and for anyone who wants documentation that does not rot.
The beginner enters from their assistant: no account, no provider key, no model to choose. They register openwiki with the assistant in one command and then simply ask “build this repository’s wiki from the current source and tests”.
The professional gains two things. First, the start on unfamiliar code: instead of reading folders for hours, they open a wiki that says what does what, with a pointer to the file. Second, maintenance: when the code changes, --update reworks what was affected. There is also the idea of a workspace, which groups the wikis of related repositories.
Who it is not for. If you want documentation with no model involved, no: here the text is written by an agent, so it needs a model and tokens. If your repository is not git, it stops you with a clean message. On an older Node it will not run.
Install
Three commands, from any folder. The check first:
node -vIf the version is 22.22.0 or newer, you go on. The global install from npm:
npm install -g openwikiAnd the first generation, inside the repository folder, because that is where it looks for git:
openwiki --initWatch the shape, because everyone confuses it: --init and --update are flags, not subcommands. There is no openwiki generate and no openwiki update. We confirmed this inside the package itself.
Through your coding agent
You give the agent’s name and openwiki writes whatever is needed, so it works from any repository:
openwiki integrations install codexThe same shape for claude, cursor, opencode, copilot, antigravity, kiro, bob and omp. The list and the removal:
openwiki integrations listopenwiki integrations uninstall codexThat integration writes files inside the agent’s own space — skills and, for some hosts, an MCP registration. We did not measure the shape of that surface, so we leave it as a vendor claim.
Without installing anything
To see what it does before it writes anything permanent, npm downloads it temporarily. This is the route we took in the test:
npx -y openwiki@0.7.2Updating the knowledge
When the repository changes, you do not rebuild from scratch:
openwiki --updateUsing it with each LLM
One warning is needed here, because the mind jumps to MCP. openwiki is not an MCP server and it is not declared in a config file. It loads no tool schemas into any session, it takes no room in context before you write a word. You use it from the shell: the assistant hands a command over and reads an answer back.
The command for one question and one answer with no interactive surface, the one that fits a script or an agent:
openwiki -p "which pages cover authentication?"The -p is short for the --print flag; without it the tool opens the interactive application. That distinction is the key to using it with an assistant.
Claude Code
In the project’s rules file you write the convention: the documentation is maintained with openwiki, and after any substantial code change an update runs. The command the assistant hands to the shell, inside the repository root:
openwiki --updateFor the assistant wiring, once:
openwiki integrations install claudeCodex CLI
The same shape in an AGENTS.md file: when architecture or public behaviour changes, a wiki update follows and the change lands together with the code. The shell question is worth having here, because an agent cannot drive an interactive surface:
openwiki -p "which file defines the user input flow?"The first generation, if the wiki does not exist yet:
openwiki --initCursor
One instruction in the project rules is enough: the repository’s knowledge stays in the wiki and after a structural change an update runs. For the editor link:
openwiki integrations install cursorThe shell check stays the same:
openwiki -p "where is the user model defined?"In an automation pipeline
Because the update needs no interactive terminal, it fits a scheduled job: you ask for an update after every merge and the knowledge stays in step without a human. The exit codes help: the workspace command returns 1 outside a git repository and 0 inside one, so the pipeline judges by the code, not by impressions.
My recommendation, not the vendor’s instruction: pin the package version in a scheduled job. Thirty releases in four months mean “latest” keeps moving.
Where it wins, where it loses
It wins on binding a claim to its evidence. It does not throw you a text that may have come from thin air; it keeps every statement tied to the file behind it, which is why it reworks only what changed. --update shows the design is serious: an update is a targeted re-examination, not a repetition.
It wins on knowledge that does not get lost. When starting on unfamiliar code goes through pages, the time drops for everyone, not just for the one person who already knows.
It wins on talking to agents: zero schema tokens, zero config-file entry, no restart, an exit code to read. And on the basics: MIT, no money for the tool, 17,672 stars within four months.
Where it loses. First, weight: the package is 2.17 MB, but in our test the tree reached 215.15 MB across 40,962 files and 263 packages, with 27 direct dependencies carrying the plumbing of nearly every model provider. Second, the Node strictness: below 22.22.0 it does not start. Third, a cost you do not know in advance: the wiki is written by a model, so you pay tokens per page, a figure we did not measure. Fourth, the git requirement. Fifth, the interactive nature: --help gives no help, it opens an application, and outside a terminal it breaks with the raw-mode error from ink. Sixth, telemetry: the package carries posthog-node, though there is a way to see what it sends. Seventh, maturity: 0.7.2, a few months old, around 190 open issues.
The test
I ran the tool and measured. The numbers in this section came out of the runs, not out of documentation.
The package downloaded and ran with the command below:
npx -y openwiki@0.7.2It worked. The weight on disk was measured separately: the full node_modules reached 215.15 MB across 40,962 files and 263 packages, while the openwiki package itself is 10.75 MB. The five largest clusters: @langchain 37.00 MB, @azure 24.78 MB, openai 22.44 MB, js-tiktoken 21.39 MB, @anthropic-ai 16.29 MB. That is, 204 of the 215 MB are the dependencies, not the tool.
The workspace command, bare:
openwiki workspaceIt printed its usage line and exited with code 1.
Outside a git repository:
openwiki workspace currentThe OpenWiki root must be inside a Git repository., exit code 1. Inside a repository, the same command said This repository uses its own wiki. and exited with code 0.
Unknown flags are rejected with a message. --dry-run answered with “Unknown option”, because it exists only inside ingest; --version likewise with “Unknown option”.
What I did not measure. I did not run the wiki generation, because it needs a model session or a provider key, and that is why I did not measure how many tokens a page costs. I did not measure generation time, I did not try the visual exploration, and I did not examine the schema of the MCP surface. Any number not stated here is not ours.
What it costs
The tool. Zero money: openwiki is MIT and has no locked feature. What you pay is disk space and model calls.
The context. It is not an MCP server, so it loads no tool schemas into every session: its token tax before you write a word is zero. Its weight is its dependency tree. With npx -y openwiki@0.7.2, the on-disk node_modules reached 215.15 MB across 40,962 files and 263 packages (our own measurement, 2 November 2026). The openwiki package itself is 10.75 MB; the other 204 MB are its 27 direct dependencies — @langchain 37.00 MB, @azure 24.78 MB, openai 22.44 MB, js-tiktoken 21.39 MB, @anthropic-ai 16.29 MB. In other words, it carries the plumbing of nearly every model provider.
The work. To write the wiki, openwiki is not a model of its own: it uses the session of the coding agent you already have, or its own provider keys. So generation costs tokens on your own model, per page — and we did not measure that number. That is precisely why it does not score perfect: you learn the cost after you run it.
A note on telemetry. The package contains posthog-node, and the CLI has a --telemetry-file flag that writes the exact anonymous payload to a local JSON file — so you can see what it sends before it sends it.
Verdict
Score: 8.5/10.
The tool solves a problem everyone knows and nobody tackles: knowledge that sits only in one person’s head. It does not solve it with a graph or with search; it writes pages and keeps every statement tied to the file behind it. It is MIT, its release cadence is alive, and using it takes no room in the assistant’s context.
The price is known up front: 215.15 MB of dependencies, a strict Node 22.22.0 requirement, the need for a git repository, an interactive surface that gives no help on --help, and a token cost you do not know before you run it.
In practice: try it on a repository you know well, the place where you will see immediately whether the pages tell the truth. Run it through npx first, before you commit to anything. If you like it, wire it into your assistant with one command and keep the update in a scheduled job with a pinned version. And keep an eye on that token figure; it will decide whether you put this on every repository or only on the large ones.
Sources:
https://github.com/langchain-ai/openwiki
https://www.npmjs.com/package/openwiki
https://github.com/langchain-ai/openwiki/releases/tag/v0.7.2