Research that compounds
into an edge.
Laniakea Brain is a research system built on Claude Code and Obsidian. It gives an investment team persistent, compounding memory across every position — so conviction, contradictions, and catalysts stay current instead of being re-derived from scratch every session. Compilation, not retrieval. We install it on your stack, and we run it on our own book.
Compilation, not retrieval.
Most "AI for research" is retrieval — RAG: you upload sources, the model fetches relevant chunks at query time and generates an answer. Every query rediscovers the same knowledge from scratch, and nothing compounds. Laniakea Brain inverts that. It's a disciplined application of the LLM Wiki pattern Andrej Karpathy formalized in April 2026: instead of re-answering, the model incrementally compiles raw sources into a persistent, interlinked wiki that gets richer with every source you add.
The promise is compounding knowledge: the cross-references are already there. The contradictions have already been flagged. The synthesis already reflects everything you've read. Investment research is exactly the kind of work that benefits — qualitative, multi-year, with ideas that need to be revisited as new evidence arrives.
Raw sources · Wiki · Schema.
Karpathy's architecture has three layers. Each maps directly to this vault's investment-research instantiation:
/Research/ (provenance)
Karpathy: "Your curated collection of source documents. Articles, papers, images, data files. These are immutable — the LLM reads from them but never modifies them."
Here: earnings transcripts, sell-side research, expert calls, regulatory filings, substack pieces. Drop them into _Inbox/, the /ingest skill processes them, the originals move to _Inbox/processed/. The source: URL gets locked into frontmatter and is never edited. Provenance has to be auditable for an investment decision you'll defend months later.
/Research/ (summaries)
/Sectors/
/Macro/
Karpathy: "A directory of LLM-generated markdown files. Summaries, entity pages, concept pages, comparisons, an overview, a synthesis. The LLM owns this layer entirely. You read it; the LLM writes it."
Here: the wiki is structured for equity research specifically. Each ticker has a 14-section thesis. Each source becomes a 4-section research note. Each sector has an 11-section overview that links every active position in it. Macro frameworks live in their own folder. The LLM maintains all of it — you curate sources and ask questions; the cross-references, summaries, and Log entries take care of themselves.
/Templates/
/.claude/skills/
Karpathy: "A document (e.g. CLAUDE.md for Claude Code) that tells the LLM how the wiki is structured, what the conventions are, and what workflows to follow. This is the key configuration file — it's what makes the LLM a disciplined wiki maintainer rather than a generic chatbot."
Here: CLAUDE.md defines the writing standards (no hedge words, lead with the insight, tables over prose), the safety tiers, and the file conventions. Templates/ holds the skeletons that force structure on every thesis, research note, and sector. .claude/skills/ contains 21 deterministic workflow specifications. Together these are the operating contract — they convert Claude from a chatbot into a disciplined research analyst with house style.
Karpathy's metaphor: "Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase." That mental model is the right one here too. You're the product manager — you decide what to build, what questions to ask, what sources to add. Claude is the engineer doing the actual maintenance.
Six properties that distinguish this from RAG, chat, or a notes app.
These are the load-bearing design decisions inherited from the LLM Wiki pattern and adapted for investment work. The rest of this guide explains how each one is implemented.
source: URL in frontmatter is locked at creation and never modified. Months later, when defending an investment decision, the audit trail holds up.
CLAUDE.md + Templates + skill specs are loaded into every session. Writing standards stay enforced. The 14-section thesis structure stays enforced. House style stays consistent across hundreds of notes written over years.
/ingest compiles new sources into the wiki. Manual prompts query it. /lint periodically audits health — orphans, staleness, contradictions, missing cross-references. The vault adds two finance-specific operations on top: conviction tracking via /sync and /status, and retrospective review via /retro.
## Log section — never edited, only appended. Karpathy's log.md is per-vault; this implementation runs it per-thesis, so every position has its own evolution history. /retro reads these logs to surface where your thinking diverged from price.
The specific problems an LLM Wiki solves better than a notes app.
The generic Karpathy framing covers any long-running knowledge work. Investment research has three specific failure modes that the wiki pattern resolves in a way no spreadsheet, Notion page, or chat interface can.
Conviction drift goes undetected
Without a log, you don't notice that you've quietly downgraded a name three times in two months. The wiki's append-only Log per thesis makes drift mechanical — /sync flags it: "4 of your last 5 updates on this name pushed back on the Bull Case. Conviction is drifting whether you've noticed or not."
Cross-thesis blind spots stay invisible
At 40 positions, you can't hold the whole portfolio in your head. The wiki makes synthesis possible at the portfolio level: "Which of my bull cases share an implicit macro dependency?" · "Scan for places one note's bull case depends on what another note's bear case challenges." These prompts only work when the wiki exists.
Hindsight has no anchor
Three months after a trade you can't remember what your written conviction was when you put it on. The wiki preserves it. The retro engine reads those preserved positions against actual market reaction since — and surfaces the names where narrative and price diverged most. Lessons learned become structural, not aspirational.
The rest of this guide is how the pattern is implemented in practice. The pillars below preview the chapters.
Three engines that turn a maintained wiki into investment alpha.
A static knowledge base is interesting. A knowledge base whose evolution gets actively interrogated against market reality is a research process. Three mechanisms do that interrogation.
The retro engine — narrative-price gap detection
Once a week, /retro 1w reads every Log entry, callout, and conviction shift from the past 7 days, overlays it against actual price moves and news flow, and classifies each ticker into a 3×2 grid: aligned (already priced), inverted (positioning signal — strongest single signal, weighted 1.5×), or unreactive (catalyst dismissed or bear case ignored, weighted 2×). The output is a ranked list of trade ideas — alpha harvest candidates, missed signals, stress-test candidates. The retro never auto-changes conviction; it tells you which names deserve the next round of attention.
Cross-thesis synthesis — portfolio-level pattern detection
Once you have 20+ theses, Claude can do things no spreadsheet can: scan for internal contradictions ("places one note's bull case depends on what another's bear case challenges"), surface hidden macro concentration ("which bull cases share an implicit dependency on AI capex, rates, or China decoupling?"), audit stale assumptions ("for my 10 oldest theses, is the Key Non-consensus Insights section still non-consensus today?"). About 40 of these prompts ship with the system. Each one is structurally impossible without the wiki.
Adversarial stress test — pre-mortems on demand
/stress-test TICKER reads your thesis as a hostile short-seller and writes from that perspective — attacking the Bull Case, identifying break-the-thesis paths, surfacing risks you've been comfortable ignoring. It does not change conviction; it produces the material you'd otherwise avoid generating yourself. Pair with the new-position-build chain (§8) to pressure-test every thesis before promotion to active.
Pointed at your own book, these engines surface the divergences only your vault can see — the names where your thinking and the market have come apart. That is where the trades are.
How the vault keeps Claude aware of your ongoing work.
Large language models are amnesiacs by default. Every new conversation starts from scratch. This vault solves that by storing the agent's "memory" as plain Markdown files that Claude reads at the start of every session — and writes back to as it works.
This is what people in the AI engineering community now call context engineering — the practice of structuring an LLM's working environment so it behaves as if it has long-term memory and durable behavior. The vault does this with six files. Three of them are the most important; click any card to inspect.
/sync know which 3-5 thesis files matter when a new research note lands, without re-reading all 40. The skill that owns this file (/graph) keeps it incrementally updated./catalyst. Aggregates earnings dates, regulatory milestones, scheduled product launches across all positions. Answers "what is coming up?" without scanning every thesis individually.find -newer .last_sync returns only changed files, so syncs run in ~30 seconds instead of reading the whole vault every time./rollback restores any of them. Closure snapshots get 30-day protection. The reason aggressive automation feels safe: mistakes cost a snapshot, not real data.The vault as a layered system.
§3 named the six files Claude reads on every session. This is what they look like as a system — how they relate, who writes them, who consumes them, and where data flows when a skill runs. Click any node to see its role, ownership, and the contract it enforces.
Deeper architectural reference — per-skill lock scope, manifest contracts, the 12 critical invariants, and runtime markers — ships with the installed system.
How the vault enforces good research habits.
Context engineering tells Claude what state to keep in mind. Templates and writing standards tell Claude how the output has to look. Together they make hundreds of notes written over years feel like they came from the same disciplined analyst.
Templates: skeletons that enforce structure
The Templates/ folder contains one Markdown file per note type — thesis, research, sector, macro. Every time you run /thesis TICKER or /ingest [URL], the relevant template is used as the starting skeleton. The structure is rigid by design: sections you'd skip on a bad day get filled in regardless.
A look at the four required sections of every research note:
The "Thesis Delta first" rule matters. Every read opens with what changed for an existing thesis — not a business description. Without this rule, research notes end up restating the company every time and burying the insight. Same goes for "Contradiction Check": forcing yourself to write what an article contradicts is what kills confirmation bias.
Writing standards in CLAUDE.md
These rules ship as part of the system prompt. Claude follows them on every output — every section it writes, every Log entry, every research note summary.
[source/trigger]: [what changed] — [conviction impact: unchanged/strengthened/weakened + 1 reason]. Anything longer is moved to the body section.
Editing these rules in CLAUDE.md doesn't just affect one chat — it changes how every future skill run and every future manual prompt behaves. The behavior is configurable without retraining.
Fourteen sections, each one doing a job.
Most research notes are unstructured prose. That's fine for personal scribbling but terrible for analysis you'll need to defend in six months. Each section here exists because skipping it is exactly how analysts get blindsided.
Browse the synthetic ACME thesis below. The Sector tab shows the parallel 11-section structure that overlays the thesis layer. Expand any section to see what work that section forces you to do.
The verbs Claude can run on the vault.
Skills are how you actually do work in the vault. Every command you type — /sync, /stress-test, /retro — invokes one. They are the moving parts that turn the static notes into a working system.
What a skill is
A skill is a plain Markdown file at .claude/skills/<name>/SKILL.md that tells Claude exactly what to do, step by step. It is not a prompt — prompts are improvisational. A skill is a specification: pre-flight checks, the procedure, exit conditions. Claude follows it literally.
Three things follow from this design:
- Same input, same output. A skill behaves the same way regardless of model temperature or how the conversation went before. This is what makes the system reliable for actual investment decisions instead of being a fancy chat toy.
- The specification is the source of truth. If a skill misbehaves, you edit the SKILL.md file. There's no opaque model state to debug.
- You can read the spec. Every skill is plain text. If you want to know why
/syncpropagates conviction changes the way it does, you open its SKILL.md and read.
The 21 skills, four families
Each family corresponds to a different role: Core moves information through the vault, Analytical generates insight, Building creates or extends theses, Maintenance keeps the substrate healthy.
● Core (4)
◆ Analytical (7)
▲ Building (4)
◐ Maintenance (6)
Full reference — arguments, side effects, and follow-up chains for every skill — is included in the delivered system.
What working with the vault actually looks like.
No big ceremony. You open Obsidian, type a command, and a few seconds later you have structured output. Here are the two routines that account for most of the use: a morning ingest run and a Friday-evening retro.
Six chains that cover most of what you'll ever do.
§7 catalogued the 21 skills individually. Real work is rarely a single skill — it's a chain of them. The map below shows the six most common chains, all overlaid on the same skill graph. Click any tab to highlight that chain; the sequence appears at the bottom.
The full chain index — optional branches, failure-mode footnotes, ~30 less-common scenarios, and an "I want to ___" intent map — comes with the installed system.
A way to push back without losing the exchange.
When Claude writes something you don't agree with, you don't argue in chat — you drop a callout right next to the suspect sentence. Later, ask Claude to address fresh callouts and the back-and-forth becomes a permanent record inside the thesis.
Four types, each with its own hotkey: [!question] (Mod+Alt+1, ask), [!error] (Mod+Alt+2, flag), [!tip] (Mod+Alt+3, suggest), [!todo] (Mod+Alt+4, action). Use the right type and the system can later tell you "you've raised four [!error] callouts on this name in the past month — your conviction is drifting whether you've noticed or not." The full callout specification ships with the system.
1. Drop a callout
Hit Mod+Alt+1 to ask a question, 2 to flag an error, 3 for a tip, 4 for a todo. The callout lands right next to the line that bothered you.
2. Ask Claude to address it
"Address fresh callouts in [[Theses/ACME]]." Claude rewrites the body where needed and leaves a Prompt/Response audit block in place of the original callout.
3. Pin the ones worth revisiting
Add [[pinned]] to mark a callout as something to re-address whenever new data lands — a competitor announcement to watch, a quarterly question to keep asking.
4. The audit trail compounds
Six months later, you can see exactly which arguments you pushed back on, what Claude wrote in response, and how your conviction evolved as the evidence came in.
What running a skill actually looks like.
Each of these is a canned trace — the same kind of output a real session produces on this synthetic ACME thesis. Pick a skill and watch the deterministic output stream past.
# All output is canned and deterministic — same skill, same trace.
# No API calls. No live data. Fictional ACME — Acme Robotics.
Questions you'd ask if a friend pitched this to you.
Isn't this just RAG with extra steps?
No. RAG is retrieval-augmented generation against a static index. The vault is a stateful, structured, mutually-aware set of notes that Claude both reads and writes through deterministic workflows.
RAG retrieves passages to inform a single response. The vault is the agent's working memory — its content gets mutated continuously by skills like /sync and /graph as part of the operating loop. RAG retrieves; this system retrieves, edits, propagates, snapshots, and audits.
How is this different from just using ChatGPT?
ChatGPT has no persistent memory of your portfolio. Every conversation starts from zero. You re-paste the transcript, re-explain the company, re-summarise your context — the expensive work of building up forty positions over two years never accumulates because nothing persists.
This vault is the opposite. Claude wakes up every session already knowing your forty theses, your most recent conviction shifts, every callout you've ever dropped, every contradiction you've already spotted (§3). You stop being a context-provider and start being an analyst with a research team that doesn't forget.
Do I need to be a programmer?
No. We install and configure everything — Obsidian, Claude Code, the vault, and all 21 skills (§6) tailored to your process. Day one, you're calling skills, not setting them up.
You will, however, have to be the kind of person who's comfortable typing /sync ACME instead of clicking a menu. If you live in spreadsheets, you'll be fine.
Won't Claude just hallucinate things into my thesis?
It can — treat every section it writes as a first draft, not as gospel. The system mitigates this in three ways. First, the source URL is recorded in frontmatter and cannot be edited later — you can always trace a claim back to its source. Second, inline callouts (§9) let you push back on individual sentences with a permanent record of the disagreement. Third, /stress-test exists precisely to surface holes in the thesis from an adversarial perspective.
None of this makes Claude a reliable analyst by itself. It makes Claude a structured research assistant whose mistakes are auditable and reversible. You're still the analyst.
What stops the LLM from going off-script and breaking the vault?
Five layers. CLAUDE.md as system prompt sets the conventions. Each skill is a step-by-step specification, not a free-form prompt. Tier-3 confirmations gate investment-grade changes (conviction shifts, status transitions, file deletions). Every destructive operation snapshots before editing. /lint audits schema drift across the vault.
Claude can still hallucinate the contents of a note — that's a separate problem solved by reading-before-writing and provenance immutability. But it cannot, by construction, silently violate the architectural rules.
How long until the vault starts being useful?
The first thesis you write is already more valuable to you than ten random research notes. The compound effect kicks in around thesis number five or six — the first time /surface finds cross-thesis patterns you couldn't see yourself, and the first time /retro has enough conviction shifts to rank trade ideas by narrative-price gap.
Most users feel the system click after a month of regular use. Before that, it's experienced as structured note-taking. After that, you start noticing the vault catching things you would have missed.
Is this only for stocks?
The investment-research version is one instantiation, but the patterns — context engineering, deterministic skills, append-only audit logs, snapshot-based rollback — generalise to any LLM-augmented knowledge work. Legal research, scientific literature review, software architecture documentation, investigative journalism. Same primitives, different note templates and skill specs.
Have us install it on your stack.
Laniakea Brain is what we run at Laniakea Partners, and what we build for other funds. Start with a paid Strategy Sprint: we map your research workflow, find the highest-ROI interventions, and hand you a roadmap. From there we install the system end-to-end — or take on the broader AI advisory around it.
The handful of terms used throughout.
- Thesis
- The 14-section investment case for one ticker. Lives in
Theses/. - Research note
- A structured note about one source — transcript, article, stress test. Four required sections. Lives in
Research/. - Sector note
- An 11-section overview of one sector that links every active thesis in it. Lives in
Sectors/. - Skill
- A Markdown spec at
.claude/skills/<name>/SKILL.mdthat tells Claude exactly what to do, step by step. Same command, same output. - Context engineering
- The discipline of structuring an LLM's working environment so it behaves as if it has memory and durable behavior. The vault does this with six files (see §3).
- Frontmatter
- YAML metadata block at the top of a Markdown file. Defines status, conviction, sector, ticker, source.
- Wikilink
[[note-name]]syntax for cross-references inside the vault. Lets Claude traverse the graph of related notes.- Conviction
- Your stated confidence in a thesis: high, medium, or low. Changes are Tier-3 and require explicit confirmation.
- Callout
- An inline comment block dropped next to LLM output to push back on it, ask a question, or flag a todo.
- Non-consensus insight
- A view the market hasn't priced in. The thesis structure forces you to articulate one — it's where alpha actually lives.
- Narrative-price gap
- The distance between what your vault says about a name and what the market did with the price. The retro engine ranks trade ideas by this gap.
- Snapshot
- A backup copy of a note taken automatically before any destructive change. Lets you undo any skill that goes wrong.
- Subagent
- A child Claude instance spawned for an isolated subtask (used by
/lint,/prune,/surface,/retro). Returns a summary; its read cost stays out of the main conversation. - Watermark
- The modification time of
.last_sync. Lets skills find only the files that changed since the last operation.