Agent Quickstart

Onboarding for coding agents (Claude Code subagents, Claude Agent SDK agents, sub-process workers) dropped into a project that references this Compendium. Read once at session start; come back for the decision tree.

1. What this is

A personal reference library: 810 notes across 7 disciplines + System, locked 2026-05-25 as read-only with respect to other projects (other projects reference Compendium for facts and patterns; Compendium never reaches back into them). Tier 1 deep notes (foundational, ~500–1000 lines), Tier 2 specialty notes (~500–650 lines), Tier 3 family-index catalogs (encyclopedic, table-driven), _compare_* synthesis notes (cross-system axes), _learn_next recommendation graphs, Walkthroughs/design-* end-to-end project skeletons.

2. The map

d:\Vault\Compendium\
├── README.md
├── CHANGELOG.md
├── ACTIONS_REQUIRED.md
├── Sciences/
│   ├── Chemistry/        — organic, analytical, biochem, inorganic, physical, electrochem, polymer, materials, medicinal+photo
│   │   ├── _index.md
│   │   ├── _learn_next.md
│   │   ├── _compare_synthesis-strategies.md
│   │   ├── _compare_analytical-methods.md
│   │   ├── _compare_polymerization_methods.md
│   │   └── Tier3/        — family-index catalogs (every reaction class, every reagent, etc.)
│   ├── Biology/          — cell+mol, genetics, neuroscience, immunology, ecology+evol, microbio, structural, plant, marine, dev
│   ├── MaterialsScience/ — crystallography, characterization, electronic structure, mechanical, biomaterials, soft matter
│   └── ClimateScience/   — physical climate, carbon cycle, impacts, mitigation, ML for climate, paleoclimate, ocean biogeochem
├── Engineering-and-Robotics/
│   ├── Engineering/      — mech, EE, civil, chemical, thermal, fluid, aerospace, nuclear, marine, etc.
│   │   ├── _compare_control-strategies.md
│   │   ├── _compare_materials-selection-criteria.md   ← cross-discipline anchor (Engineering ↔ MaterialsScience)
│   │   ├── _learn_next.md
│   │   └── Tier3/
│   └── Robotics/         — kinematics, sensors, control, planning, SLAM, manipulation, mobility, safety
├── Math-and-Compute/
│   ├── Math/             — linear algebra, probability, calculus, ODE/PDE, optimization, info theory, RL, Lie groups
│   │   ├── _compare_optimization-methods.md
│   │   ├── _compare_probability-frameworks.md
│   │   └── _learn_next.md
│   ├── Compute/          — distributed systems, databases, OS, networking, ML/AI, security, observability
│   │   ├── _compare_consistency_models.md
│   │   ├── _compare_service-architectures.md
│   │   ├── _learn_next.md
│   │   ├── Claude/       — 17-note Claude ecosystem reference (models + API + Code CLI + hooks + subagents + skills + MCP + Agent SDK + ...)
│   │   └── Tier3/
│   └── Languages/        — 51 deep per-language notes + 6 cross-cutting comparisons + 85 Tier-3 family catalogs (~2,160 distinct languages)
│       ├── _compare_memory_models.md
│       ├── _compare_type_systems.md
│       ├── _compare_concurrency.md
│       ├── _compare_metaprogramming.md
│       ├── _compare_build_tools.md
│       └── _learn_next.md
├── Society/
│   ├── Economics/        — micro, macro, behavioral, game theory, dev, IO, labor, env, monetary, public+health
│   ├── Finance/          — corporate+markets, derivatives, investments, accounting, insurance, RE, ESG, structured
│   │   ├── _compare_pricing-models.md
│   │   ├── _compare_risk-measures.md
│   │   └── _learn_next.md
│   └── Law/              — contracts+IP, torts, criminal, constitutional, admin, civproc+evidence, employment+env, immigration+intl, securities+M&A
├── Arts-and-Energy/
│   ├── Music/            — theory, production, synthesis, live sound, sound design, ethno, performance practice, orchestration
│   └── EnergyMarkets/    — electricity, gas+oil, capacity+ancillary, carbon, transmission, RECs, demand response, LNG+weather derivs, biofuels
├── Humanities/
│   ├── Philosophy/       — metaphysics+ontology, epistemology, ethics, mind+language, philosophy of science, AI ethics
│   ├── History/          — ancient, medieval, early-modern, modern, historiography, WWII deep + dynasties catalog
│   ├── Linguistics/      — phonetics, syntax, semantics, historical/typology, sociolinguistics, formal semantics + language families catalog
│   ├── Anthropology/     — cultural, biological, archaeology + paleoanthropology+aDNA + hominin species catalog
│   └── ReligiousStudies/ — comparative, Abrahamic, Dharmic, East-Asian, indigenous+NRM, Islamic jurisprudence + sacred texts catalog
├── Walkthroughs/         — 45 end-to-end design walkthroughs (robotics, manufacturing, energy, transport, medical, fusion, biotech, civil, marine, aerospace certification, software)
├── System/               — operating manual + conventions + audits + memos + claude-config backups
├── scripts/              — build-site.ps1, rebuild-index.ps1
└── hooks/                — repo-local hook scripts

Every library has an _index.md at its root. Most active libraries have at least one _compare_* synthesis + one _learn_next recommendation graph.

Tag taxonomy (quoted from Conventions)

Every note carries exactly one library-canonical tag identifying which library it lives in:

Library	Canonical tag
Chemistry	chemistry-reference
Biology	biology-reference
MaterialsScience	materials-science-reference
ClimateScience	climate-reference
Engineering	engineering-reference
Robotics	robotics-reference
Math	math-reference
Compute	compute-reference
Languages	language-reference
Economics	economics-reference
Finance	finance-reference
Law	law-reference
EnergyMarkets	energy-markets-reference
Music	music-reference
Philosophy	philosophy-reference
History	history-reference
Linguistics	linguistics-reference
Anthropology	anthropology-reference
ReligiousStudies	religious-studies-reference
Walkthroughs	walkthroughs (no -reference suffix since walkthroughs aren’t a discipline)

Every note also carries tier1, tier2, or tier3 — plus family-index if it’s a T3 catalog, moc if it’s an index file. Topical tags (2–5) are added below the canonical for cross-cutting concepts.

A bare-library tag (e.g. finance instead of finance-reference) is the topical form — used when a note from one library references a domain. Example: a Compute note about LLM-based financial-analytics tools is tagged [compute-reference, t2, finance, llm] — the finance tag means “this Compute note is about finance,” not “this note lives in Finance.”

Outcome tags (universal): outcome:accomplished, outcome:failed, outcome:partial, outcome:superseded.

3. How to find the right note for a topic

Decision tree, ordered by query type:

Query shape	Where to go	Example
Concept-level: “what are the options for X?”	_compare_* synthesis notes at library root	”what consistency model should I pick?” → _compare_consistency_models
Foundational learning: “teach me the field”	Tier 1 deep notes (~500–1000 lines each) — start from the library’s _index.md	”I need to learn distributed systems” → _index → distributed-systems-fundamentals
Specialty deepening: “go deeper on technique Y”	Tier 2 notes (~500–650 lines each)	“how does Raft actually handle leader leases?” → consensus-protocols
Encyclopedic lookup: “list every variant of Z”	Tier 3 family-index catalogs (table-driven) under <Library>/Tier3/_index.md	”every database engine ever shipped” → _index
Practical recipe: end-to-end project	Walkthroughs/design-*.md (12-section skeleton: spec → components → sizing → controls → safety → manufacturing → cost)	“build an LLM training cluster” → design-llm-training-cluster
Recommendation: “what should I learn next?”	_learn_next.md per library	”I know Python, what next?” → _learn_next
Vendor-specific tooling (currently Anthropic only)	<Library>/<Vendor>/ sub-libraries	”what does the Claude prompt-caching beta header do?” → prompt-caching
Cross-library jumps	Each library’s _index.md has an “Adjacent libraries” / “See also” block	Compute → Math (RL, optimization), Compute → Languages (runtimes), Robotics → Engineering (kinematics)

If you don’t know which library a topic belongs to, start with semantic search (Section 4). It cuts across all 810 notes.

4. Semantic search

# Hybrid (default — full-text + semantic via reciprocal-rank fusion). Use this.
node ~/.claude/bin/obsidian-research.mjs query "your question" --hybrid --k 8
 
# Restrict to Compendium only (skip the private vault):
node ~/.claude/bin/obsidian-research.mjs query "your question" --hybrid --k 8 --compendium-only
 
# Restrict to a library by canonical tag:
node ~/.claude/bin/obsidian-research.mjs query "your question" --hybrid --k 8 --tags "compute-reference"
 
# Pure semantic (concept matching, ignores exact keywords):
node ~/.claude/bin/obsidian-research.mjs query "your question" --semantic --k 8
 
# Pure full-text (fast, exact-token match):
node ~/.claude/bin/obsidian-research.mjs query "your question"

The local embedding index lives at ~/.claude/compendium-index.json (~127–155 MB), covers all 810 notes, and rebuilds nightly via a scheduled task. After a batch of saves, refresh it incrementally with node ~/.claude/bin/obsidian-research.mjs index.

Default to --hybrid — it catches concept matches that keyword alone misses and keyword matches that semantic alone misses.

5. Highest-leverage entry points per discipline

Two to three starting notes per library that give the most surface coverage. Use these to bootstrap; follow the wikilinks from there.

Sciences

• _compare_synthesis-strategies — total-synthesis vs retrosynthesis vs convergent vs divergent vs flow chemistry
• _compare_analytical-methods — NMR / MS / IR / X-ray / chromatography decision matrix
• _index — cell+mol, genetics, neuro, immuno, ecology, structural, dev
• _compare_materials-selection-criteria — cross-discipline anchor that pairs Engineering need-cases (load, fatigue, corrosion, temp) with MaterialsScience options (alloys, polymers, composites, ceramics)
• _index — crystallography, characterization, electronic structure, mechanical, biomaterials, soft matter
• _index — physical climate, carbon cycle, impacts, mitigation, ML for climate, paleo, ocean biogeochem

Engineering + Robotics

• _compare_control-strategies — PID vs LQR vs MPC vs adaptive vs robust vs feedforward
• _compare_materials-selection-criteria — load × environment → material class
• _learn_next — recommended next sub-discipline based on what you already know
• _index — full robotics surface (kinematics → sensors → control → planning → SLAM → manipulation → mobility → safety)

Math + Compute

• _compare_optimization-methods — gradient / Newton / conjugate / interior-point / evolutionary / Bayesian decision tree
• _compare_probability-frameworks — frequentist vs Bayesian vs measure-theoretic vs information-theoretic
• _learn_next — depth-shift vs lateral recommendations
• _compare_consistency_models — linearizable → eventual hierarchy with real-system mapping
• _compare_service-architectures — monolith / microservices / SOA / event-driven / serverless / cell-based
• _index — Claude ecosystem reference; most relevant when building an agent ON Claude (see Section 6)
• _compare_memory_models — manual / RAII / GC / region / linear-types / reference-counting
• _compare_type_systems — nominal / structural / row-poly / dependent / refinement / gradual
• _compare_concurrency — threads / async / actors / CSP / STM / data-parallel
• _compare_metaprogramming — macros / reflection / staging / mixins / generics
• _compare_build_tools — cargo / npm / pip / maven / bazel / gradle / nix
• _learn_next — cross-language depth-shift recommendation graph

Society

• _index — micro, macro, behavioral, game theory, dev, IO, labor, env, monetary, public+health
• _compare_pricing-models — Black-Scholes / binomial / Monte Carlo / Heston / SABR / Bachelier / FX-skew
• _compare_risk-measures — VaR / CVaR / Expected Shortfall / coherent vs convex risk
• _learn_next — recommended Finance progression
• _index — contracts+IP, torts, criminal, constitutional, admin, civproc, employment+env, immigration+intl, securities+M&A

Arts + Energy

• _index — theory, production, synthesis, live sound, sound design, orchestration
• _index — electricity, gas+oil, capacity, carbon, transmission, RECs, demand response, LNG+weather derivs, biofuels

Humanities

• _index — metaphysics + ontology, epistemology, ethics, mind + language, phil sci, AI ethics
• _index — ancient → modern + historiography + WWII deep + dynasties catalog
• _index — phonetics, syntax, semantics, historical/typology, sociolinguistics + language families catalog
• _index — cultural, biological, archaeology + hominin species catalog
• _index — comparative, Abrahamic, Dharmic, East-Asian, indigenous+NRM + sacred texts catalog

Walkthroughs

• _index — 45 end-to-end design walkthroughs, grouped by category (robotics, manufacturing, biotech, civil, marine, energy, transport, medical, fusion, software, regulated processes, aerospace certification)
• Each walkthrough exercises multiple libraries end-to-end: spec → component selection → sizing math → controls → manufacturing → cost build-up, wikilinking back to Tier 1/2/3 notes at every decision.

6. Special attention: the Claude sub-library

For agents being built ON Claude (Claude Code subagents, Claude Agent SDK programs, MCP servers), the Math-and-Compute/Compute/Claude/ sub-library is the canonical reference. 17 files total (1 index + 16 deep notes), version-pinned to 2026-05-25 source pulls from docs.claude.com, platform.claude.com, code.claude.com, modelcontextprotocol.io, and github.com/anthropics/*. Inventory below quoted from _index:

Foundations

File	What it covers
claude-models-and-capabilities	Opus 4.7 / Sonnet 4.6 / Haiku 4.5 + legacy generations, pricing, context windows, knowledge cutoffs, benchmarks, model-selection heuristics
claude-api-and-sdks	The Messages API surface (parameters, response shapes, streaming, errors, rate limits) + Python / TypeScript / Go / Java / C# / PHP / Ruby SDKs
prompt-engineering-for-claude	Claude-specific prompting (XML tags, prefill, role priming, model-version idiosyncrasies, agentic prompting)
prompt-caching	5-minute and 1-hour ephemeral caches, breakpoint placement, cost math, multi-turn caching strategy

Tool use & multimodal

File	What it covers
tool-use-and-function-calling	Client-defined tools (tool_use / tool_result), parallel tool use, strict mode, fine-grained tool streaming, server tools overview
vision-and-multimodal	Image input (base64, URL, Files API), PDF input, document blocks, token costs, sizing rules, format support
computer-use-and-code-execution	The four Anthropic-managed tools that make Claude agentic: computer_*, code_execution_*, bash_20250124, text_editor_*, plus memory_20250818 and web_search_* and web_fetch_*
batch-api-and-files-api	Message Batches (asynchronous, ≤24 h, 50% discount) + Files API (upload, download, reference by file_id)
citations-and-grounding	Native citation blocks, document chunking, char_location / page_location / content_block_location, RAG integration

Claude Code

File	What it covers
claude-code-cli	The claude binary — install paths, flags, subcommands, settings.json, environment variables, permission modes, statusline, login
claude-code-hooks-deep	Every hook event, matcher syntax, command vs HTTP vs MCP-tool vs prompt vs agent handlers, exit-code semantics, JSON output schema, safety floor
claude-code-subagents-and-skills	Subagents (.claude/agents/*.md), the Task / Agent tool, Skills (SKILL.md), bundled vs user-created skills, hierarchy, disable-model-invocation, dynamic !backtick“

Beyond the CLI

File	What it covers
mcp-protocol	The Model Context Protocol spec: JSON-RPC base, lifecycle, capabilities, tools / resources / prompts primitives, transports (stdio, HTTP, SSE, streamable HTTP), auth, SDK survey
claude-agent-sdk	claude-agent-sdk (Python + TS) — query, ClaudeSDKClient, ClaudeAgentOptions, setting_sources, mcp_servers, agents map, hooks, message types
agents-and-orchestration-patterns	Multi-agent orchestration (supervisor-worker, swarm, ReAct, Plan-and-Solve), handoff protocols, Anthropic’s own published guidance
hidden-tricks-and-gotchas	Undocumented flags, environment-variable escape hatches, prompt-caching breakpoint tricks, tool-use parallelism quirks, vision token accounting, MCP buffering, model-specific quirks

Typical lookup paths

1. Picking a model → claude-models-and-capabilities → prompt-caching → tool-use-and-function-calling (if you need tools).
2. Debugging a Claude Code session → claude-code-cli (flags) → claude-code-hooks-deep (hook lifecycle) → hidden-tricks-and-gotchas (env-var overrides).
3. Building an MCP server → mcp-protocol → claude-code-cli (how Claude Code consumes it) → claude-agent-sdk (if embedding an agent).
4. Multi-agent system → agents-and-orchestration-patterns → claude-code-subagents-and-skills (in-process) → claude-agent-sdk (cross-process).
5. Cost optimization → prompt-caching + batch-api-and-files-api + pricing tables in claude-models-and-capabilities.
6. RAG / grounded responses → citations-and-grounding + vision-and-multimodal (for PDF document blocks).

7. Citation back-pattern

When you use Compendium info in any artifact you produce — code comments, design docs, PR descriptions, agent saves to the private vault — cite the source note. This makes claims auditable and lets the user (or another agent) verify against an authoritative source.

Format:

(per [[Compendium/<Library>/<note-slug>]])

Examples:

• # Using 1-hour cache TTL for the system prompt (per [[Math-and-Compute/Compute/Claude/prompt-caching]])
• Selected Raft over Paxos for the leader-election layer (per [[Math-and-Compute/Compute/consensus-protocols]] and [[Math-and-Compute/Compute/_compare_consistency_models]]).
• Material choice: 6061-T6 aluminum for the chassis (per [[Engineering-and-Robotics/Engineering/_compare_materials-selection-criteria]]).

If the claim is time-sensitive (pricing, version numbers, beta-flag names), re-verify against the authoritative source before citing — the note is a time-stamped claim, not ground truth (see Section 8).

8. What this library is NOT

• Not a code repository. No executable code lives here; example snippets are illustrative. Working code lives in d:\Projects\<project>\ repos.
• Not a session log. Per-session captures, decision logs, and project-specific notes live in the private vault at d:\Vault\AI Vault\Research\Sessions\ and d:\Vault\AI Vault\Research\Topics\.
• Not authoritative on time-sensitive info. Notes are time-stamped claims. Always verify version numbers, pricing, beta-flag names, API shapes, and regulatory dates against the authoritative source (docs.claude.com, platform.claude.com, vendor docs, current regs) before acting.
• Not a substitute for code, comments, or commit messages. Those are authoritative for what changed. Compendium is for what’s known about the domain, what trade-offs apply, what’s been published.
• Not a memory store. The persistent agent-memory layer is Obsidian (private vault) per agents-learning-protocol. Compendium is a curated reference; the vault is the lessons-learned log.

9. The read-only rule

Quoted verbatim from Conventions:

Rule (2026-05-25). The Compendium is a reference library, not an operator. Agents working inside Compendium may:

• Read from anywhere on the machine (vault, project repos, runtime config) for context, learning, and synthesis;
• Write only inside d:\Vault\Compendium\ itself.

Agents working inside Compendium may not:

• Modify files in d:\Projects\<any-project>\ (Suits, TaxProfessional, IncomeProject, and any future project) without that project’s own agent expressly approving the change;
• Run git commit / git push in any other project’s repo;
• Trigger deploys, scheduled tasks, or background processes that affect any other project.

Why. The Compendium is intentionally a one-way knowledge dependency: other projects reference Compendium for facts and patterns; Compendium never reaches back into them. This keeps the Compendium safe to grow without coordinating with every consuming project, and it keeps each project’s history/state under its own agent’s control.

Exception — private vault. The user’s vault at d:\Vault\AI Vault\ is treated as user-personal storage, not a “project” in the project-agent sense. Compendium agents may write to the vault (e.g., save lesson notes per agents-learning-protocol) without triggering this rule.

If you find yourself wanting to write outside d:\Vault\Compendium\ and outside the private vault: stop. Route the task to that project’s own agent, or leave a “needs cross-project review” note and let the user dispatch it.

10. Authoritative entry points

• README — root overview, status, count, structure
• CHANGELOG — commit-by-commit history of what’s been added/restructured
• Conventions — house style + tag taxonomy + the read-only rule
• agents-learning-protocol — the five-step query → adapt → save → log → re-index loop every agent follows
• AGENTS — operating manual (sister doc to this one; oriented to the private-vault research layer)
• ACTIONS_REQUIRED — user-only items (dashboard work, deploys, cross-project decisions that need a human in the loop)