OpenWiki: the AI agent that writes your docs — and turns your Gmail into a second brain

Every team knows the cycle. The code changes daily; the wiki doesn't. Onboarding takes weeks because the only accurate documentation is the code itself, and nobody ever volunteers to update the wiki. What's new is who suffers: it's no longer just humans. AI coding agents — Claude Code, Copilot, Cursor — are only as good as the context they can find, and a stale wiki misleads them exactly as it misleads a new hire.

The obvious fix is also the honest one: if writing documentation is the chore nobody wants, give the chore to an agent — but wrap it in guardrails so it can't do anything except documentation.

OpenWiki is an MIT-licensed CLI from the LangChain team, built on their DeepAgents framework. Install is one line — npm install -g openwiki — and the terminal UI is, delightfully, React: it's built with Ink, so the interactive chat, streaming tool calls and setup wizard all render in your console.

The same agent serves two very different masters:

• Code mode (openwiki --update) — documents the current repository: quickstart, architecture, workflows, source maps. Recurrence comes from a scheduled GitHub Actions workflow it writes for you.
• Personal mode (openwiki personal) — ingests configured connectors (Gmail, Notion, Slack, X, web search, Hacker News) and synthesizes a local wiki of commitments, logistics, themes and open questions.

The architecture is small — a CLI, a credential store in ~/.openwiki/.env, a provider-agnostic model layer (OpenAI with an API key or your ChatGPT subscription, Anthropic, OpenRouter, Fireworks, Baseten, NVIDIA NIM, or any OpenAI-compatible gateway), and a SQLite checkpointer so conversations survive restarts. But two decisions elevate it from "neat demo" to "thing you can trust".

1. The agent physically cannot touch your code

OpenWiki extends DeepAgents' shell backend with explicit write guards: the agent may only write documentation files. It sees the repo through virtual paths, its output is capped, its commands are time-boxed. You don't have to trust the model's intentions — the backend enforces the contract.

2. A snapshot gate that keeps CI from looping

After every run, OpenWiki computes a SHA-256 snapshot of the whole wiki directory and writes its update metadata only if the content actually changed. A no-op update stays a true no-op — which is what stops a scheduled weekly run from committing metadata churn forever. It's a small idea that every "agent on a cron job" system should copy.

Theory is cheap, so I connected my actual Gmail. Authorization is a single command — openwiki auth gmail — which opens a Google consent screen with a read-only scope: the agent can read mail, never send or delete it. Tokens land in ~/.openwiki/.env, and only the variable names are ever printed, never the secrets.

Ingestion is a two-stage rocket, and the separation matters:

The pull fetched 100 messages from the last 24 hours into raw JSON. Then the agent — treating raw email as untrusted evidence, not instructions — classified every message by type, priority and durability, and wrote six cross-linked pages: commitments, personal logistics, themes, open questions, a source evidence table, and a quickstart. Receipts, promotions and newsletters didn't make the cut. That's the point.

And then the fun part — you can just ask it things:

Because the wiki is plain markdown, a tiny docsify server also turns it into a local website — sidebar, full-text search, and evidence-linked tables:

For the finale I pointed OpenWiki at the repository you're reading right now — omkamal.github.io, 420 files of articles and cheatsheets with zero documentation — and ran code mode:

$ cd ~/omkamal.github.io
$ openwiki --update --print

Created the initial generated wiki entrypoint at openwiki/quickstart.md

$ git status --short
 M CLAUDE.md        # OPENWIKI block appended
?? .github/         # scheduled openwiki-update.yml workflow
?? AGENTS.md        # agent guidance, created
?? openwiki/        # the generated wiki

One command produced the wiki and the recurrence machinery: an AGENTS.md, a CLAUDE.md block that tells coding agents to read the wiki first, and a scheduled GitHub Actions workflow that will keep refreshing it. A follow-up prompt expanded the wiki to four cross-linked pages — quickstart, site architecture, publishing workflow, and a source map:

The complete 13-minute video covers everything in motion — the animated pipeline, the install from a fresh clone, the live Gmail demos, and the repo run — with every diagram synced to the narration:

Four takeaways survived contact with reality:

• Agent-written documentation is practical today — not a research demo. The output above is real, and it was cheap.
• Guardrails are the product. A docs-only write policy enforced by the backend is what makes it safe to run an agent on a schedule, unattended.
• Recurrence beats heroics. The scheduled workflow plus the snapshot gate means the wiki stays fresh without anyone remembering to run anything.
• Your knowledge stays local. Both brains are plain markdown on your machine — chat with them, browse them, grep them, back them up.

• OpenWiki on GitHub — github.com/langchain-ai/openwiki (MIT)
• OpenWiki on npm — npmjs.com/package/openwiki · install with npm install -g openwiki
• DeepAgents, the agent framework underneath — npmjs.com/package/deepagents
• LangChain — langchain.com
• Ink (React for the terminal) — github.com/vadimdemedes/ink
• docsify, the zero-build markdown site viewer used in the demos — docsify.js.org
• The full video walkthrough — youtu.be/YPrFph-ce5Q

Illustrations generated with Google's Nano Banana image model; diagrams use Font Awesome Free icons (CC BY 4.0, Fonticons, Inc.). Personal details in demo screenshots are blurred.