Four weeks through prompt, loop, graph, and the knowledge representation layer underneath all three.
Several sources trace this progression independently. Read in order, it is a curriculum rather than a pile of links.
Progressive disclosure is the mechanism that makes it affordable. Schema constrained state is the memory and decision layer. And what separates a graph from an expensive loop is one rule.
A graph is a loop with something that can contradict it.
Phase 4 is the phase most people skip. The agent memory field has converged on schema constrained knowledge graphs with temporal facts, which is ontology engineering, a discipline with thirty years of prior art behind it. Reading the foundations makes the rest stop looking like novelty.
That overlap is not an observation original to this page. Intentional Arrangement has been publishing on semantic infrastructure and what agentic systems need since mid 2025, including a three part series on AI autonomy and a piece from January 2026 titled Ontologies, Context Graphs, and Semantic Layers, What AI Actually Needs. Phase 4 collects that work. What this plan adds is the sequence, and the readings from the other side of the gap.
One post. It becomes the filter the other 64 get judged through, including the ones that contradict it.
Verification anchors. A loop optimises the one number it can see, by any route available, including routes nobody would have approved. Multi agent verification is consensus theater, since identical weights share identical blind spots, and parallel verification costs 10 to 100 percent more rather than less. The rule that survives is that on every critical path at least one node must be non probabilistic.
The vocabulary shift, then progressive disclosure, the three tier pattern that makes large capability libraries affordable. Everything in Phase 2 assumes it.
The cleanest statement of the shift. Start here to get the terms straight.
The original decomposition, written before the term got diluted.
Read immediately after 1.02. The eighteen month diff is the actual lesson.
The most quantified piece in the plan. Three tiers. Discovery loads name and description at roughly 80 tokens per skill, so seventeen skills cost about 1,700. Activation loads full instructions at 275 to 8,000. Execution loads scripts and templates only at the relevant step. Compare that against ninety tool definitions burning 50,000 tokens before reasoning starts.
Same pattern, more depth, worked examples.
The empirical counterweight to prompt maximalism, and a useful gut check against any configuration file that has quietly grown past its usefulness.
A harness is the information and tools that let a general agent do a specific job repeatably. This is where it stops being an abstraction and becomes a filesystem structure you can build.
The definition and the positioning, sitting between rigid graph agents that are unmaintainable and unconstrained ReAct that is unpredictable.
The most directly actionable piece here. A root descriptor, routing files named for their own subdirectory so the agent reads summaries before descending, and a leaf marker that stops exploration and forces use of a tailored skill. The real gem is maintenance. Reverse disclosure finds every routing document referencing a target file, so one high level instruction cascades across all of them instead of silently rotting.
Where the pattern came from and where the field thinks it is going.
The production checklist. Pairs with 2.05.
Abstraction over harnesses, and the newest piece in the plan.
A loop library organised around goals, schedules and recipes.
The origin of the loop engineering framing that 0.01 later argues against. Read both, because the disagreement is the education.
The hands on version. Build alongside it rather than reading it through.
The most aggressive autonomy pattern in the plan. Read 0.01 first, then decide what gets a deterministic anchor before running any of this unattended.
Navigating the tradeoff between pure AI and deterministic software. Same territory as 0.01, argued from an engineering management seat rather than a systems one.
How one team built a custom internal harness for product and engineering work. The only real organisational case study in the plan, since everything else describes individual practice.
Graduated autonomy as a practical case study. The missing middle between asking every time and running overnight.
One constraint move applied twice. The reframe that makes the first half worth it is to stop asking what to retrieve and start asking what should never be stored. The second half points the same move at decisions rather than facts, declaring the answer shape before generation so an invalid answer is unrepresentable rather than merely unlikely.
The argument. Read before 3.02, which is the implementation.
Constrain the output space before generation. Typed entities with docstrings. Edges with source and target constraints, so an invalid relationship is unrepresentable rather than merely unlikely. Temporal facts that separate what was true from what is true. Budget roughly ten entity types, ten edge types and ten fields each, starting at three or four and expanding only when retrieval actually fails. This is the hinge of the phase. Once the constraint move is clear here, 3.10 is the same idea pointed at decisions and needs almost no new explanation.
The taxonomy of memory types, cleanly. Oldest piece in the plan and still the clearest primer.
Why naive vector search stopped being the answer.
The bridge into Phase 4. This is where memory becomes a graph problem.
Architectural history. Skim if 3.04 already landed.
Context as topology. A memory playbook rather than a memory theory.
Playbooks, memory and skills treated as one stack. Discount the headline framing, because the stack model underneath it is sound.
Short. Read as a check on what stuck from the memory half before moving to the decision half.
The decision layer made concrete. A model that takes a state plus declared questions and returns typed answers in three primitives, a choice from a set with per option probabilities, a score on ordered levels, and a yes or no returning a probability between 0 and 1. It writes no prose at all, and its output is built for software to consume rather than a person to read. Read straight after 3.02 and the symmetry does the teaching.
The durable idea is System One, fast automatic judgment treated as a separate class of model from slow deliberate reasoning. That framing outlives any particular product, and it is the vocabulary worth carrying forward.
The applied version. Four demos with receipts, plus ten specific agent decisions that could move off a frontier model. This is what turns the concept into something tried rather than read about.
Calibrated is not deterministic. A decision model trained against outcomes rather than rater preference should have confidence numbers that track real accuracy, which is a genuine property most model confidence scores lack. It is still a model making a probabilistic call.
So a typed decision node is a better behaved judge, not the non probabilistic anchor that 0.01 argues every critical path needs. A compiler is that. A schema validator is that. A decision model sits closer to independent than a second frontier instance does, because it is a different architecture trained on different data, so the correlated blind spot problem shrinks. It does not disappear.
Where does the calibration come from, and what happens to it when the distribution shifts? Carry that question into anything in this space, including whatever replaces the current tooling.
Phase 3 arrives at schema constrained graphs with temporal facts and treats it as a discovery. It is not. It is taxonomy and ontology work, and reading the practitioners directly is the difference between designing a memory system once and rewriting it in eighteen months.
Why most AI projects fail before they start. The best single argument for why this phase exists at all.
Start the series here. Practitioner level rather than academic.
Continues directly from 4.02.
Where taxonomy becomes ontology, which is the distinction Phase 3 blurs.
A worked ontology for workflows. The closest thing in the plan to a template for modelling agent actions.
Graphs proper, from the representation side rather than the retrieval side.
Who actually does this work and what the roles are called. Useful when it comes time to hire for it.
The decision framework. Directly answers the question 3.05 raises and leaves open.
Ready made explanation material for convincing anyone that this layer matters.
A tool rather than an essay. SKOS is the standard a hand rolled memory schema tends to reinvent badly.
An open spec for knowledge bases, for work and life. Read against 4.12 and pick which abstraction is worth adopting.
A free and open source macOS app for managing markdown knowledge bases. The running implementation of 4.13.
Not a sequence. Tactical material, best read when it matches the week's work, and carrying a much shorter shelf life than Phases 1 through 4.
The playbook version of Phase 1. Ignore the multiplier in the title.
Useful as a benchmark against any configuration file that has grown past the median.
Hooks are where a deterministic verification anchor actually gets installed. Read after 0.01.
The hands on counterpart to 0.01.
Newest convention in the set. Verify the claims against primary documentation before adopting any of it.
Context degradation explained without jargon. The most useful thing here to hand to a non engineer.
Memory at the configuration layer, which is the cheap version of Phase 3.
Skim for the two or three that are not already habit.
Reference material.
Progressive disclosure applied, with numbers. The practical payoff of 1.04.
The personal practice version of Phase 2.
A concrete directory convention worth comparing against the harness tree in 2.02.
Process lessons drawn from how the tool itself gets built.
Interleave one per week. Everything above is written by people whose incentive is for agents to work. This is the correction.
Read this one first. Comprehension debt compounds quietly, and the argument lands harder coming from someone with no stake in the habit.
The discipline that makes the deterministic anchor rule from 0.01 operational.
Repeatability as the actual goal, rather than capability.
What has to be true before any of Phase 2 matters organisationally.
Where coding benchmarks actually stand, from the person who built the main one.
The most direct treatment of the central claim in 0.01. Worth finding if the verification question becomes load bearing.
Reading without building turns eighteen hours into industry awareness. Each of these is small and traceable to a specific reading.
Convert a flat skills folder into a harness tree. A root descriptor, routing files named for their own subdirectory so the agent reads summaries before descending, and leaf markers where exploration should stop and a tailored skill should take over. Then add reverse reference lookup so a single high level edit cascades to every routing document that mentions the target.
Three or four entity types. Three or four edge types, each with source and target constrained so invalid relationships are unrepresentable rather than merely unlikely. Temporal facts kept separate so what was true never silently serves as what is true. Expand only when retrieval actually fails, not in anticipation.
A compiler, a type checker, a schema validator, something with zero error correlation to the model. Majority voting several model instances is not verification, because they share weights, training data and blind spots. Audit anywhere a fan out to multiple agents currently gets treated as a check.
Count the tokens spent on tool definitions and always on context before the model does any work. The comparison worth making is that metadata only discovery runs around eighty tokens per skill, while a large tool roster can cost fifty thousand before the first thought.
Last updated 2026-09-22. I am reading this in order and annotating as I go, so entries change as I reach them. Progress is kept in this browser, so checking things off survives a return visit.