Jonathon's AI Wiki

Understand Anything — Codebase + Karpathy-LLM-Wiki Knowledge Graph for Multi-Agent Coding (Lum1104)

9 min read

Repo: github.com/Lum1104/Understand-Anything Stars: 21,832 (at ingest 2026-05-23) Language: TypeScript License: MIT Homepage: https://understand-anything.com (live demo at /demo/) Source: ai-research/lum1104-understand-anything-2026-05-23.md

Multi-agent codebase-to-knowledge-graph pipeline positioned as a shared retrieval layer across Claude Code (native plugin), Codex, Cursor, VS Code + GitHub Copilot, Copilot CLI, Gemini CLI, OpenCode, OpenClaw, Antigravity, Pi Agent, Vibe CLI, Hermes, Cline, and KIMI CLI — 14 integrations from a single repo. Headline pitch: “graphs that teach > graphs that impress.” TypeScript, MIT, created 2026-03-15, last push 2026-05-24 (active). The interesting hook for this wiki specifically: /understand-knowledge targets a Karpathy-pattern LLM wiki directly and produces a force-directed knowledge graph with community clustering — the pattern this vault implements is a named input format.

Key Takeaways

  • 14 platform integrations from one repo — broader fan-out than CodeGraph (colbymchenry)‘s 5-agent claim. Each integration is a separate verification (a repo can ship a working Claude Code path while half the named agents are stubs); the codegraph verification protocol applies in full.
  • Karpathy-pattern LLM wiki is a first-class input. /understand-knowledge ~/path/to/wiki consumes the exact format this vault uses — deterministic parser extracts wikilinks + categories from index.md, then LLM agents discover implicit relationships, extract entities, and surface claims. Force-directed graph with community clustering. Complement to the existing 2D / 3D graph view on jc-aiwiki.pages.dev — different vendor, different traversal model, same content shape.
  • Tree-sitter + LLM hybrid is the right architectural split — deterministic parser for structural facts (imports, exports, definitions, call sites, inheritance) feeds an importMap to LLM agents that produce summaries / tags / layer assignments / domain mappings / tours. Same code → same edges; intent layer captured separately. This is the same architectural shape QMD uses for wiki retrieval (BM25 deterministic + vector semantic + LLM rerank), translated to code.
  • 6 specialized agents with /understand-domain and /understand-knowledge adding 7th and 8th — project-scanner, file-analyzer, architecture-analyzer, tour-builder, graph-reviewer, domain-analyzer, article-analyzer. File analyzers run in parallel (up to 5 concurrent, 20-30 files per batch). Incremental by default.
  • Graph is JSON, designed to be committed. Teammates skip the pipeline by checking in .understand-anything/ (except intermediate/ and diff-overlay.json). /understand --auto-update registers a post-commit hook. Large graphs go on git-lfs. This is the shared-state-as-a-build-artifact pattern — orthogonal to the per-developer index pattern CodeGraph implies.
  • Persona-adaptive UI — dashboard adjusts detail level based on user role (junior dev / PM / power user). Combined with the business-domain view (/understand-domain), this targets non-engineer stakeholders, not just the IDE-resident developer.
  • Star count 21,832 on a ~2-month-old repo (created 2026-03-15). Same caveat shape as CodeGraph (19.1k stars / 4 months) and andrej-karpathy-skills (146k stars, verified real). Real Discord, real homepage with live demo, Trendshift badge, 8 README languages, ~13.5k LOC in pnpm-lock.yaml — looks legitimately built. See verification section.
  • Hermes is in the supported-platform matrix — confirms the Hermes Agent / CodeGraph / Understand-Anything triple as the named multi-agent integration set people are converging on for shared local code intelligence.
  • The “fewer tokens” claim from CodeGraph is implicit but not load-bearing here — Understand-Anything pitches understanding (onboarding, exploration, diff impact) before token-reduction. Different positioning for the same architectural primitive.

Implementation

Tool/Service: Lum1104/Understand-Anything (TypeScript pnpm monorepo, MIT, multi-agent codebase + wiki knowledge-graph builder) Setup (Claude Code, native):

/plugin marketplace add Lum1104/Understand-Anything
/plugin install understand-anything

Setup (other agents, one-line install):

curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash
# or pin platform:
curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash -s codex

Supported <platform> values: gemini, codex, opencode, pi, openclaw, antigravity, vibe, vscode, hermes, cline, kimi. Installer clones to ~/.understand-anything/repo and symlinks for the chosen platform.

Core commands:

  • /understand — build graph (incremental). Flags: --language en|zh|zh-TW|ja|ko|ru, --auto-update, subdirectory scope.
  • /understand-dashboard — interactive web dashboard.
  • /understand-chat <question> — Q&A over the graph.
  • /understand-diff — change-impact analysis.
  • /understand-explain <file-or-function> — symbol deep-dive.
  • /understand-onboard — auto-generated onboarding guide.
  • /understand-domain — business-process view.
  • /understand-knowledge ~/path/to/wiki — Karpathy-pattern LLM wiki → force-directed graph with community clustering.

Cost: Free / open-source (MIT). LLM costs are passed through to whichever agent surface invokes it.

Integration notes:

  • For this wiki specifically: /understand-knowledge against karpathy-obsidian-vault-main-2/wiki/ would produce a complement to the existing graph view. Different vendor, different traversal model, same content shape. Pairs with Karpathy Pattern adoption tracking.
  • Graph-as-committed-JSON pattern: write .understand-anything/ into the repo, gitignore intermediate/ + diff-overlay.json, use git-lfs for >10 MB graphs. Teammates skip the pipeline entirely.
  • The article-analyzer 7th agent (for /understand-knowledge) extracts entities + claims + implicit relationships — this is the same surface this wiki’s lint pass operates on (orphan detection, missing concepts, cross-link gaps). Worth comparing the two as wiki-health surfaces.
  • Tree-sitter importMap pre-resolution in scan phase is the implementation detail that makes the file-analyzer parallelism work without re-derivation cost. Same pattern would apply to wiki link-graph extraction.
  • For Hermes Agent specifically: install via install.sh hermes registers the skill surface. Slots alongside CodeGraph as a runtime skill — comparing them on the same Hermes session is the most direct test of which architecture wins.

Verify before citing

This article inherits the verification caveat from the raw stub. Strict-bar treats high stars + young age as a flag, not a disqualifier.

  • Star count 21,832 on a ~2-month-old repo (created 2026-03-15). Same caveat shape as CodeGraph (19.1k stars / 4 months) and andrej-karpathy-skills (146k stars, verified real). Signals raising the prior: live homepage with demo, real Discord community, Trendshift badge linking trending repos #23482, 8 README translations, 215 KB pnpm-lock.yaml (real Node monorepo), understand-anything-plugin/ with actual source. Signals that would lower the prior on inspection: stub commands behind the README’s table, missing source under understand-anything-plugin/, README copy that doesn’t match the build. Reproduction is still required.
  • 14 platform integrations is a wide claim. Each integration is a separate verification — a repo can ship a working Claude Code path while the Codex / Cursor / OpenCode / Gemini / Hermes / Cline / KIMI / Vibe / Antigravity / OpenClaw / Pi / Copilot paths are stubs. Confirm at least the 2-3 you care about end-to-end before citing the matrix.
  • “Tree-sitter + LLM hybrid” is falsifiable. The deterministic parser should produce identical structural output for identical source. Run it twice against the same repo and diff the two graph JSONs — only the LLM-summary fields should drift. If structural edges drift between runs, the determinism claim is wrong.
  • Karpathy-pattern /understand-knowledge is falsifiable directly against this vault. Point it at karpathy-obsidian-vault-main-2/wiki/ and compare the produced graph against the existing 2D / 3D view on jc-aiwiki.pages.dev. Coverage and edge quality are the load-bearing checks.
  • Persona-adaptive UI claim is fuzzy. “Adjusts based on who you are” needs a concrete mechanism — does it read a config? Detect from git author? Ask on first run? Inspect before citing.
  • Hermes integration is plausible (CodeGraph also claims Hermes support and Hermes does have a runtime skill surface), but install.sh hermes hasn’t been exercised in this vault yet. Run the install + a /understand against a small known repo to verify before pitching to anyone else.
  • What would falsify the headline framing. If reproduction shows: (i) Tree-sitter pass is non-deterministic, (ii) integrations are aspirational rather than working for ≥3 of the 14 named agents, (iii) /understand-knowledge produces a graph qualitatively worse than the existing 2D / 3D view on the same wiki content, or (iv) the homepage demo is the only working surface and the local install is broken — drop to “promising experimental code-graph format with a homepage demo, status unverified.”

Try It

  1. Pull the repo: gh repo clone Lum1104/Understand-Anything && cd Understand-Anything && cat README.md. Confirm the install paths, the integration matrix, the agent pipeline.
  2. Install the Claude Code plugin: /plugin marketplace add Lum1104/Understand-Anything && /plugin install understand-anything. Run /understand against a small repo you’ve written yourself (something under 5k LOC). Time the build, measure on-disk size of .understand-anything/.
  3. Run /understand-dashboard and explore the produced graph. Compare against CodeGraph on the same codebase if both are installed — coverage, depth, query latency, dashboard quality.
  4. Test the falsification: run /understand twice against the same repo. Diff the two knowledge-graph.json outputs. Structural edges should be identical; only LLM-summary fields should drift. If edges drift, the determinism claim is wrong.
  5. Test the wiki-input claim: run /understand-knowledge against ~/Auto1111/Claude/karpathy/karpathy-obsidian-vault-main-2/wiki/. Compare the produced force-directed graph against the existing 2D / 3D view on jc-aiwiki.pages.dev. Note coverage gaps + edge quality differences. If the produced graph adds anything the existing view misses, write a file-back article on the deltas.
  6. Test multi-agent shared state: if you use Hermes Agent or CodeGraph, install via install.sh hermes and verify the same graph index serves both. If only one agent integration works, downgrade the wiki article from “14-platform” to “Claude-Code-with-experimental-other-agent-support.”
  • CodeGraph (colbymchenry) — direct sister surface: same pattern (pre-indexed local code knowledge graph for multi-agent), different positioning (token-reduction vs. understanding). Treat as complementary, not duplicate.
  • QMD — architectural analog: same Tree-sitter-deterministic + LLM-semantic split applied to wiki markdown instead of code.
  • Karpathy Pattern — the wiki pattern this tool consumes via /understand-knowledge.
  • synthadoc — sister tool that generates a Karpathy-pattern wiki; Understand-Anything consumes one. Complementary pipeline endpoints.
  • Context Management in Claude Code — token-reduction framing aligns with the broader thesis that agents waste tokens on filesystem walks.
  • CLI vs MCP Tool Selection — 14-platform compatibility is a bet on shared infrastructure as the right abstraction.
  • Hermes Agent — named platform in the install matrix; install via install.sh hermes.
  • Karpathy-Inspired Claude Code Guidelines (multica-ai) — verified-real precedent for young-but-high-star repo in this cluster.

Open Questions

  • Does /understand-knowledge actually produce better coverage than this wiki’s existing graph view, or does it surface different edges? Worth a side-by-side comparison file-back.
  • Are the 14 named platform integrations all working today, or are some aspirational? Audit at least Claude Code + Codex + Hermes before citing the matrix.
  • How is persona-adaptive UI implemented — config, git-author detection, first-run prompt? README is fuzzy on the mechanism.
  • Does the article-analyzer 7th agent overlap with this wiki’s lint pass (orphan detection, missing concepts, cross-link gaps)? If yes, the lint pass could potentially adopt some of its prompts.
  • Star history shape unknown at ingest — is the 21.8k stars curve organic ramp or single-spike acquisition? Star-history.com link in README would resolve this; check before citing the count as a quality signal.

Graph View

Backlinks