# GeorgOS framework guide

> How to drive the AI-OS: layers, skills, subagents, planners, pipeline, memory, and the tooling underneath.

Two corpora. The walkthrough is 23 notes in 5 bands, on the method: how to build an AI-OS of this shape. The reference is 113 entries in 9 sections, on this instance: the layers, skills, agents, planners and tool docs GeorgOS runs today. Every link below is a markdown file. The whole text is at https://georgos.it/llms-full.txt.

## Start

- [Index](https://georgos.it/llm/note/index.md): What GeorgOS is for, the map of its parts, and the sources that the guide uses.

## Hardware

- [The model](https://georgos.it/llm/note/model.md): The model executes every instruction, and the system keeps the model replaceable.
- [MCP servers](https://georgos.it/llm/note/mcp-servers.md): An MCP server is the driver that connects the model to one outside system.

## Kernel

- [The root router](https://georgos.it/llm/note/root-router.md): The root router decides what a session loads, and the router loads the narrowest layer only.
- [L0 rules](https://georgos.it/llm/note/l0-rules.md): The L0 rules are the policy that every session loads, one topic in each file.
- [Hooks](https://georgos.it/llm/note/hooks.md): A hook intercepts an event of the harness and runs a script before the action lands.
- [Guards](https://georgos.it/llm/note/guards.md): A guard bounds what a session may touch, and the guard works when the permission prompts do not.
- [The execution rule](https://georgos.it/llm/note/execution-rule.md): The execution rule picks the cheapest mechanism that runs a task at the needed precision.
- [Skills](https://georgos.it/llm/note/skills.md): A skill is a named system service, and the dispatch index is the table that lists each skill.

## Processes

- [Sessions and subagents](https://georgos.it/llm/note/sessions-and-subagents.md): A session is a process, and a fork or a subagent isolates work from the context of the session.
- [The session registry](https://georgos.it/llm/note/session-registry.md): The session registry tells each new session which other sessions work in the same repository.
- [SendMessage](https://georgos.it/llm/note/send-message.md): SendMessage carries a message between two sessions, and a message never carries authority.
- [The session board](https://georgos.it/llm/note/session-board.md): The session board keeps one file for each open thread, so a session can end at any moment at no cost.
- [The context window](https://georgos.it/llm/note/context-window.md): The context window is the working memory of one session, and every design rule of the system protects it.

## Memory and storage

- [Auto memory](https://georgos.it/llm/note/auto-memory.md): Auto memory is a small cache, and every entry in the cache names the disk address of its fact.
- [The vault and the git log](https://georgos.it/llm/note/vault-and-git-log.md): The vault, the code graphs, and the git log are the disk, and each one answers a different question.
- [Regions](https://georgos.it/llm/note/regions.md): A region is an independent part of the vault, and one file at the root of the region declares its layout.
- [Ingest](https://georgos.it/llm/note/ingest.md): Ingest is the write path of the vault, and one ingest turns a source into linked pages.
- [Query](https://georgos.it/llm/note/query.md): Query is the read path of the vault, and query climbs a retrieval ladder from the cheapest tier.
- [Lint and audit](https://georgos.it/llm/note/lint-and-audit.md): Lint checks the integrity of a region, and the audit checks the integrity of the machinery.
- [graphify-out](https://georgos.it/llm/note/graphify-out.md): The graphify-out folder holds a structural graph of the code of one project, and planners read the graph.

## User space

- [GiorgIA](https://georgos.it/llm/note/giorgia.md): GiorgIA is the personal region of the author, and no system task reads it.
- [Projects and planners](https://georgos.it/llm/note/projects-and-planners.md): A project is an application that runs on the system, and a planner is the workflow that drives the project.
- [The guide and core](https://georgos.it/llm/note/guide-and-core.md): The core folder documents the system for the system, and the guide renders the same sources for a reader.

## Build order

The parts at steps 1 to 11 are core, and every build needs them. Each part at a later step is conditional, and the part enters the build when its need recurs.

1. [The model](https://georgos.it/llm/note/model.md): core. Every build needs a model to execute the instructions that a session loads.
2. [The root router](https://georgos.it/llm/note/root-router.md): core. Every build needs a router, so that each task loads its own files and no other file.
3. [L0 rules](https://georgos.it/llm/note/l0-rules.md): core. Every build needs always-on rules, so that one policy holds in every session.
4. [The vault and the git log](https://georgos.it/llm/note/vault-and-git-log.md): core. Every build needs one permanent store with a history, so that knowledge outlives each session.
5. [Skills](https://georgos.it/llm/note/skills.md): core. Every build needs skills, because ingest, query and lint are procedures that repeat and must run the same way each time.
6. [Regions](https://georgos.it/llm/note/regions.md): core. Every build needs at least one region declaration, because each knowledge base skill reads the layout before the first write.
7. [Hooks](https://georgos.it/llm/note/hooks.md): core. Every build needs hooks, because a rule in a rule file is a request to the model. A guard needs a hook to enforce a boundary.
8. [Guards](https://georgos.it/llm/note/guards.md): core. Every build needs at least one guard, because ingest treats the source folder as immutable, and a guard denies each write into that folder.
9. [Ingest](https://georgos.it/llm/note/ingest.md): core. Every build needs ingest, because each source must become linked pages that later questions read.
10. [Query](https://georgos.it/llm/note/query.md): core. Every build needs query, because query must answer each question from the compiled pages at the lowest cost.
11. [Lint and audit](https://georgos.it/llm/note/lint-and-audit.md): core. Every build needs lint after each ingest. The audit enters when a change to the rules, the hooks or the skills leaves a claim that no check reads.
12. [The context window](https://georgos.it/llm/note/context-window.md): conditional. The always-on text, or a large read that the harness resends, takes enough of the context window to crowd the task.
13. [The session board](https://georgos.it/llm/note/session-board.md): conditional. A thread spans more than one session, and a context reset loses the state of the thread.
14. [Auto memory](https://georgos.it/llm/note/auto-memory.md): conditional. The harness keeps an auto memory, and the entries drift from the files that hold the facts.
15. [Sessions and subagents](https://georgos.it/llm/note/sessions-and-subagents.md): conditional. A role repeats across tasks, or a large read would flood the context of the session.
16. [The execution rule](https://georgos.it/llm/note/execution-rule.md): conditional. More than one execution mechanism is in use, and each task needs a rule that picks the cheapest mechanism.
17. [MCP servers](https://georgos.it/llm/note/mcp-servers.md): conditional. A task needs an outside system, such as a browser or a document store.
18. [graphify-out](https://georgos.it/llm/note/graphify-out.md): conditional. A code base is too large for a session to read whole.
19. [Projects and planners](https://georgos.it/llm/note/projects-and-planners.md): conditional. More than one project runs on the system, or a workflow repeats for each project.
20. [GiorgIA](https://georgos.it/llm/note/giorgia.md): conditional. The author keeps personal knowledge that system work must never read.
21. [The session registry](https://georgos.it/llm/note/session-registry.md): conditional. Two or more sessions work in one working tree at the same time.
22. [SendMessage](https://georgos.it/llm/note/send-message.md): conditional. Two registered sessions must coordinate the edit of one thread.
23. [The guide and core](https://georgos.it/llm/note/guide-and-core.md): conditional. The system needs documentation of itself that no session loads by default.

## Reference: Layers & Method

- [GeorgOS Vision](https://georgos.it/llm/node/georgos-vision.md): An AI-OS built on linked knowledge graphs. Three subsystems compose it: Claude Code (execution), Obsidian (graph store) and graphify (code memory).
- [The Vault Layers (L0–L2 + graphify-out)](https://georgos.it/llm/node/vault-layers.md): One Obsidian vault in three layers (L0 the always-on rules, L1 core/ the system, L2 GiorgIA/ the brain) plus orthogonal per-project graphify-out code memory. Route each task to the narrowest layer.
- [Routing Discipline](https://georgos.it/llm/node/routing.md): Route each task to the narrowest layer it needs and load nothing else. The root CLAUDE.md is the interface of GiorgIA: a navigation table, a dispatch index, and the knowledge-base gate.
- [The GeorgOS Method](https://georgos.it/llm/node/method-overview.md): Every GeorgOS graph follows the LLM Wiki pattern: the LLM reads sources and maintains every page; the human curates sources and asks questions.
- [The LLM Wiki Pattern](https://georgos.it/llm/node/llm-wiki-pattern.md): An LLM incrementally builds and maintains a persistent, interlinked Markdown knowledge base that sits between you and your raw sources.
- [Persistent Wiki vs. RAG](https://georgos.it/llm/node/persistent-wiki-vs-rag.md): RAG re-derives an answer from raw chunks every query; the persistent wiki compiles each source once and maintains an interlinked structure.
- [Compounding Knowledge](https://georgos.it/llm/node/compounding-knowledge.md): The wiki gets richer with every source and question because good answers file back in, instead of resetting each session.
- [Vault-Config Contract (region.yml)](https://georgos.it/llm/node/vault-config-contract.md): Every region declares its layout and policy in a single region.yml; the skills read it so their behavior is parameterized by the region, not hard-wired.
- [Memex](https://georgos.it/llm/node/memex.md): Vannevar Bush's 1945 concept: a personal, curated knowledge store with associative trails linking documents.
- [Vannevar Bush](https://georgos.it/llm/node/vannevar-bush.md): American engineer who in 1945 described the memex — the conceptual ancestor of this wiki.
- [Machine Prose](https://georgos.it/llm/node/machine-prose.md): The constraint on every prose deliverable a machine writes in the vault: a ban list plus an ASD-STE100 Simplified Technical English kernel. It never licenses imitating the author's voice.
- [Writing Voice](https://georgos.it/llm/node/writing-voice.md): The author's writing profile: fixed mechanical Block A rules plus a measured Block B voice corpus; read by the thesis blueprint reviewer and the author, never by a drafting agent.
- [STE Kernel — Writing Rules](https://georgos.it/llm/node/ste-rules.md): 45 of ASD-STE100 Issue 9's 53 rules plus its 8 general recommendations, distilled and numbered against the original standard so audit findings can cite it directly.
- [STE Kernel — Banned Words](https://georgos.it/llm/node/ste-banned-words.md): The words that actually appear in machine prose, each with its replacement — Block A quoted from the ASD-STE100 dictionary, Block B vault-authored for defects the standard never had to name.
- [STE kernel: domain terms](https://georgos.it/llm/node/ste-domain-terms.md): The vault's register of technical nouns and verbs the STE-based prose rules permit outside the approved dictionary.
- [Graph Visibility and the Ingest Pipeline](https://georgos.it/llm/node/graph-visibility-and-the-ingest-pipeline.md): How the two-axis graph-visibility contract and the four-skill ingestion pipeline enforce each other, and the one case where the dependency runs the other way.
- [Execution modes](https://georgos.it/llm/node/execution-modes.md): The coder/reviewer pair is the middle execution rung: a worker or the main session writes inline and stops at declared checkpoints for a cold planner:checkpoint-reviewer. Fable orchestrates, Opus executes.
- [Git discipline](https://georgos.it/llm/node/git-discipline.md): The operating rules for every repository: which reason excludes a file from git, and what autonomy each git operation carries.
- [Decision routing](https://georgos.it/llm/node/decision-routing.md): Routes a decision to a permission prompt, an impartial arbiter, or the author's decision block, on three fixed trigger events.
- [LLM-Scoped Prose](https://georgos.it/llm/node/llm-scoped-prose.md): The register for a prose document whose only reader is a model. It extends machine-prose with one inverted rule and four added rules, and the llm-scope skill applies it.

## Reference: Skills

- [graphify](https://georgos.it/llm/node/graphify.md): Turn any folder (code, docs, papers, images, video) into a navigable knowledge graph with community detection, god nodes, and query/path/explain tools.
- [ingest](https://georgos.it/llm/node/ingest.md): Compile raw prose sources (papers, text, PDFs, notes) into a curated, interlinked wiki inside a region. Prose only — code goes through graphify.
- [graph-connect](https://georgos.it/llm/node/graph-connect.md): Onboard any folder into the vault: inspect its structure, route code to graphify and prose to ingest, build the dual wrap, stamp origin, register it in the root hub.
- [ingest-graphify](https://georgos.it/llm/node/ingest-graphify.md): The sole, manual path from a parked graphify-out/ code graph to curated Obsidian code knowledge (source + concept/synthesis pages citing graph nodes).
- [lint](https://georgos.it/llm/node/lint.md): Runs sixteen checks over a wiki region and reports contradictions, broken links, orphan pages, frontmatter defects, and preference projection drift.
- [declutter](https://georgos.it/llm/node/declutter.md): Post-completion cleanup of a single directory: delete the run scaffolding, ask per spec and plan, sweep the stray temp clutter. It archives nothing.
- [interview](https://georgos.it/llm/node/interview.md): A light brainstorming triage: interviews you to grow or correct non-personal knowledge, judges whether it should land, then proposes one of three handoffs and stops.
- [polish](https://georgos.it/llm/node/polish.md): Rewrites a raw prompt into a model-aware, more machine-digestible version, using the ingested Claude Platform docs.
- [impeccable](https://georgos.it/llm/node/impeccable.md): Frontend design skill: shape, critique, audit, refine, enhance, and fix an interface, with a command per intent and a craft floor loaded immediately before any UI edit.
- [planner:deploy](https://georgos.it/llm/node/planner-deploy.md): Apply a reusable planner definition to a project: scaffold the untracked workflow.md, install the issue template, the PM settings, the root trust and the labels, and register the exclusion.
- [guide-sync](https://georgos.it/llm/node/guide-sync.md): Re-scans the framework guide's real sources, hash-diffs them against guide.json, and re-renders index.html.
- [query](https://georgos.it/llm/node/query.md): Answers a knowledge question from the vault by climbing a cheapest-first retrieval ladder and citing every claim.
- [courtroom](https://georgos.it/llm/node/courtroom.md): Adversarial audit of a bounded case: a numbered evidence record, checkable claims routed to existing tools, arguable claims argued by a prosecution/defense pair, and one verdict per topic from a four-seat panel.
- [os-audit](https://georgos.it/llm/node/os-audit.md): Audits the GeorgOS machinery itself against five method properties and eleven lenses, with a deterministic reality sweep and an independent review of its own report.
- [session-handoff](https://georgos.it/llm/node/session-handoff.md): Runs the session board writer by hand, so the board file is rewritten now instead of only at session end.
- [/llm-scope](https://georgos.it/llm/node/llm-scope.md): Writes or restructures a document whose only reader is a model, under the llm-scoped-prose register. It confirms the frame block and every gap marker with the author before it writes.
- [herdr](https://georgos.it/llm/node/herdr.md): Controls Herdr, a terminal multiplexer for coding agents, from inside a Herdr-managed pane.

## Reference: Subagents

- [mechanical-scanner](https://georgos.it/llm/node/mechanical-scanner.md): Cheap write-only-when-told mechanical scanner for lint, guide-sync, graph-connect, and the os-audit citation check: enumerations, hash-diffs, tree walks, and deterministic assembles/renders.
- [technical-writer](https://georgos.it/llm/node/technical-writer.md): Prose editor that audits a bounded text against the machine-prose ban list and the Simplified Technical English kernel, and cites a rule ID for every finding.
- [wiki-retriever](https://georgos.it/llm/node/wiki-retriever.md): Tier-4 page finder for the query skill: reads region indexes, greps, and returns ranked paths with one-line justifications. Never answers the question.
- [wiki-coherence-reviewer](https://georgos.it/llm/node/wiki-coherence-reviewer.md): Read-only meaning-level reviewer for a wiki region after an ingest — link integrity, cross-link reach, taxonomy fit, duplication, contradiction — as opposed to lint's mechanical form checks.
- [courtroom-investigator](https://georgos.it/llm/node/courtroom-investigator.md): Read-only evidence gatherer for /courtroom. Reads every artifact in a resolved audit boundary once and returns a numbered evidence record plus a checkable/arguable triage split.
- [courtroom-attorney](https://georgos.it/llm/node/courtroom-attorney.md): One-sided arguer for /courtroom: argues every arguable claim from the named side, citing only the numbered evidence record.
- [os-auditor](https://georgos.it/llm/node/os-auditor.md): The reasoning half of /os-audit. Reads one mechanically-assembled corpus end to end and writes one report judging the OS machinery against five method properties and eleven lenses.
- [audit-skeptic](https://georgos.it/llm/node/audit-skeptic.md): Independent reviewer of an /os-audit report. Demands a concrete failure trace for each finding, so a plausible finding with no real consequence cannot survive.
- [courtroom-clerk](https://georgos.it/llm/node/courtroom-clerk.md): Bounded pre-panel worker for /courtroom: rules on every COVERAGE-GAP motion and matches every attorney falsifier against the record.
- [courtroom-judge](https://georgos.it/llm/node/courtroom-judge.md): One seat of the /courtroom four-seat verdict panel, ruling on every contested topic through a single fixed lens.
- [courtroom-synthesizer](https://georgos.it/llm/node/courtroom-synthesizer.md): Writes the end of a /courtroom audit: verdicts every bypassed topic, matches seat falsifiers, and states the overall call.
- [planner:checkpoint-reviewer](https://georgos.it/llm/node/checkpoint-reviewer.md): Read-only gate of the coder/reviewer pair: one dispatch per checkpoint, reviewing the diff against the plan for compliance, consistency, errors, and silenced failures.
- [planner:mechanical-coder](https://georgos.it/llm/node/mechanical-coder.md): The coder at transcription tier: it fires only when a plan already carries the code, and returns BLOCKED rather than filling any gap the plan left open.
- [planner:worker](https://georgos.it/llm/node/worker.md): The worker of the PM loop: the main agent of a background session that resolves exactly one GitHub issue in its own worktree, pushes its branch, and opens the PR that closes the issue.

## Reference: Planners

- [Planners](https://georgos.it/llm/node/planners-concept.md): A planner is a type of workflow defining actors and actions in a human-guided, AI-powered pipeline — the orchestrator of a project, coordinating every action across idea → code → knowledge.
- [computational-researcher (definition)](https://georgos.it/llm/node/computational-researcher.md): A concrete planner definition: ground work, then a six-step loop from idea to updated knowledge, with owner tags marking who drives each step.
- [general (definition)](https://georgos.it/llm/node/general.md): The planner for a project without a research loop: the PM runs the issue loop of the pm output style and nothing else.

## Reference: Ingestion Pipeline

- [Ingestion Pipeline](https://georgos.it/llm/node/ingestion-pipeline.md): One job per skill: graphify (code→parked graph), ingest (prose→wiki), graph-connect (orchestrates onboarding), ingest-graphify (parked graph→curated code knowledge).
- [Ingest, Query, Lint](https://georgos.it/llm/node/ingest-query-lint.md): The three operations that drive the wiki: ingest a source, query for an answer, lint for health.

## Reference: Memory Model

- [L0 Memory Model](https://georgos.it/llm/node/memory-model.md): Auto memory is a cache under an address contract: every entry names a disk address, passes three admission tests, and fits a budget of ten entries. A durable preference goes in its GiorgIA/ page first, and the session board holds what the git log cannot answer.

## Reference: Claude Code Tooling

- [Claude Code](https://georgos.it/llm/node/claude-code.md): Anthropic's agentic coding tool and GeorgOS's execution layer: reads the vault, edits files, runs commands, and is itself configured by five primitives.
- [Claude Code as the GeorgOS Execution Layer](https://georgos.it/llm/node/claude-code-execution-layer.md): Maps every GeorgOS construct to the Claude Code primitive that implements it, and states the trigger/gate contract every routing edge follows.
- [Skills](https://georgos.it/llm/node/skills-doc.md): A SKILL.md file of instructions Claude loads on demand and can invoke itself, or that a person triggers with /skill-name.
- [Subagents](https://georgos.it/llm/node/subagents.md): A specialized assistant running in its own context window, returning only a summary to the main conversation — the core use is context isolation.
- [Hooks](https://georgos.it/llm/node/hooks.md): User-defined commands that fire deterministically at lifecycle events — enforcement Claude cannot bypass, where CLAUDE.md is only advice.
- [MCP (Model Context Protocol)](https://georgos.it/llm/node/mcp.md): Lets Claude Code use tools beyond its built-in set — issue trackers, databases, browsers, external APIs — by connecting to MCP servers.
- [Slash commands](https://georgos.it/llm/node/slash-commands.md): Type / to see them: three kinds — built-in, bundled skill, bundled workflow — each recognized only at the start of a message.
- [Memory (CLAUDE.md & auto memory)](https://georgos.it/llm/node/memory.md): CLAUDE.md (you write) and auto memory (Claude writes) are the two mechanisms carrying knowledge across sessions.
- [Permissions](https://georgos.it/llm/node/permissions.md): Two layers decide what Claude Code may do without asking: rules (allow/ask/deny) and modes (how often it pauses at all).
- [settings.json](https://georgos.it/llm/node/settings-json.md): The JSON file that configures Claude Code — permissions, env vars, hooks, model — with a four-scope precedence system wiring every primitive together.
- [Claude Code CLI](https://georgos.it/llm/node/claude-code-cli.md): The claude command line: how sessions launch, resume, fork, run non-interactively, and parallelize.
- [Agent View & Background Agents](https://georgos.it/llm/node/agent-view.md): claude agents is one screen over many full background Claude Code sessions, each a complete conversation running without a terminal attached.
- [Claude in Chrome](https://georgos.it/llm/node/claude-in-chrome.md): Connects Claude Code to a Chromium-based browser for automation from the CLI or VS Code — testing, console/DOM reads, forms, data extraction.
- [Code Review](https://georgos.it/llm/node/code-review.md): A fleet of specialized agents analyzes a PR diff in parallel and posts verified, severity-tagged inline findings without approving or blocking.
- [Fast Mode](https://georgos.it/llm/node/fast-mode.md): A high-speed API configuration for Opus — up to ~2.5× faster at a higher cost per token, identical quality, not a different model.
- [Output Styles](https://georgos.it/llm/node/output-styles.md): Changes how Claude responds, not what it knows, by editing the system prompt to set role, tone, and output format.
- [Plugins](https://georgos.it/llm/node/plugins.md): A self-contained directory bundling skills, agents, hooks, and MCP servers behind a plugin.json manifest, versioned and shareable as one unit.
- [Routines](https://georgos.it/llm/node/routines.md): A saved Claude Code configuration — a prompt, repos, connectors — packaged once and run automatically on Anthropic-managed cloud infrastructure.
- [Sandboxing](https://georgos.it/llm/node/sandboxing.md): An OS-enforced perimeter lets Claude run most shell commands without asking, in exchange for a declared file/network boundary.
- [Dynamic Workflows](https://georgos.it/llm/node/workflows.md): A JavaScript script that orchestrates subagents at scale — Claude writes it, a runtime executes it in the background, the script holds the plan.
- [Artifacts](https://georgos.it/llm/node/artifacts.md): A live, interactive HTML/Markdown page Claude Code publishes to a private claude.ai URL, the vendor primitive the GeorgOS Artifact tool wraps.
- [Channels](https://georgos.it/llm/node/channels.md): An MCP server that pushes events into an already-running session — a chat bridge or a webhook receiver — so Claude reacts while you're away.
- [.claude Directory](https://georgos.it/llm/node/claude-directory.md): The project-local .claude/ and global ~/.claude/ topology — where every extension point (skills, agents, hooks, memory, settings) actually lives on disk.
- [Computer Use](https://georgos.it/llm/node/computer-use.md): Lets Claude click, type, and see a real macOS desktop through a built-in MCP server — for native apps and GUI-only tools with no CLI or API.
- [Context Window](https://georgos.it/llm/node/context-window.md): Everything Claude 'knows' in a session lives in one context window; three visibility tiers govern what loads and how visibly.
- [Prompt Caching](https://georgos.it/llm/node/prompt-caching.md): Only the changed suffix of a request reprocesses, at a fraction of the cost; the value is knowing which actions silently rebuild the cache mid-task.
- [Remote Control](https://georgos.it/llm/node/remote-control.md): Connects claude.ai/code or the mobile app to a Claude Code session on your own machine — execution stays local, the web surface is just a window.
- [Ultraplan](https://georgos.it/llm/node/ultraplan.md): Removed as of the 2026-09-11 vendor snapshot — hands a planning task to a cloud plan-mode session; local plan mode now covers the same job.
- [Claude Platform Docs](https://georgos.it/llm/node/claude-platform-docs.md): A 13-file snapshot of Anthropic's Claude Platform (API) docs — prompt engineering and guardrails — a different product from the CLI execution layer.
- [Prompt Engineering](https://georgos.it/llm/node/prompt-engineering.md): The general technique reference for steering Claude through the system/user prompt, current across the flagship model family.
- [Model-Specific Prompting](https://georgos.it/llm/node/model-specific-prompting.md): Behavioral differences and prompting patterns specific to Claude Fable 5, Fable 5.1, Opus 4.8, Opus 5, Opus 5.5, and Sonnet 5.
- [API Guardrails](https://georgos.it/llm/node/api-guardrails.md): Six techniques for hardening a Claude-powered application: hallucination, jailbreak/injection, prompt leak, latency, consistency, streaming refusals.
- [Advisor](https://georgos.it/llm/node/advisor.md): Pairs the main model with a second, at-least-as-capable model Claude consults at key decision points — before committing to an approach, on a recurring error, before declaring done.
- [Claude Code on the Web](https://georgos.it/llm/node/claude-code-on-the-web.md): Runs a session on Anthropic-managed cloud infrastructure at claude.ai/code, so a task keeps running after the browser closes.
- [Cross-Session Messaging](https://georgos.it/llm/node/cross-session-messaging.md): ListAgents and SendMessage let one Claude Code session find and message another — a subagent, a teammate, or an independent session anywhere.

## Reference: Obsidian Tooling

- [Obsidian](https://georgos.it/llm/node/obsidian.md): The Markdown knowledge-base app used as the human-facing browser over the wiki. GeorgOS's graph store: the whole vault is a folder of plain-text files.
- [Vault](https://georgos.it/llm/node/vault.md): A folder of plain-text files on disk — the unit Obsidian opens and the substrate GeorgOS treats as its graph store.
- [Wikilinks](https://georgos.it/llm/node/wikilinks.md): [[double-bracket]] links — Obsidian's core mechanism and GeorgOS's: every page links liberally, both directions, so the vault becomes a graph.
- [Backlinks](https://georgos.it/llm/node/backlinks.md): A link into a note from elsewhere, indexed automatically — what turns one-directional wikilinks into a traversable graph.
- [Graph View](https://georgos.it/llm/node/graph-view.md): Visualizes the vault as a node-link graph — the at-a-glance health check: hubs, clusters, and orphan pages.
- [Properties](https://georgos.it/llm/node/properties.md): YAML frontmatter at the top of a note. GeorgOS stamps type: and layer: on every page here; ingest/lint read and write properties as structured metadata.
- [Tags](https://georgos.it/llm/node/tags.md): Keyword labels, orthogonal to wikilinks. Where links express relationships, tags express categories.
- [Callouts](https://georgos.it/llm/node/callouts.md): Admonition blocks — a blockquote with a [!type] tag. Used in curated pages to flag contradictions, warnings, and asides without breaking flow.
- [Canvas](https://georgos.it/llm/node/canvas.md): An infinite spatial board of cards and connections, stored as an open .canvas (JSON Canvas) file. The hand-arranged complement to the generated graph view.
- [Core Plugins](https://georgos.it/llm/node/core-plugins.md): Obsidian's built-in, first-party plugins — navigation, search, productivity, display. The wiki-relevant ones have their own pages; the rest are catalogued here.
- [Obsidian Flavored Markdown](https://georgos.it/llm/node/obsidian-flavored-markdown.md): The Markdown dialect every wiki page is written in: CommonMark + GFM + LaTeX, plus Obsidian's own link/embed/callout extensions.
- [Bases](https://georgos.it/llm/node/bases.md): Database-like table, list, cards, and map views over the vault's own properties. Files stay plain Markdown; a .base file only describes the view.

## Reference: Optimization References

- [CoT — Algorithm Optimization (source)](https://georgos.it/llm/node/source-cot-algorithm-optimization.md): The trusted external source the whole taxonomy distills: compiler optimizations for superscalar, vector, and multiprocessor architectures.
- [Dependence Analysis](https://georgos.it/llm/node/concept-dependence-analysis.md): The legality foundation: a transformation is legal if and only if every dependence vector stays lexicographically positive after it.
- [Loop Reordering](https://georgos.it/llm/node/concept-loop-reordering.md): Transformations that change the order iterations execute in, to expose parallelism and cut stride: interchange, skewing, reversal, strip mining, tiling, distribution, fusion.
- [Loop Restructuring](https://georgos.it/llm/node/concept-loop-restructuring.md): Reshapes a loop nest without reordering iterations: unrolling, coalescing, collapsing, peeling, normalization, spreading.
- [Loop Replacement](https://georgos.it/llm/node/concept-loop-replacement-transformations.md): Replaces a whole loop with a different construct: reduction recognition, idiom recognition, array statement scalarization.
- [Memory Access Optimizations](https://georgos.it/llm/node/concept-memory-access-optimizations.md): The memory hierarchy is the dominant bottleneck: padding, scalar expansion, array contraction, scalar replacement, code colocation.
- [Partial Evaluation](https://georgos.it/llm/node/concept-partial-evaluation.md): Move work out of the hot path and into compile time: constant propagation and folding, copy propagation, forward substitution, strength reduction.
- [Redundancy Elimination](https://georgos.it/llm/node/concept-redundancy-elimination.md): Removes unreachable and useless computation: dead code, dead variables, and common-subexpression elimination.
- [Procedure Call Optimizations](https://georgos.it/llm/node/concept-procedure-call-optimizations.md): Four ways to cut call overhead: remove the call, remove the body, cut entry and exit cost, or skip steps in making the call.