GeorgOS is a second version of its author, and it carries as much of the author's work as the author permits. The operating system of the Map section structures the parts, and the work of the author is the purpose of the parts.

Map

GeorgOS borrows the parts list of an operating system. Each row names a function, the part an OS has for it, and the module that performs the function here. The map is a taxonomy of the parts, and the map is no build order and no checklist. The Build order section gives the sequence of the parts and the need that calls for each part.

The analogy breaks at one point. A CPU executes its kernel exactly, and the model reads a rule file as a request. A rule that a script can test therefore gets a hook.

Hardware

Function	An OS has	GeorgOS performs it with
Execute instructions	CPU	the model
Talk to outside devices	drivers	MCP servers

Kernel

Function	An OS has	GeorgOS performs it with
Decide what loads at start	bootloader	the root router
Hold policy that is always in force	resident kernel	L0 rules
Intercept an action before it lands	interrupt handlers	hooks
Bound what a process may touch	protection rings	guards
Pick how work runs	scheduler	the execution rule
Expose system services by name	syscall table	skills

Processes

Function	An OS has	GeorgOS performs it with
Run isolated work	processes, `fork()`	sessions and subagents
Know what else runs	process table	the session registry
Pass messages between processes	IPC	SendMessage
Survive a shutdown mid-task	hibernation file	the session board
Hold the working set of a process	process memory	the context window

Memory and storage

Function	An OS has	GeorgOS performs it with
Cache hot facts that point at storage	cache with addresses	auto memory
Store everything permanently	disk	the vault and the git log
Attach independent volumes	mount points	regions
Write to storage	write path	ingest
Read from storage	read path	query
Check storage integrity	`fsck`	lint and audit
Index code for fast lookup	symbol index	graphify-out

User space

Function	An OS has	GeorgOS performs it with
Hold the user's own files	`/home`	GiorgIA
Run applications	programs	projects and planners
Document the system	`man`	the guide and core

Build order

A part enters the build only for a need that recurs. A core part serves the knowledge loop of ingest, query and lint, directly or through a dependency, so every build needs the core parts. Every other part is conditional, and the Needed when cell of a conditional part names the need that justifies the part. Each part comes after every part that the part depends on, and every core part comes before every conditional part.

The tier and the need of each part are design judgments of the author. The build of this guide checks the order against the declared dependencies.

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

Sources

Andrej Karpathy, llm-wiki.md: https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f
Nate Herk, video on AI knowledge systems: https://youtu.be/8QQ_INxAhRs