Is this a code documentation generator or a docs host?

Both, but generation is the point. Moxie writes docs from your repo, keeps them searchable, and serves agents over MCP. You are not hand-uploading a wiki.

What does the first index actually produce?

An architecture overview, a conventions reference, walkthroughs of the flows that span files, an API and interface surface, setup steps, and a directory guide - each page written from current source with links to the files it describes.

How long does the first index take?

Minutes for most repositories. Large monorepos take longer because Moxie writes each page in its own pass rather than one sweep. You get a notification when the workspace is ready.

Which languages and frameworks are supported?

Any GitHub repo Moxie can index. The focus is architecture, conventions, and cross-file flows, so language coverage matters less than it would for a symbol-by-symbol generator.

Does Moxie edit or merge docs on its own?

No. Updates arrive as GitHub pull requests - most of them batched into the weekly Friday Cleanup PR on Pro and Team. Your team reviews and merges. Nothing auto-merges.

How is this different from Mintlify or GitBook?

Those host pages you author. Moxie maps the codebase, writes the structural docs for you, and opens PRs when code and docs diverge. You can still keep hand-written Markdown in the repo alongside it.

How is this different from Doxygen, Sphinx, or TypeDoc?

Those extract an entry per symbol from signatures and comments. Moxie writes the layer above that: how the pieces fit, which flow runs when, and what the conventions are - the context a symbol reference does not carry.

What happens to the Markdown docs already in my repo?

They are indexed alongside the generated pages and searchable from the same workspace, and they are checked for drift on merge just like the generated ones. Moxie does not overwrite them.

Does it work on a private repo or a monorepo?

Yes to both. On a monorepo, docs are matched to the source paths they cite wherever those live, and a nested AGENTS.md or package-level doc is checked against its own directory.

Code documentation generator

Codebase docs that write themselves from GitHub

Connect a repo. Moxie generates source-cited docs on the architecture, conventions, and flows already in your code, keeps them current on every merge, and serves the same context to AI agents over MCP.

Quick Answer: Moxie Docs generates codebase documentation automatically from a connected GitHub repository. On the first index it plans an outline and writes each page - architecture, conventions, cross-file flows, and API surface - from current source, with every claim linked to the file it came from. Each merge re-checks the affected pages for drift, gaps, and thin coverage, and the same index is served to AI coding agents over MCP.

From source. Architecture, conventions, and walkthroughs from the code that exists today, cited line by line.
Searchable. Generated pages and the Markdown already in your repo, indexed together in one workspace.
Agent-ready. Cursor, Claude Code, and Codex pull the same index over MCP.

Start trial on your repo See how it works

What you get

What lands in the workspace

Generated from source

Architecture, conventions, and flow walkthroughs written from your default branch, every claim linked to the file it came from.

Architecture map

How services, modules, and data flow fit together, with Mermaid diagrams for the paths that span files.

Convention capture

The patterns your repo already enforces - test runner, error contract, folder layout - pulled into an AGENTS-style reference.

One searchable workspace

Generated pages and your hand-written Markdown indexed together and searchable from a single place.

Current on merge

Every merge re-checks the affected pages for drift, thin coverage, and undocumented surface.

MCP for agents

Cursor, Claude Code, and Codex pull the same conventions, docs, and open gaps before the first edit.

How it works

From connect to searchable docs

01
Connect GitHub
Install the app on the repos you want documented. Read access to code and metadata; nothing is written without a pull request.
02
First index
Moxie plans an outline, then writes each page in its own pass against current source. Minutes for most repos.
03
Search and share
Browse the workspace, search across generated and hand-written docs, and send a teammate a link.
04
Stays current
Every merge re-checks the touched pages. Friday Cleanup batches fixes into one docs-only PR on Pro and Team.

What gets written

The docs a new hire actually asks for

Moxie writes structural documentation - how the system is put together and why - not a generated entry for every function. These are the pages people open in their first week and keep open after.

01
Architecture overview
How the codebase splits into services and modules, what each one owns, and where the boundaries sit.
02
Cross-file flows
The request path, the job pipeline, the auth handshake - traced through every file they touch, with a diagram.
03
Conventions reference
The rules the code enforces in practice: naming, test commands, error handling, and where new code is expected to go.
04
API and interface surface
Route handlers, exported helpers, and public types, each with its signature and where it is called from.
05
Setup and local dev
The install and run sequence, derived from the scripts and config that exist today rather than a year-old README.
06
Directory guide
What lives where, so search has somewhere to land and agents stop guessing at paths.

How generation works

Outline first, then one pass per page

Generation is not a single prompt over the whole repo. Moxie builds an outline sized to the codebase, then writes each page on its own so detail never gets spread thin - and grades its own output before you see it.

01
Index the repo
Moxie reads the default branch: source, config, existing Markdown, and commit history.
02
Plan an outline
It decides which pages the codebase warrants and how they nest, scaled to the size of each subsystem.
03
Write each page
Every page gets its own generation pass against the real files it describes.
04
Cite every claim
Each section links the source path it came from, so a reader - or a reviewer - can check it.
05
Grade its own coverage
A thin-docs check catches any page too light for the code it covers before it reaches the workspace.

After the first index

Generation is the start, not the deliverable

A one-time doc dump is stale within a sprint. What makes generated docs worth trusting is what keeps them true afterward.

Moxie re-indexes the surface a pull request touches when it merges, compares the new code against the pages that cite it, and records anything that no longer matches. Between Cleanup PRs every finding is already visible in the workspace and posted to the relevant GitHub pull request as an advisory check.

Re-checked on merge. The pages a change touches are re-evaluated for drift, gaps, and thin coverage while the change is still fresh.
Reviewed by humans. Fixes arrive as a docs-only Friday Cleanup PR on Pro and Team. Moxie opens pull requests; your team merges.
Served to agents. The same index answers MCP queries from Cursor, Claude Code, and Codex, so generated context and agent context never diverge.
Tunable. Dismiss a finding, mute it for 7 or 30 days, or turn a detector off for the whole repo.

Moxie

Same index, over MCP

	Hosted doc platforms	Symbol extractors	Moxie
Source of content	You write every page by hand	Signatures and doc comments	Architecture and flows, cited to source
Keeps up with code	Only when someone edits it	Symbol list regenerates; prose does not	Re-checked on every merge
Reading level	Whatever the author had time for	One entry per symbol	Structural - how the system fits together
Undocumented code	Invisible	Listed but unexplained	Flagged as a gap
Feeds AI agents	Copy and paste	No	Same index, over MCP

FAQ

Frequently asked questions

Get started

Generate docs from your repo

Connect a repository and the first index shows you the architecture, conventions, and flows already in your code - plus what is undocumented. 14-day trial, no charge today.

Connect GitHub See how it works

Codebase docs that write themselves from GitHub

What lands in the workspace

Generated from source

Architecture map

Convention capture

One searchable workspace

Current on merge

MCP for agents

From connect to searchable docs

Connect GitHub

First index

Search and share

Stays current

The docs a new hire actually asks for

Architecture overview

Cross-file flows

Conventions reference

API and interface surface

Setup and local dev

Directory guide

Outline first, then one pass per page

Index the repo

Plan an outline

Write each page

Cite every claim

Grade its own coverage

Generation is the start, not the deliverable

Where automated generation fits

Source of content

Keeps up with code

Reading level

Undocumented code

Feeds AI agents

Frequently asked questions

Is this a code documentation generator or a docs host?+

What does the first index actually produce?+

How long does the first index take?+

Which languages and frameworks are supported?+

Does Moxie edit or merge docs on its own?+

How is this different from Mintlify or GitBook?+

How is this different from Doxygen, Sphinx, or TypeDoc?+

What happens to the Markdown docs already in my repo?+

Does it work on a private repo or a monorepo?+

Generate docs from your repo