Episode 01 / Desktop film

What's Grok-Wiki?

Q: Why use Grok-Wiki instead of just Codex, Claude Code, Grok, or ChatGPT?

Grok-Wiki prepares repository context, runs the local CLI agent you already use, then turns the investigation into source-grounded wikis, docs, Ask sessions, and public handoff pages. The agent does the work; Grok-Wiki gives it durable structure, citations, and a workspace other agents can read later.

Q: What happens when I publish a wiki?

Publishing creates a separate read-only page that can be shared with teammates, users, or other agents. It does not turn the original workspace into a public editing surface; regeneration, Ask, and app controls stay in the local or authenticated workspace.

A short product film for the desktop loop: source-grounded repository context, local CLI agents, and model access that stays with you.

Watch all episodes

Local CLI-first desktop

Wikis, answers, docs, and tasks, powered by your local agents.

Point Grok-Wiki at a repo or folder. It prepares the context, streams source-grounded progress, and hands every model call to the CLI you already sign into.

Projects to start. Wiki to understand. Ask to interrogate. Docs to reference. Tasks to run.

Cmd 1 through 5. Terminal included.

Download for Mac Open public library

Desktop contract Local-first

Your library lives on your machine

Wikis, answers, docs, and task runs save to a local library. Publishing to the public library is a deliberate click, never a default.

on disk

Model access stays with the CLI

Grok CLI, Codex CLI, Claude Code, Pi, and Antigravity authenticate through their own tools. Grok-Wiki never holds a key.

cli-owned

Telemetry has a payload boundary

Optional usage signals exclude prompts, answers, code, paths, keys, and run logs.

no payloads

Tasks

Capture work, then run it with a local agent in Terminal.

Backlog2

Epic1/3

Tighten the auth flow

stablyai/orcaFrom Ask

Write a migration guide for the v2 config

twentyhq/twenty

Ready1

Add error states to the docs reader

timescale/tigerfs

In progress1

Document the worktree lifecycle

stablyai/orca

Running

Done1

Map the GraphQL schema

twentyhq/twenty

3 files, +120 -14

Projects

Every repo and folder you have pointed Grok-Wiki at, in one place.

3 total

stablyai/orca

Orca Developer Reference2d

How do worktrees get cleaned up?3h

twentyhq/twenty

Twenty CRM Developer Reference5d

Where does the schema engine live?1d

design-system Local

Design system docs4h

Generate a repository wiki.

Add one or more GitHub repos, URLs, or local paths. Generated pages and source evidence appear in the library below.

Search wikis

3 saved wikis

6 pagesOrca

Orca Developer Reference Wiki

Electron IDE, worktree orchestration, local agents, runtime RPC, and provider-neutral automation.

Technicalstablyai/orca

5 pagesWarp

Warp Agentic Development Environment

Terminal-born agentic development environment with GPU UI, coding agents, and model access.

Technicalwarpdotdev/warp

6 pagesTwenty

Twenty CRM Developer Reference

Open-source CRM architecture, GraphQL backend, React frontend, and metadata schema engine.

Technicaltwentyhq/twenty

Ask across repositories.

Add one or more GitHub repos, URLs, or local paths. Sources and activity appear after a run exists.

Question 1 of 3

Where should the answer go deep?

Tip · Type / to choose a Compound Engineering lens or attach wiki context.

Generate repository documentation.

Turn a GitHub repo, URL, or local folder into a docs-site structure with quickstarts, guides, references, examples, and source evidence.

Search docs

2 saved docs

25 pagesTigerFS

TigerFS Documentation

Reference for mounting PostgreSQL as a versioned filesystem, including CLI and file-first workflows.

Docstimescale/tigerfs

22 pagesOrca

Orca Documentation

Electron IDE and CLI docs covering worktrees, multi-agent terminals, RPC, remotes, and git providers.

Docsstablyai/orca

Terminal

Projects, worktrees, and local agent shells in one rail.

Projects

stablyai/orca 1

main

Document the worktree lifecycle - Working Grok CLI

docs-handoff

Shell - Ready zsh

Document the worktree lifecycle - Working

Working · Document the worktree lifecycle stablyai/orca

✓ Prepared workspace from stablyai/orca (main)
✓ Read 14 files under src/worktrees
● Writing docs/worktree-lifecycle.md
● Adding a lifecycle diagram

Project rail keeps every shell and agent session under the repo that owns it.

Choose the CLI that owns model access.

The desktop is Local CLI-first. Each agent signs in through its own tool and owns model access.

A working miniature of the desktop app. Click through the sidebar.

Repository memory

The context stays close to the work.

Grok-Wiki turns old runs, source trails, and generated docs into a local workspace your agents can actually read.

Source trails Local runs Docs archive

Workflows

Generate, ask, and index repos.

Start a wiki, ask a question, or add a GitHub repo. Grok-Wiki keeps the run, sources, and selected local CLI in view.

running AsyncFuncAI/grok-wiki

local first

Read repositoryResolve files and source scope

done

Draft outlineBuild page tree from evidence

live

Write pagesPatch active run monitor only

live

Attach sourcesLink exact files and lines

Generate a wiki without moving the desktop.

The run monitor advances in place while sidebar, reader, composer, and selected local agent stay stable.

AsyncFuncAI/grok-wiki

What is the main entry point?

Working for 6s

Scanning repository structure Found desktop, public, and API entry surfaces.

Reading package scripts Matched the local web and desktop commands.

Checking source evidence Preparing file-backed answer references.

is thinking through the repo... Active step streams without remounting the composer.

Ask the repo and keep sources visible.

Answers stream beside the evidence map, so claims stay tied to files instead of a detached chat transcript.

Press the shortcut on a repo and start indexing.

Cmd + Shift + Space turns the active GitHub repository or local folder into source context without changing provider ownership.

Code Graph

Production-grade repository context.

As your codebase grows, every Ask, Wiki, and Docs run should stay simple. Code Graph is the missing layer that keeps rediscovery out of the critical path.

Agents are excellent at reasoning over code. The hard part is making them stop re-learning where everything lives. Code Graph gives each new run a reusable map of structure and source evidence, so the model you already chose spends effort on synthesis, not scavenger hunts.

Capabilities

Without Code Graph Wiki run

discovering no map

slow path

List the treeWalk directories for project shape

live

Guess entry pointsREADME, manifests, main files

Rebuild relationshipsTrace imports file by file

queued

Plan the outlineStructure after expensive discovery

queued

Model budget spent finding the architecture.

With Code Graph Wiki run

Code graph ready. map attached

fast path

Attach the mapModules and hotspots arrive with the run

live

Plan from structureOne pass over real entry points

Write the pagesEach page starts closer to the system

queued

Model budget spent explaining the architecture.

Without Code Graph Ask run

chasing imports file by file

slow path

Open the first fileRead a handler, chase every import

live

Cross packages by handRebuild the call path layer by layer

Miss non-obvious edgesNeighbors stay hidden until another search

queued

Answer with partial wiringOnly as good as the trail just rebuilt

queued

Relationships are reconstructed under pressure, every time.

With Code Graph Ask run

Code graph ready. edges known

fast path

Query the graphDependencies arrive as structured context

live

Follow the real pathCross-package edges before long reads

Explain the systemAnswers account for actual wiring

queued

Relationships are available when the question needs them.

Without Code Graph Docs run

grepping whole files

slow path

Search broadlyGrep names, open candidate files in full

live

Read past useful linesToken budget for a single claim

Cite after the factSource trails assembled late

queued

Hope the claim holdsHarder to verify without first-class proof

queued

$ rg "resolveConflict" -n src/sync/engine.ts:88: ... src/sync/merge.ts:214: ... src/client/store.ts:41: ... apps/desktop/src/...: open full file

Evidence is a byproduct of the hunt.

With Code Graph Docs run

Code graph ready. excerpts ready

fast path

Pull focused excerptsRelevant source next to reasoning

live

Ground the claimPages stay closer to real files

Keep proof inspectableFrom conclusion back to source

queued

src/sync/engine.ts:88-112 Conflict resolution entry for concurrent edits

src/sync/merge.ts:214-241 Three-way merge path used by the client store

src/client/store.ts:41-67 Offline replay hooks after a merge settles

Evidence is part of the run, not an afterthought.

Without Code Graph Three surfaces

re-exploring ×3 tax

slow path

Ask exploresFinds entry points, then answers

live

Wiki explores againSame discovery, separate run

Docs explores againSame discovery, third time

queued

—

No shared memoryEvery surface pays rediscovery tax

queued

The same structure gets rebuilt for every workflow.

With Code Graph Three surfaces

indexed once map reused

fast path

Index onceFirst use of a repository builds the map

live

Ask starts informedQuestion lands on architecture

Wiki starts informedStructure reuses the same intelligence

queued

Docs starts informedGuides lean on shared evidence

queued

One map compounds across Ask, Wiki, and Docs.

What changes in the numbers.

A side-by-side of the costs people actually feel: discovery turns, where model budget goes, how many surfaces share context, and the first-run tax of indexing.

Illustrative · mid-size monorepo

Metric Without Code Graph With Code Graph

Discovery turns per run Agent steps spent locating files and rebuilding shape

8-14 Cold walk every Ask, Wiki, or Docs run

1-3 Map attached, then plan and write

Model budget on navigation Share of the run spent hunting vs synthesizing

~65% Most spend is search, open, re-trace

~15% Most spend is explanation and docs

Surfaces sharing context Ask, Wiki, and Docs after the first index

0 / 3 Each surface rediscovers alone

3 / 3 One map reused across workflows

First-run setup cost Extra work before the first useful answer

0 No index. Start exploring immediately

1× Short index once per repository

Later-run rediscovery tax Repeated cost after the repo is already known

Every run Structure rebuilt from scratch

Near zero Reuse the map; re-index only when needed

Without Code Graph · tradeoffs

Zero setup. Tiny repos and one-shot questions stay light.
Every serious run pays discovery again, including the third surface that needs the same map.
Evidence arrives late, so claims are harder to verify while the agent is still hunting.

With Code Graph · tradeoffs

First use of a repo spends a short indexing pass before the map is ready.
Later Ask, Wiki, and Docs runs spend far less on navigation and more on useful output.
Optional by design. Turn it off and Grok-Wiki returns to local exploration without deleting your work.

Turn it on when understanding the repository is the job.

Code Graph is optional repository intelligence, not another model. Keep it off for tiny or one-off questions. Enable it when rediscovery is the expensive part of Ask, Wiki, and Docs.

Settings › Code Graph › Enable

Public library

Share docs, wikis, and Obsidian ZIPs.

Browse generated docs and public wikis, or download a vault-ready Markdown ZIP for Obsidian.

Docs readerGenerated pages can be browsed, shared, or exported as a Markdown vault.

Docs gallery Obsidian ZIP

/public/docs/:id

Local CLI setup

Install a local agent, authenticate through its CLI, and recheck readiness before generation.

CardsLink generated pages.

Code groupsShow cited examples.

StepsPreserve setup flow.

UpdatesTrack runbook changes.

Route mapPublished HTML, agent Markdown, and vault exports stay separate.

Public library

Public library/public/wikis

Docs gallery/public/docs

Wiki reader/public/wiki/:id

Docs reader/public/docs/:id

Obsidian ZIP/api/wiki/export.zip?id=:wiki

Agent Markdown/:surface/:id/llms.txt

Episodes/episodes

Changelog/changelog

Public wiki handoff

One click turns a public wiki into agent context.

Use Add Agent on a public Grok-Wiki page to point your selected local agent at the wiki's source-backed context. Export the same pages as an Obsidian ZIP when you want the knowledge in your local vault.

Add Agent Agent Markdown Obsidian ZIP

Published pages stay useful for humans, local agents, and vault exports without moving model access away from the CLI accounts you own.

Customer proof

Here's what Grok-Wiki users say.

Builders are using Grok-Wiki to understand repositories, share source-backed docs, and turn local agent runs into something others can actually read.

View on X

Kevin Rose @kevinrose / Digg

"Sheing is brilliant, one to watch/follow for sure. Trying out Grok-Wiki now."

A founder signal from Kevin Rose, with Digg.com highlighted as a real-world Grok-Wiki use case.

Neil Parker @nwparker_ / Orca

"Now we've got to re-write the whole thing to keep you on your toes!"

A practical builder reaction from Orca after seeing Grok-Wiki in the wild.

View post

Gabe Perez LinkedIn

"the structure mapping actually caught dependencies I forgot existed."

Tried Grok-Wiki on a 50k LOC repo and pressed on how agents handle competing importance signals.

View comment

Matt Van Horn @mvanhorn

"love your work"

A concise X endorsement from a product-minded builder.

View post

jiahao @__endif

"awesome, keep shipping"

A short public signal from the Grok-Wiki launch thread.

View post

nasuy @n_asuy

"crazy Sheing and Grok-Wiki are on fire"

Deduped into one card with both public posts attached, including the Warp repository note.

Post 1 Post 2

DJ Discord

Discord

"This might be my new favorite tool."

Used Grok-Wiki a second time on a favorite tool that had been semi-broken and deprecated.

Agents on Grok-Wiki

FAQ

Frequently Asked Questions

Everything you need to know about working with Grok-Wiki. Still have a question? Get in touch.

Why use Grok-Wiki instead of just Codex, Claude Code, Grok, or ChatGPT?

Grok-Wiki is not trying to replace your agent. It prepares repository context, runs the local CLI agent you already use, then turns the investigation into source-grounded wikis, docs, Ask sessions, and public handoff pages. The agent does the work; Grok-Wiki gives it durable structure, citations, and a workspace other agents can read later.

Where is my data stored?

The desktop app runs a local loopback server and stores data under the app data directory. Your local agent credentials stay with their own CLI tools. Public wiki pages are separate read-only copies that exist only when you publish them.

How does Grok-Wiki keep the wiki grounded in the source?

Each run starts from the repository itself, builds a structure from the files it reads, and keeps source trails attached to generated pages and Ask answers. The result is easier to inspect than a chat transcript because the useful claims are packaged back into navigable docs.

Can Grok-Wiki do more than generate a wiki?

Yes. It can generate repository wikis and docs, answer questions against source evidence, keep run history, publish read-only pages, expose agent-readable Markdown, and export Obsidian-ready ZIPs. The point is to turn one investigation into reusable repository memory instead of another throwaway chat.

Can Grok-Wiki work with private repos, local folders, or my own cloud?

The desktop and CLI flows are designed for local-first work where your authenticated tools and filesystem own access. For hosted deployments, the architecture keeps storage and provider credentials configurable so teams can run with their own auth, database, and infrastructure choices as the product expands.

What happens when I publish a wiki?

Publishing creates a separate read-only page that you can share with teammates, users, or other agents. It does not turn the original workspace into a public editing surface; regeneration, Ask, and app controls stay in your local or authenticated workspace.

Can another agent use a Grok-Wiki page after it is generated?

Yes. Published wikis expose agent-readable context through the public page and Markdown surfaces, so an agent can start from the generated structure instead of rereading the repository from zero.

What kinds of repositories are a good fit?

Grok-Wiki is most useful when the codebase has enough surface area that a README is not enough: architecture handoffs, onboarding, legacy systems, SDKs, CLIs, internal tools, and projects where source-backed explanations matter more than a quick summary.