# Show HN: 10x better performance from the Coding Harnesses with LLM-wiki

> Source: <https://llm-wiki.net/>
> Published: 2026-06-18 15:23:30+00:00

### Research

5–10 parallel agents search academic, technical, applied, news, and contrarian angles. `--min-time 2h`

keeps going in rounds, drilling into gaps each round finds.

```
██╗     ██╗     ███╗   ███╗    ██╗    ██╗██╗██╗  ██╗██╗
██║     ██║     ████╗ ████║    ██║    ██║██║██║ ██╔╝██║
██║     ██║     ██╔████╔██║    ██║ █╗ ██║██║█████╔╝ ██║
██║     ██║     ██║╚██╔╝██║    ██║███╗██║██║██╔═██╗ ██║
███████╗███████╗██║ ╚═╝ ██║    ╚███╔███╔╝██║██║  ██╗██║
╚══════╝╚══════╝╚═╝     ╚═╝     ╚══╝╚══╝ ╚═╝╚═╝  ╚═╝╚═╝
```

Parallel multi-agent research. Thesis-driven investigation. Source ingestion.
Wiki compilation. Session memory. Feedback curation. Topic archiving. Inventory tracking.
Dataset manifests. Truth-seeking audits. Querying. Artifact generation. Ships as a
Claude Code plugin, an OpenAI Codex plugin, an OpenCode instruction file, or a
portable `AGENTS.md`

. Obsidian-compatible.

Every run compounds. Sources become cross-referenced articles. Articles become reports, slide decks, study guides, playbooks, and implementation plans. Session digests keep the agent oriented without turning private chats into topic evidence.

One command spins up a topic wiki, dispatches up to ten agents, ingests what's worth keeping, collects provenance-rich catalogs before tracking them, archives old topics without deleting them, tracks durable follow-up state, indexes large datasets without copying them, captures redacted session context and feedback candidates without hoarding transcripts, compiles sources into articles, and hands you a deliverable built on top. All plain Markdown you own.

5–10 parallel agents search academic, technical, applied, news, and contrarian angles. `--min-time 2h`

keeps going in rounds, drilling into gaps each round finds.

Start from a claim. Agents split across supporting, opposing, mechanistic, meta, and adjacent angles. Output is a verdict — not a summary. Round two fights confirmation bias.

URLs, files, PDFs, inbox drops, Git doc repos, MediaWiki dumps, message archives, and Wayback CDX snapshots. Raw sources stay immutable; articles synthesize on top.

Find, dedupe, download bounded public media, and catalog discoverable artifacts, examples, memes, tools, entities, and source candidates. Captures aliases, found-in-context provenance, local asset paths, hashes, scale, media policy, and inventory fit.

Track durable things the wiki should remember: items, source candidates, corpora, entities, open questions, watch items, and next actions. Chat views default to compact tables.

Index large, external, mutable, or operational data with manifests, samples, profiles, and query recipes. The wiki becomes the interface; the data stays where it belongs.

Move whole topic wikis to `topics/.archive/`

. Preserved knowledge stays structurally maintainable but out of default query, compile, research, collect, output, and maintenance context.

Raw sources become synthesized articles with cross-references and confidence scores. Every directory has an `_index.md`

— nothing is scanned blindly.

Quick (indexes), standard (articles), or deep (everything + sibling wikis). `--resume`

picks up where you left off.

Default-on hook capture writes redacted events, state JSON, and Markdown digests under `.sessions/`

. Rehydrate future turns with compact context; promote only what belongs in a topic.

Curates high-signal corrections, preferences, approvals, and plan acceptance under `.sessions/feedback/`

. Generic acknowledgements are ignored; durable lessons are explicitly promoted.

Score every article for staleness and quality. Two-tier scan: fast metadata check, then deep content read for flagged articles. Checkpoint recovery. Machine-readable JSON + human-readable report.

Answer the broader trust question. Reuse the librarian pass, trace outputs across `raw/`

, `wiki/`

, and `output/`

, detect drift, inspect provenance, and do fresh research when local evidence is not enough.

Extract lessons learned from the current session — error→fix patterns, user corrections, discoveries. Saved as structured notes the wiki can query later. `--rules`

emits enforceable rules instead of prose.

Wiki-grounded implementation plans. Reads the knowledge base, interviews you about requirements, fills gaps with targeted research, and produces a phased plan citing wiki articles as evidence. `--format rfc|adr|spec`

.

Reports, slide decks, study guides, playbooks, implementation plans, timelines, glossaries, comparisons. Filed back into the wiki so the next output builds on every previous one.

Native plugin. Recommended.

```
claude plugin install wiki@llm-wiki
```

Installs from the public marketplace. Restart Claude Code to apply.

Marketplace plugin. Invoke with `@wiki`

.

```
codex plugin marketplace add nvk/llm-wiki
# Then open /plugins, enable "LLM Wiki", use @wiki
```

Or from a local checkout: `./scripts/bootstrap-codex-plugin.sh --scope user --verify`

. The Codex tree is a generated mirror of the Claude source of truth — updates land identically.

Instruction file.

```
# In opencode.json:
{ "instructions": [
  "path/to/llm-wiki/plugins/llm-wiki-opencode/skills/wiki-manager/SKILL.md"
] }
```

Or copy to `~/.config/opencode/AGENTS.md`

. Web search requires `OPENCODE_ENABLE_EXA=1`

.

Instruction file. Best for local models.

```
pi --instructions path/to/llm-wiki/plugins/\
llm-wiki-opencode/skills/wiki-manager/SKILL.md
```

Pi's 1K system prompt leaves room for the full wiki skill on 32K context local models. Uses the same skill file as OpenCode.

Portable `AGENTS.md`

.

```
curl -sL https://raw.githubusercontent.com/nvk/llm-wiki/master/AGENTS.md \
  > ~/your-project/AGENTS.md
```

Drop the file into any agent's context or project root. Works with anything that can read/write files and search the web.

**Claude Code:**

```
claude plugin update wiki@llm-wiki
# Restart Claude Code to apply
```

If the update command misses a new version (stale marketplace cache), sync manually:

```
git clone https://github.com/nvk/llm-wiki.git   # or: git -C ~/llm-wiki pull
REPO=~/llm-wiki/claude-plugin
DEST=~/.claude/plugins/cache/llm-wiki/wiki
VERSION=$(grep '"version"' "$REPO/.claude-plugin/plugin.json" | grep -o '[0-9.]*')
rm -rf "$DEST"/*
mkdir -p "$DEST/$VERSION"
cp -R "$REPO/.claude-plugin" "$REPO/commands" "$REPO/skills" "$DEST/$VERSION/"
```

**Codex:** `codex plugin marketplace upgrade llm-wiki`

. For a local checkout: re-run `./scripts/bootstrap-codex-plugin.sh --scope user --verify`

.

**AGENTS.md:** re-run the curl command above to replace the file.

One command, from anywhere — creates a topic wiki, launches parallel agents, keeps researching for an hour, comes back compiled.

```
/wiki:research "gut microbiome" --new-topic --min-time 1h
```

More common flows:

```
/wiki:research "nutrition" --new-topic
/wiki:research "fasting" --deep --min-time 2h
/wiki:research "What makes articles go viral?" --new-topic

/wiki:research --mode thesis "fiber reduces neuroinflammation via SCFAs"
/wiki:query "How does fiber affect mood?"
/wiki:query --resume

/wiki add https://example.com/article       # fuzzy router → ingest
/wiki what do we know about CRISPR?         # fuzzy router → query

/wiki:ingest-collection https://github.com/bitcoin/bips --wiki bitcoin
/wiki:collect "bitcoin memes" --wiki bitcoin
/wiki:collect "bitcoin memes" --scale medium --media reference --inventory corpus
/wiki:inventory add item "TRX-4M ring and pinion" --wiki trx4m-1-18
/wiki:inventory list --view actions --limit 10
/wiki:dataset add "Bitcointalk Temporal Graph" --location https://figshare.com/articles/dataset/BitcoinTemporalGraph/26305093
/wiki:dataset list --view schema --limit 10
/wiki:archive topic old-interest --reason "No longer active"
/wiki:archive list --archived
/wiki:archive restore old-interest
/wiki:session status
/wiki:session rehydrate --cwd "$PWD"
/wiki:feedback list --unpromoted
/wiki:session disable   # optional opt-out

/wiki:compile
/wiki:output report --topic gut-brain
/wiki:assess /path/to/my-app --wiki nutrition
/wiki:lint --fix
```

Long agent runs lose useful context when chats compact, terminals close, or work moves from Claude to Codex.
LLM Wiki now has a hidden operational layer for that: redacted checkpoints, compact digests, and user-feedback
candidates under `HUB/.sessions/`

. It helps the next turn get oriented without treating private chat
logs as curated wiki knowledge.

Trusted hooks capture in balanced mode by default. `/wiki:session disable`

writes `enabled: false`

so those hooks become no-ops.

Capture stores metadata, state, small events, and distilled Markdown digests. Full transcripts are not stored by default.

`/wiki:session rehydrate`

returns a compact context block pointing the agent to relevant digests for the current directory, topic, or session ID.

Session digests and feedback candidates remain operational memory until `promote`

writes a distilled note into a topic's `raw/notes/`

.

```
HUB/.sessions/
├── config.json                         # enabled/mode/privacy/rehydrate settings
├── registry.jsonl                      # append-only lifecycle events
├── queue/YYYY-MM-DD.jsonl              # small redacted hook events
├── state/<harness>/<session_id>.json   # latest per-session machine state
├── digests/YYYY/MM/<harness>-<session_id>.md
├── feedback/
│   ├── candidates.jsonl                # corrections, preferences, approvals, plan acceptance
│   └── status.json
└── indexes/                            # derived caches for cwd/topic/session lookups
/wiki:session status
/wiki:session rehydrate --cwd "$PWD"
/wiki:session list --limit 10
/wiki:session show codex:abc123
/wiki:session promote codex:abc123 --topic meta-llm-wiki

/wiki:feedback list --unpromoted
/wiki:feedback show fb-abc123
/wiki:feedback promote fb-abc123 --topic meta-llm-wiki

/wiki:session disable   # opt out
/wiki:session enable    # turn capture back on
```

The same `.sessions/`

layout works across Codex, Claude Code, OpenCode, Gemini-style adapters, and local `.wiki/`

project wikis.

`.sessions/`

; no full transcripts by default.`--fix`

auto-repairs safe issues.

```
~/wiki/                                 # Hub — lightweight, no content
├── wikis.json                          # Registry of all topic wikis
├── _index.md                           # Lists topic wikis with stats
├── log.md                              # Global activity log
├── .sessions/                          # Operational session memory, digests + feedback
└── topics/                             # Each topic is an isolated wiki
    ├── nutrition/
    │   ├── .obsidian/                  # Obsidian vault config
    │   ├── inbox/                      # Drop zone for this topic
    │   ├── inventory/                  # Items, candidates, corpora, views
    │   ├── datasets/                   # Manifests for large/external data
    │   ├── raw/                        # Immutable sources
    │   ├── wiki/                       # Compiled articles
    │   │   ├── concepts/
    │   │   ├── topics/
    │   │   └── references/
    │   ├── output/                     # Generated artifacts
    │   ├── _index.md
    │   ├── config.md
    │   └── log.md
    ├── woodworking/                    # Another topic wiki
    └── .archive/                       # Archived topic wikis, hidden by default
```

Each research area is isolated. No cross-topic noise. Queries stay focused. A multi-wiki peek finds overlap when relevant.

`[[wikilinks]]`

for Obsidian plus standard markdown links for everything else. Works in every viewer — including no viewer at all.

Once a source is ingested it is never modified. Articles synthesize on top. Retraction removes both cleanly.

`/wiki:collect`

records aliases, source context, media URLs, cached asset paths, hashes, dedupe notes, scale, and inventory recommendations before anything becomes evidence or durable state.

Parts, source queues, corpora, watch items, and next actions live under `inventory/`

so they can be listed and revisited without becoming evidence.

`datasets/`

stores manifests, samples, profiles, and query recipes for large data. The wiki indexes data without copying it into the source corpus.

Archived topics live under `topics/.archive/`

. Most tools skip them by default; deep queries may surface index hits, and explicit `--include-archived`

can read them.

`.sessions/`

is hidden, cross-topic operational state for redacted checkpoints, digests, rehydration indexes, and feedback candidates. Topic promotion is explicit.

Runs entirely on the host agent's built-in tools. Plugin is Markdown + commands. No servers, no services, no telemetry.

All commands accept `--wiki <name>`

to target a topic wiki and `--local`

for the project wiki. Archived topic wikis are skipped by default; commands that support `--include-archived`

require that explicit flag before reading or writing archived material. `query`

, `output`

, and `plan`

also accept `--with <wiki>`

for cross-wiki context.

| Command | Description |
|---|---|
`/wiki <natural language>` | Fuzzy intent router — say what you want, it routes to the right subcommand. |
`/wiki` | Show status, stats, and list all topic wikis. |
`/wiki init <name>` | Create a topic wiki at `~/wiki/topics/<name>/` . |
`/wiki:ingest <source>` | Ingest a URL, file path, or quoted text. |
`/wiki:ingest --inbox` | Process files dropped into the topic wiki's inbox. |
`/wiki:ingest-collection <source>` | Bulk-ingest Git doc repos, BIP-style proposal sets, MediaWiki dumps/API sites, message archives, or Wayback CDX snapshots. |
`/wiki:collect "<things>"` | Find, dedupe, and catalog artifacts, examples, resources, media, memes, tools, entities, or source candidates. |
`/wiki:collect "<things>" --scale tiny|small|medium|large|huge` | Control write behavior by operational scale: row count, media weight, provenance burden, volatility, and inventory usefulness. |
`/wiki:collect "<things>" --media archive|thumbnail|reference` | Download bounded originals by default for media-bearing collections; use thumbnails for previews or reference to opt out. |
`/wiki:collect "<things>" --inventory corpus|records` | Create one corpus record for medium or media-heavy sets, or per-item records only for small durable lists. |
`/wiki:inventory list` | List durable tracking records as compact chat tables or bullets. |
`/wiki:inventory add <kind> "title"` | Add items, source candidates, entities, corpora, questions, tasks, or watch records after a fit check. |
`/wiki:inventory scan-outputs --dry-run` | Preview legacy queues/backlogs before an additive inventory migration. |
`/wiki:dataset list` | List dataset manifests without opening samples, profiles, queries, or underlying data. |
`/wiki:dataset add "title" --location <path-or-url>` | Index large or external data with a manifest; the data stays outside the wiki. |
`/wiki:dataset profile <slug> --dry-run` | Preview lightweight profiling of size, format, headers, or schema observations. |
`/wiki:archive list [--archived]` | List active topic wikis and optionally archived topic wikis. |
`/wiki:archive topic <slug> --reason "why"` | Move a topic wiki to `topics/.archive/<slug>` and hide it from default context. |
`/wiki:archive restore <slug>` | Restore an archived topic wiki to active status. |
`/wiki:archive peek <query>` | Search archived topic indexes without reading archived article bodies. |
`/wiki:session status|disable|enable` | Inspect, opt out of, or reconfigure default-on redacted session capture. |
`/wiki:session capture|list|show` | Create, browse, and inspect redacted session digests kept outside topic evidence. |
`/wiki:session rehydrate|promote` | Load compact session context or explicitly promote a distilled digest into topic raw notes. |
`/wiki:feedback list|show` | Review redacted feedback candidates for corrections, preferences, approvals, and plan acceptance. |
`/wiki:feedback capture|promote` | Manually add a feedback candidate or explicitly promote one into topic raw notes. |
`/wiki:compile` | Compile new sources into wiki articles. |
`/wiki:query <question>` | Q&A against the wiki. `--quick` / `--deep` / `--list` / `--resume` / `--include-archived` . |
`/wiki:ll` | Extract lessons from current session into wiki. `--dry-run` , `--rules` . |
`/wiki:research <topic>` | 5 parallel agents. `--plan` (multi-path), `--deep` (8), `--retardmax` (10), `--new-topic` , `--min-time 1h` . |
`/wiki:research --mode thesis <claim>` | Thesis-driven research: for + against → verdict. |
`/wiki:plan <goal>` | Wiki-grounded implementation plan. `--format rfc|adr|spec` . |
`/wiki:output <type>` | summary, report, study-guide, slides, timeline, glossary, comparison. |
`/wiki:assess <path>` | Assess a repo against wiki + market. Gap analysis. |
`/wiki:audit` | Truth-seeking audit across wiki, outputs, provenance, and fresh research when needed. |
`/wiki:librarian` | Score articles for staleness and quality. Checkpoint recovery. `--article <path>` for single article. |
`/wiki:lint` | Health checks. `--fix` auto-repairs. `--deep` web-verifies facts. |
`/wiki:retract` | Remove a source and clean up downstream references. |
`/wiki:project` | Group outputs into projects with goals and manifests. |

From zero to a compiled wiki in 5 minutes.

**1. Install the plugin**

```
claude plugin install wiki@llm-wiki
```

**2. Create a topic wiki**

Pick any topic you're curious about:

```
/wiki init nutrition
```

This creates a hub at `~/wiki/`

and your first topic wiki at `~/wiki/topics/nutrition/`

.

**3. Research it**

```
/wiki:research "gut microbiome and mental health" --wiki nutrition
# or just say it naturally:
/wiki research gut microbiome and mental health
```

Five parallel agents search the web from different angles (academic, technical, applied, news, contrarian), ingest the best sources, and compile them into cross-referenced wiki articles. Takes 2-5 minutes.

**4. Ask your wiki a question**

```
/wiki:query "how does fiber affect mood?" --wiki nutrition
# or naturally:
/wiki how does fiber affect mood?
```

The wiki answers from its compiled articles with citations.

**5. Audit before you trust an output**

```
/wiki:audit --wiki nutrition
/wiki:audit --artifact output/report-gut-brain.md
```

Audit rechecks the wiki layer, traces the output's evidence chain, flags drift, and will do fresh research if the local corpus is not enough to answer the trust question.

**What to do next:**

`/wiki:research "topic" --deep`

— 8 agents instead of 5, adds historical and data angles`/wiki:research "topic" --min-time 1h`

— keep researching in rounds for an hour`/wiki:research "topic" --plan`

— decompose into parallel research paths`/wiki:audit --project nutrition-playbook`

— verify outputs and upstream wiki state together`/wiki add https://example.com/article`

— fuzzy router detects the URL and ingests it`/wiki what do we know about CRISPR?`

— fuzzy router detects the question and queries`/wiki:lint --fix`

— clean up any structural issuesA typical research session flows through four stages:

**Stage 1: Ask a question or pick a topic**

llm-wiki auto-detects whether you're asking a question or naming a topic. Use the direct command or the fuzzy router:

```
/wiki:research "What makes long-form articles go viral?"   # direct command
/wiki research quantum computing                            # fuzzy router — same result
/wiki:research --mode thesis "fiber reduces neuroinflammation via SCFAs"  # thesis → for/against evidence
```

**Stage 2: Agents search in parallel**

5 agents (8 with `--deep`

, 10 with `--retardmax`

) search simultaneously from different angles — 2-3 web searches each, full-content fetch, quality scoring (1-5). A credibility pass deduplicates before ingestion.

**Stage 3: Sources are ingested and compiled**

Top sources are saved to `raw/`

(immutable — never modified after ingestion). Then the compilation pass synthesizes them into wiki articles under `wiki/concepts/`

, `wiki/topics/`

, and `wiki/references/`

with cross-references, confidence scores, and bidirectional links.

**Stage 4: Gap report and follow-up**

After each round, you see what's covered, what's still missing, and suggested follow-ups. If 2+ gaps remain, you're offered to close them in parallel:

```
### Close gaps?
1. Dose-response curves for wavelength specificity
2. Long-term safety data for daily exposure
3. Device comparison (clinical vs consumer panels)

Enter numbers (e.g. 1,2,4), "all", or "skip":
```

**Multi-round research:** Add `--min-time 2h`

to keep researching in rounds, each drilling into gaps the previous round found. Add `--plan`

to decompose into parallel paths upfront.

**The hub** (`~/wiki/`

) is just a registry. No content — only `wikis.json`

, `_index.md`

, and `log.md`

. All content lives in topic sub-wikis.

**Topic wikis** (`~/wiki/topics/<name>/`

) are isolated research areas. Each has its own sources, articles, outputs, and Obsidian vault config. Isolation means researching quantum computing can't pollute your nutrition wiki.

**Raw sources** (`raw/`

) are immutable. Once a paper, article, or data file is ingested, it's never modified. This is the audit trail — every claim in every article traces back to a source.

**Wiki articles** (`wiki/`

) are LLM-compiled syntheses organized into three categories:

**Archive** (`topics/.archive/`

) is for whole topic wikis the user no longer wants in normal context. It preserves source history, articles, outputs, and logs while keeping old interests quiet by default.

**Sessions** (`HUB/.sessions/`

) are operational memory for redacted harness checkpoints, compact digests, rehydration indexes, and feedback candidates. They are not compiled as topic evidence unless explicitly promoted into `raw/notes/`

.

**Inventory** (`inventory/`

) is for durable operational state: actual items, source candidates, corpora, entities, open questions, tasks, watch items, and next actions. It is intentionally not evidence for factual claims.

**Dataset manifests** (`datasets/`

) let the wiki index large or external data without copying it into `raw/`

. Manifests can point to local paths, URLs, archives, samples, profiles, and query recipes.

Articles use dual-link format: `[[wikilink]]`

for Obsidian + standard markdown links for everything else. Confidence scores (high/medium/low) reflect source quality and corroboration.

**Indexes** (`_index.md`

) exist in every directory. They're derived caches — rebuilt automatically from file frontmatter. The agent reads indexes first and never scans blindly.

**Outputs** (`output/`

) are generated artifacts: reports, slide outlines, study guides, implementation plans. They're built from wiki articles, so every output compounds on all prior research.

**Audit** walks that full artifact graph. It can trace an output back through the wiki state and raw sources it depended on, then escalate into fresh research when the stored evidence is stale or incomplete.

Session capture is default-on operational memory. Trusted Codex, Claude, OpenCode, and Gemini hooks write redacted checkpoints into `HUB/.sessions/`

or a local `.wiki/.sessions/`

. The topic wiki stays clean until you promote something.

**What is captured:** harness name, session ID, current directory, git branch/remote, small redacted hook events, per-session state JSON, markdown digests, and feedback candidates. Full transcripts are off by default.

```
HUB/.sessions/
├── config.json
├── registry.jsonl
├── queue/YYYY-MM-DD.jsonl
├── state/<harness>/<session_id>.json
├── digests/YYYY/MM/<harness>-<session_id>.md
├── feedback/candidates.jsonl
└── indexes/
```

**Daily commands:**

```
/wiki:session status
/wiki:session rehydrate --cwd "$PWD"
/wiki:session list --limit 10
/wiki:session show codex:abc123
/wiki:feedback list --unpromoted
/wiki:feedback promote fb-abc123 --topic meta-llm-wiki
```

**Opt out:** `/wiki:session disable`

writes `enabled: false`

in `.sessions/config.json`

, so trusted hooks become no-ops. `/wiki:session enable`

turns it back on.

**Promotion rule:** session digests and feedback candidates are useful for continuity, but they become topic knowledge only after `/wiki:session promote`

or `/wiki:feedback promote`

writes a distilled note under `raw/notes/`

.

Use native `ds4-agent`

for DS4 wiki work, not a bare chat profile. LLM Wiki needs a real tool loop for targeted reads, writes, edits, shell checks, and index-first navigation.

**Profile rule:** keep `ds4c-wiki`

as an opt-in side command. Load the LLM Wiki instruction file into `-sys`

, launch with `--chdir "$PWD"`

, and keep your model, checkout, and hub paths in environment variables.

```
export DS4_REPO="$HOME/src/ds4"
export DS4_MODEL="$HOME/models/deepseek-v4-flash-q2.gguf"
export LLM_WIKI_REPO="$HOME/agent-workspace/llm-wiki"
export WIKI_INSTRUCTIONS="$LLM_WIKI_REPO/plugins/llm-wiki-opencode/skills/wiki-manager/SKILL.md"

# Run from the project or fixture you want ds4-agent to edit.
target_cwd="$PWD"
system_prompt="$(printf '%s\n' \
  'You are ds4c-wiki, a native ds4-agent profile for LLM Wiki workflows.' \
  'Resolve the hub, read indexes first, choose a topic, then use targeted reads/searches.' \
  'Do not broad-scan home directories, unrelated source trees, or dependency folders.' \
  'Keep .sessions operational until the user explicitly promotes a digest or feedback candidate.'; \
  cat "$WIKI_INSTRUCTIONS")"

"$DS4_REPO/ds4-agent" \
  -m "$DS4_MODEL" \
  -c "${DS4_CTX:-100000}" \
  --chdir "$target_cwd" \
  --nothink \
  -sys "$system_prompt" \
  --non-interactive \
  -p 'wiki status: tell me which hub or local .wiki you would use, then stop'
```

**Public examples rule:** use placeholders like `~/src/ds4`

, `~/models/model.gguf`

, `~/agent-workspace/llm-wiki`

, and `~/wiki`

. Before sharing snippets, redact local usernames, hostnames, LAN or VPN IPs, SSH fingerprints, tokens, raw traces, and full `.sessions/`

content.

**First real test:** run a disposable local wiki fixture before pointing DS4 at your real hub.

```
tmp="$(mktemp -d)"
cd "$tmp"
git init
cat > AGENTS.md <<'EOF'
Use only this fixture's local .wiki directory. Do not read or write a real user hub.
EOF

DS4C_WIKI_NON_INTERACTIVE=1 ds4c-wiki \
  'Initialize a local .wiki, add one fictional raw note, query it, then stop.'
find .wiki -maxdepth 4 -type f | sort
```

**Pass gate:** the profile should read indexes first, avoid broad scans, keep `.sessions/`

operational until promotion, create only fixture-local files in the test, and answer from local wiki evidence. Full guide: [DS4 wiki profile on learntoprompt.org](https://learntoprompt.org/guides/ds4-wiki-profile.html).

Use iCloud Drive when you want the same hub visible from multiple Macs. The important rule is that the shared config should describe the logical path, not one Mac's absolute user directory.

**Set the hub with a portable path:**

```
/wiki config hub-path "~/Library/Mobile Documents/com~apple~CloudDocs/wiki"
```

This writes `~/.config/llm-wiki/config.json`

. New configs should keep `hub_path`

and avoid writing a machine-specific `resolved_path`

. Shared `wikis.json`

entries should store topic paths such as `topics/bitcoin`

, not `/Users/alice/.../topics/bitcoin`

.

**Each Mac needs its own app permission.** iCloud sync can be healthy while macOS still blocks the agent process. Full Disk Access is local to the machine and to the exact launcher app.

`/usr/libexec/sshd-session`

, `/usr/libexec/sshd-keygen-wrapper`

, and optionally `/usr/sbin/sshd`

, then start a new SSH/Codex session.**Fast diagnostic:** run this from the same terminal, SSH session, or app that launches the agent:

``` python
python3 - <<'PY'
from pathlib import Path
hub = Path.home() / "Library/Mobile Documents/com~apple~CloudDocs/wiki"
for path in [hub, hub / "wikis.json", hub / "topics"]:
    try:
        print("STAT OK:", path)
        path.stat()
    except Exception as exc:
        print("STAT FAIL:", type(exc).__name__, exc)
    try:
        if path.is_dir():
            print("LIST OK:", [p.name for p in path.iterdir()][:10])
        else:
            print("READ OK:", path.read_text(encoding="utf-8")[:200])
    except Exception as exc:
        print("READ/LIST FAIL:", type(exc).__name__, getattr(exc, "errno", None), exc)
PY
```

**How to read the result:** `STAT OK`

followed by `READ/LIST FAIL ... Operation not permitted`

means the path is correct and macOS privacy is denying content access. Do not switch to `~/wiki`

or a machine-local `resolved_path`

; grant the launcher permission and restart the session.

For broad topics, `--plan`

decomposes your research into independent paths and runs them all in parallel:

```
/wiki:research "red light therapy" --plan --wiki redlight-therapy
# or naturally:
/wiki research red light therapy --plan
```

The agent generates a research plan and asks for confirmation:

```
## Research Plan — red light therapy

### Paths (will run in parallel)

1. **Mechanisms** — cytochrome c oxidase, wavelength specificity, dose-response
2. **Clinical evidence** — RCTs for skin, joints, wounds, cognition
3. **Devices** — LED vs laser, panel sizing, FDA clearances
4. **Criticisms** — placebo effects, publication bias, safety concerns

### Estimated: 4 paths x 5 agents = 20 parallel agents

Proceed? (y/n/edit)
```

On confirmation, all paths launch simultaneously. Each path runs its own 5-agent swarm. Sources are ingested in parallel (each path writes unique files), then a single compilation pass sees all sources at once for cross-path synthesis.

**After the first round,** a gap report shows what's still missing. Pick which gaps to close — they launch as another parallel batch:

```
### Close gaps?
1. Dose-response curves for wavelength specificity
2. Long-term safety data for daily exposure
3. Device comparison (clinical vs consumer)

Enter numbers (e.g. 1,2,4), "all", or "skip":
```

**Combine with other flags:**

`--plan --deep`

— 8 agents per path instead of 5`--plan --min-time 2h`

— multiple plan-dispatch-compile cycles over 2 hours`--plan --new-topic`

— create the wiki and research in one shotOnce your wiki has compiled articles, generate deliverables from them:

```
/wiki:output report --topic gut-brain --wiki nutrition
# or naturally:
/wiki write a report on gut-brain axis
```

**Output types:**

`summary`

— concise overview of a topic or the entire wiki`report`

— detailed analysis with citations and evidence`study-guide`

— structured learning material with key concepts and review questions`slides`

— slide deck outline with speaker notes`timeline`

— chronological view of events and developments`glossary`

— term definitions extracted from articles`comparison`

— side-by-side analysis of two or more subjectsOutputs are saved to `output/`

inside the topic wiki and indexed automatically. Every output builds on all compiled articles, so the more you research, the stronger every output gets.

**Retardmax mode** works here too — `/wiki:output report --retardmax`

ships a rough draft immediately. Iterate later.

**Cross-wiki context:** Use `--with`

to pull knowledge from another wiki into your output:

```
/wiki:output report --wiki nutrition --with article-writing
# Uses nutrition content + article-writing craft knowledge
```

**Projects:** Group related outputs into project folders with goals:

```
/wiki:project new rebuild-blog "Rewrite the company blog using wiki research"
/wiki:output report --topic gut-brain --project rebuild-blog
```

The output lands in `output/projects/rebuild-blog/`

with a `WHY.md`

that captures the goal. Future outputs with the same `--project`

flag accumulate there.

Research sessions fetch many URLs. By default, Claude Code asks for approval on each one. To skip these prompts, add `WebFetch`

and `WebSearch`

to your project's allow list:

In `.claude/settings.local.json`

:

```
{
  "permissions": {
    "allow": [
      "WebFetch",
      "WebSearch"
    ]
  }
}
```

This pre-approves all web fetches and searches. You can also allow specific domains only: `WebFetch(domain:arxiv.org)`

.

If you prefer per-session approval, choose "Always allow" when Claude asks about the first URL — that covers the rest of the session.

Pulled live from [github.com/nvk/llm-wiki/releases](https://github.com/nvk/llm-wiki/releases). Falls back to the version baked into the plugin manifest if the API is unavailable.

**Feedback curator.** Trusted hooks now distill high-signal user corrections, preferences, approvals, and plan acceptance into redacted candidates under `HUB/.sessions/feedback/`

.

**Noise filter.** Generic acknowledgements like `ok`

, `thanks`

, and `cool`

are ignored by default.

**Review then promote.** Use `/wiki:feedback list`

, `show`

, and `promote`

; selected candidates become topic knowledge only through explicit promotion into `raw/notes/`

.

Pulled live from `.claude-plugin/marketplace.json`

on the master branch via jsDelivr CDN — no rate limits, always current.

LLM-compiled knowledge base. Commands: `/wiki`

(router + init/status), `/wiki:ingest`

, `/wiki:ingest-collection`

, `/wiki:collect`

, `/wiki:inventory`

, `/wiki:dataset`

, `/wiki:archive`

, `/wiki:session`

, `/wiki:feedback`

, `/wiki:compile`

, `/wiki:query`

, `/wiki:research`

, `/wiki:audit`

, `/wiki:librarian`

, `/wiki:ll`

, `/wiki:assess`

, `/wiki:plan`

, `/wiki:lint`

, `/wiki:output`

, `/wiki:retract`

, `/wiki:project`

.

LLM Wiki is a set of commands and a knowledge model that turns any LLM agent into a research engine and an append-only, Markdown-native wiki. It runs parallel multi-agent research, collects provenance-rich catalogs of discoverable artifacts and examples, preserves redacted session memory and feedback candidates under `.sessions/`

, ingests URLs and files, archives old topic wikis that should stay preserved but quiet, tracks durable inventory state, indexes large datasets with manifests, compiles raw sources into synthesized articles with cross-references, audits whether those articles and outputs are still trustworthy, answers questions against the compiled knowledge, and generates artifacts like reports, slides, study guides, and implementation plans.

Inspired by [Andrej Karpathy's LLM wiki concept](https://x.com/karpathy/status/2039805659525644595).

Five install modes: Claude Code (native plugin via the `llm-wiki`

marketplace), OpenAI Codex (marketplace plugin via `codex plugin marketplace add nvk/llm-wiki`

, invoked with `@wiki`

), OpenCode (instruction file via `opencode.json`

), Pi (instruction file — best for local models with its minimal system prompt), and any other LLM agent via the portable `AGENTS.md`

file.

The behavioral logic lives in a single `wiki-manager`

skill shared across runtimes — Codex, OpenCode, and Pi trees symlink into the Claude source of truth so there is no fork. Drift is caught by self-healing sync tests.

By default in `~/wiki/`

on your machine. You can relocate the hub to iCloud Drive, Dropbox, or any custom path:

```
/wiki config hub-path ~/Library/Mobile\ Documents/com~apple~CloudDocs/wiki
```

Config lives at `~/.config/llm-wiki/config.json`

. Shared hubs should use portable `hub_path`

values and relative `wikis.json`

topic paths; old machine-specific `resolved_path`

values are treated only as fallback caches.

macOS privacy permissions are local to each Mac and to the exact process launching the agent. One machine can read the iCloud hub while another machine with the same Apple ID and same files returns `Operation not permitted`

.

If `stat`

succeeds for the hub but reading `wikis.json`

or listing `topics/`

fails, the configured `hub_path`

is correct. Grant Full Disk Access or iCloud Drive access to the launcher app, then fully restart that app and the agent.

For SSH-launched Codex sessions, Terminal.app permission is not enough because Codex is a child of `sshd-session`

. Grant access to `/usr/libexec/sshd-session`

, `/usr/libexec/sshd-keygen-wrapper`

, and optionally `/usr/sbin/sshd`

, then start a new SSH session.

Session memory lives in `HUB/.sessions/`

or a local `.wiki/.sessions/`

. It is hidden operational state: redacted hook events, state JSON, digest Markdown, feedback candidates, and indexes for rehydration.

It is default-on so long sessions can survive compaction and future turns can start with the right context. It does not store full transcripts by default. Run `/wiki:session disable`

to opt out, `/wiki:session rehydrate`

to load compact context, and `/wiki:session promote`

only when a digest should become topic evidence.

Yes. Each topic wiki ships with its own `.obsidian/`

vault config and can be opened as an independent vault:

```
open ~/wiki/topics/nutrition/
```

Cross-references use a dual-link format:

```
[[gut-brain-axis|Gut-Brain Axis]] ([Gut-Brain Axis](../concepts/gut-brain-axis.md))
```

Obsidian reads the wikilink for graph view and backlinks; everything else (Claude Code, GitHub, plain text editors) follows the standard markdown link.

A research mode inspired by [Elisha Long's retardmaxxing philosophy](https://www.retardmaxx.com/) — act first, think later. Ten parallel agents, skip planning, cast the widest net, ingest aggressively, compile fast, lint later.

Available on `/wiki:research --retardmax`

and `/wiki:output --retardmax`

for when you want results now and will clean up afterward.

`/wiki:research --mode thesis "<claim>"`

starts from a specific claim and uses it as a filter. Agents are split across **supporting**, **opposing**, **mechanistic**, **meta/review**, and **adjacent** — balanced by design.

Sources that don't relate to the claim's variables are skipped, which keeps the wiki tight. Output is a **verdict**: supported, partially supported, contradicted, insufficient evidence, or mixed.

With `--min-time`

, round two focuses harder on the weaker side of the evidence — counter-weight against confirmation bias.

Yes. LLM Wiki is MIT-licensed. Source and releases at [github.com/nvk/llm-wiki](https://github.com/nvk/llm-wiki).

Compiling, querying, linting, and generating artifacts from an existing wiki work offline — everything is plain Markdown on your disk. Research and ingestion need internet since they fetch URLs and search the web.

Zero runtime dependencies. LLM Wiki uses only the built-in tools of the host agent (file read/write, web fetch, web search). The plugin itself is Markdown: command definitions, skills, and reference docs.

Optional: [ask-grok-mcp](https://github.com/nvk/ask-grok-mcp) for best-in-class tweet ingestion, [tobi/qmd](https://github.com/tobi/qmd) for local search beyond ~100 articles.

**Claude Code:** `claude plugin update wiki@llm-wiki`

and restart.

**Codex:** `codex plugin marketplace upgrade llm-wiki`

(or re-run the bootstrap helper for a local checkout).

**AGENTS.md:** re-curl from the master branch to replace your file.

See [Install](#install) for the manual sync fallback when the plugin updater hits stale cache.