Share E-Book

Graph Engineering — The Loop Memory Model Give agentic workflows durable memory, traceability, and shared knowledge with… (Volodymyr Pavlyshyn)(Z-Library)

Author

Rating 3.5 AI initial rating

Log in to rate

C
Language English

No Description

Format PDF
Size 3.0 MB
(First 20 pages)

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

Page 1
G ra p h E n g in e e rin g — T h e L o o p M e m o ry M o d e l V O LO D YM YR PAV LYSH YN Graph Engineering — The Loop Memory Model Give agentic workfl ows durable memory, traceability, and shared knowledge with graphs Volodymyr Pavlyshyn Choose the right architecture from loop, chain, swarm, DAG, or graph Define separate schemas for work history and in-force knowledge Turn Markdown nodes into a disposable query index Add provenance, confidence, and validity to graph assertions Compute NEAR links to surface duplicates without making them facts Build a context assembler with typed, time-aware traversal Check claims against graph paths instead of prose alone Measure graph quality and know when not to build one WHAT YOU WILL LEARN Agent loops are good at producing work, but the reasoning behind that work disappears the moment the context window closes. Two agents rediscover the same bug three sprints apart; a decision made in run 12 gets silently contradicted in run 47. Graph Engineering moves that reasoning out of transcripts and into an explicit knowledge graph. You’ll model execution history separately from durable knowledge, then connect the two with a small set of bridge relationships. Markdown stays the authoritative source; the graph is a disposable index built for queries, not a second source of truth. From there, the book turns the model into a working mechanism: parse structured repository data, extract only genuine prose, resolve entities, and assemble typed relations. Retrieve small, relevant neighborhoods instead of dumping an entire knowledge base into context. See how evaluations check supporting paths, how concurrent workers publish changes without corrupting shared state, and how a pipeline preserves lineage from objective to artifact. The fi nal section is judgment; which metrics reveal graph quality, how false merges and bad incentives produce confi dent errors, what this architecture costs, and when a simple ADR log or relational table is the bett er answer. www.packtpub.com Graph Engineering — The Loop Memory Model First Edition Get a free PDF of this book packtpub.com/unlock/9781808812477
Page 2
Graph Engineering — The Loop Memory Model Give agentic workflows durable memory, traceability, and shared knowledge with graphs Volodymyr Pavlyshyn
Page 3
Graph Engineering — The Loop Memory Model Copyright © 2026 Packt Publishing All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews. Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book. Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information. Portfolio Director: Ashwin Nair Portfolio Manager: Nitin Nainani Project Manager: Ruvika Rao Content Engineer: Kinnari Chohan Technical Editor: Arjun Varma Production Designer: Salma Patel Growth Lead: Anamika Singh First published: September 2026 Published by Packt Publishing Ltd. Grosvenor House 11 St Paul's Square Birmingham B3 1RB, UK. ISBN 978-1-80881-247-7 www.packtpub.com
Page 4
Contributors About the authors Volodymyr Pavlyshyn writes about AI-driven software engineering, agent workflows, and durable engineering knowledge. Graph Engineering is the third book in his Clarity series, following The Clarity Engineer and The Clarity Forge. Across the series, he explores how engineering judgment, specifications, architecture records, and agent execution can be turned into explicit artifacts that survive tool and model changes. In this book, he extends that work from durable specifications to graph-based memory for multi-agent development.
Page 5
(This page has no text content)
Page 6
Table of Contents Preface xi Part I: The Argument 1 Chapter 1: Everyone's Building Loops, Almost Nobody's Building the One That Remembers 3 1.1 What Loop Memory Actually Captures ................................................................................. 4 1.2 The Three Honest Risks ........................................................................................................ 4 1.3 The Inversion ....................................................................................................................... 5 1.4 Why Markdown Files Stopped Being Enough ...................................................................... 6 1.5 What "Graph Engineering" Actually Names ........................................................................ 7 1.6 The One‐Sentence Test ........................................................................................................ 7 Chapter 2: The Ladder: Five Architectures, Five Bottlenecks 9 2.1 The Five Rungs ..................................................................................................................... 9 2.2 Rung One: The Loop, And The Four Conditions ................................................................. 10 2.3 Rung Two And Three: Chains And Swarms ......................................................................... 12 2.4 Rung Four: The DAG Is The Graph ...................................................................................... 12 2.5 Rung Five: The Knowledge Graph ...................................................................................... 14 2.6 Choosing A Rung ............................................................................................................... 14 2.7 What The Ladder Tells You About This Book ...................................................................... 15 Chapter 3: Two Graphs, Not One 17 3.1 The Two Questions ............................................................................................................. 17 3.2 The Two Failure Modes Of Collapsing Them ..................................................................... 18 3.3 The Bridge ......................................................................................................................... 19 3.4 You Already Have Both, Badly ............................................................................................ 20 3.5 A Worked Example Of The Split ......................................................................................... 20 3.6 The Rule ............................................................................................................................. 21
Page 7
Part II: The Structure 23 Chapter 4: The Lattice You Already Have 25 4.1 The Lattice In One Page ...................................................................................................... 25 4.2 What It Gets Right ............................................................................................................. 27 4.3 What It Cannot Do ............................................................................................................ 27 4.4 The Pattern In The Six ....................................................................................................... 28 4.5 What Survives The Promotion ........................................................................................... 29 Chapter 5: Lattice Metagraphs 31 5.1 The Three‐Level Hierarchy, Briefly ...................................................................................... 31 5.2 Four Places The Lattice Is Already Metagraphic ................................................................. 32 5.2.1 supersedes Is An Edge About A Decision‐Relation • 32 5.2.2 Nodes Already Contain Subgraphs • 32 5.2.3 Capabilities Contain Requirements Contain Scenarios • 33 5.2.4 Properties On Edges • 33 5.3 Accidental Metagraphs ...................................................................................................... 33 5.4 The Layer Model ................................................................................................................ 35 5.5 Homoiconicity, And Why It Matters Here .......................................................................... 35 5.6 Implementing It Without A Metagraph Database .............................................................. 36 Encoding A — Markdown plus a derived index (recommended) • 36 Encoding B — Bipartite projection • 37 Encoding C — RDF‐Star / statement graphs • 38 5.7 When You Do Not Need Full Metagraph Expressiveness .................................................... 38 5.8 What Chapter 6 Adds ........................................................................................................ 38 Chapter 6: Semantic Spacetime for the Lattice 41 6.1 The Four Relations ............................................................................................................. 41 6.2 Mapping The Forge's Five .................................................................................................. 43 6.3 What The Missing Relation Costs ...................................................................................... 43 6.4 NEAR Is Computed, Never Authored .................................................................................. 44 6.5 Pragmatic Proximity Is The Whole Trick ........................................................................... 45 6.6 Why Not Just Embeddings ................................................................................................. 46 6.7 LEADS_TO And The Temporal Dimension ......................................................................... 47 Table of Contents vi
Page 8
6.8 The Extended Vocabulary .................................................................................................. 48 Chapter 7: The Schema 49 7.1 Design Constraints ............................................................................................................. 49 7.2 Node Types ........................................................................................................................ 49 Knowledge plane — durable, curated, in‐force set • 49 Work plane — historical, high‐volume, machine‐written • 50 Shared • 51 7.3 Predicates ........................................................................................................................... 51 Knowledge plane — authored (unchanged from the forge) • 51 Work plane — authored • 52 Bridges — the only cross‐plane predicates • 52 Derived — computed, never authored • 53 Structural — implied by layout • 53 7.4 The Node File Format ......................................................................................................... 53 7.5 Reference Syntax ................................................................................................................ 54 7.6 A Complete Worked Example ............................................................................................. 54 7.7 The Five Graph Invariants .................................................................................................. 57 7.8 The Directory Layout ......................................................................................................... 57 7.9 Migration From A Forge Lattice ......................................................................................... 58 Part III: The Mechanism 59 Chapter 8: Building the Graph 61 8.1 What To Parse And What To Extract .................................................................................. 61 8.2 Stage 1 — Extraction .......................................................................................................... 62 8.3 Stage 2 — Resolution ......................................................................................................... 63 8.4 Stage 3 — Assembly ........................................................................................................... 64 8.5 Stage 4 — Query ................................................................................................................ 65 8.6 This Is Graph Autoresearch ............................................................................................... 67 8.7 Building The Gold Set ........................................................................................................ 68 Chapter 9: Context Assembly and the Grounded Evaluator 69 9.1 The Failure Mode This Prevents ......................................................................................... 69 9.2 The Seven‐Step Context Builder ........................................................................................ 69 vii Table of Contents
Page 9
9.3 Grounding: From Critique To Check ................................................................................... 71 9.4 The Forge Version .............................................................................................................. 72 9.5 What Stays With The Model .............................................................................................. 73 9.6 Multi‐Hop Answers Need Path Evaluation ........................................................................ 73 9.7 The Honest Limit ............................................................................................................... 74 Chapter 10: The Swarm Against One Graph 75 10.1 The Write Problem ........................................................................................................... 75 10.2 Promise Theory: Workers Own Their Promises ................................................................ 75 10.3 Worktree Isolation, And Its Limit ..................................................................................... 77 10.4 The Write Protocol ........................................................................................................... 77 10.5 The Reducer, And Why It Needs A Contract ..................................................................... 78 10.6 Making Verification Actually Independent ...................................................................... 79 10.7 Budgets Are Not Optional ................................................................................................. 79 10.8 When Fan‐Out Hurts ...................................................................................................... 80 Chapter 11: The Pipeline, Rewired 81 11.1 The Full Stage List ............................................................................................................. 81 11.2 What Changes At Each Stage ............................................................................................ 82 11.3 The Archive Command, Extended ..................................................................................... 84 11.4 LINK, In Detail .................................................................................................................. 84 11.5 Costs, Honestly ................................................................................................................. 85 11.6 What Not To Automate ..................................................................................................... 86 Part IV: Judgement 87 Chapter 12: Metrics, Failure Modes, and When Not to Build This 89 12.1 Metrics By Layer ............................................................................................................... 89 12.2 Metrics Get Gamed, Always ............................................................................................. 90 12.3 Entity Resolution Can Cause Catastrophic Errors ............................................................. 91 12.4 The Graph Amplifies Builder Judgment ............................................................................ 92 12.5 A Graph Reflects Its Corpus .............................................................................................. 92 12.6 The Cost Side .................................................................................................................... 93 12.7 When Not To Build A Graph .............................................................................................. 93 12.8 Sketches Are Not Production Software ............................................................................. 94 Table of Contents viii
Page 10
12.9 The Test, Again ................................................................................................................. 94 Chapter 13: The Build Path 95 13.1 Day 1 — Build The Loop .................................................................................................... 96 13.2 Day 2 — Add One Tool ...................................................................................................... 97 13.3 Week 1 — Add Planning .................................................................................................... 97 13.4 Week 2 — Go Multi‐Agent ................................................................................................ 97 13.5 Month 1 — Wire In The Graph .......................................................................................... 98 13.6 Month 2 — Scale To A Swarm ........................................................................................... 98 13.7 The Reference Architecture ............................................................................................... 99 13.8 The Default Task Loop ..................................................................................................... 99 13.9 The Production Checklist ............................................................................................... 100 13.10 Closing .......................................................................................................................... 101 Chapter 14: Further Reading 103 The Clarity Series .................................................................................................................. 103 Graph Structures ................................................................................................................... 103 Foundational Theory ............................................................................................................. 104 Architecture and Documentation Practice ............................................................................ 104 Agent Workflow Practice ....................................................................................................... 105 Tooling .................................................................................................................................. 105 A Note On The Paper That Started This ................................................................................. 106 Appendix A: Graph Engineering on One Page 107 The Claim .............................................................................................................................. 107 The Test ................................................................................................................................ 107 The Ladder ............................................................................................................................ 107 Two Graphs, Not One ............................................................................................................ 108 The Vocabulary ..................................................................................................................... 108 The Node Types ..................................................................................................................... 108 The Four Semantic Modes ..................................................................................................... 108 The Five Graph Invariants ..................................................................................................... 109 The Pipeline .......................................................................................................................... 109 The Seven‐Step Context Builder ............................................................................................ 109 The Grounded Evaluator ....................................................................................................... 109 ix Table of Contents
Page 11
The Build Path ........................................................................................................................ 110 The Iron Rules ........................................................................................................................ 110 When Not To Build This ......................................................................................................... 110 Appendix B: Schema Reference 111 B.1 Node Types ........................................................................................................................ 111 B.2 Predicates ......................................................................................................................... 112 Knowledge plane — authored • 112 Work plane — authored • 113 Bridges — the only cross‐plane predicates • 113 Derived — computed on index build, never authored, never gating • 113 Structural — implied by layout • 114 B.3 Reference Syntax .............................................................................................................. 114 B.4 Node File Format .............................................................................................................. 114 B.5 Reified Assertion Format .................................................................................................. 115 B.6 Layers ............................................................................................................................... 115 B.7 The Five Graph Invariants ................................................................................................ 115 B.8 Derived Index Schema ...................................................................................................... 116 B.9 Retrieval Policy (Layer 3) .................................................................................................. 117 B.10 Directory Layout ............................................................................................................. 117 B.11 CLI Surface ...................................................................................................................... 118 Appendix C: The Prompts 119 G1 — Graph Reconciliation (extends Glue 3¼, Lattice Reconciliation) .................................. 119 G2 — Bounded Context Assembly (replaces the Stage 5 spec‐slice selection) ....................... 120 G3 — The Grounded Evaluator (replaces the ADR‐alignment portion of Stage 6) .................. 121 G4 — Extraction (new; Stage: index build) ............................................................................ 121 G5 — Resolution Arbitration (new; Stage: index build) ......................................................... 122 G6 — Promise Declaration (new; Stage 5, per dispatched worker) ......................................... 123 Installation ............................................................................................................................ 123 Index 125 Table of Contents x
Page 12
Preface You set the loop running on Friday. Generate, critique, revise. Tools wired in. Three worktrees, three sub-agents, a reducer at the end. You came back Monday to forty commits, a green test suite, and a summary that reads well. Then you asked the only question that matters: why is the retry budget three? Nobody knows. Not you — you were asleep. Not the loop — its context window closed on Friday night and took the reasoning with it. Not the commit log — it records that MAX_RETRIES = 3 was written, not that an agent tried five, watched the rate limiter trip, and settled on three. The artifact survived. The decision evaporated. This is the same failure as the Monday morning in The Clarity Forge — intent lost, code shipped — except now it happens at machine speed, unattended, forty times over. The forge fixed the human-paced version by making the spec the durable artifact and the code the side effect. That fix does not survive contact with a swarm. A spec is a document. A swarm needs a substrate. What This Book Is The seed of the substrate is lat.md/, the lattice: ADRs, vocabulary, invariants, patterns, and principles, cross-linked by five named predicates. It is a place to park the crosscutting knowledge that specs and ADRs both drop. This book moves the lattice to the centre of the architecture and finishes the job. It turns the lattice from a directory of Markdown files into a queryable, typed, provenance-bearing metagraph that many agents read from and write to concurrently, and it wires that graph into every stage of the OpenSpec pipeline, from bootstrap to archive. The claim is small enough to state in one line and large enough to reorganize a workflow around it: The memory is not the sixth piece of the loop. It is the thing the loop exists to produce. Everything here follows from taking that seriously. What You Need To Have Read Nothing, strictly. Chapter 4 recaps the lattice in full before extending it.
Page 13
Chapters 5 and 6 lean on two further books for their formal grounding — Metagraph for AI Agents and Semantic Space Time for AI Agent Ready Graphs — but both chapters are written to stand alone. The cross-references tell you where to go deeper, not what you must read first. What This Book Is Not It is not a survey of agent frameworks. It is not a defence of any particular graph database — the whole thing runs on Markdown files and a 200-line indexer if you want it to. And it is not an argument that every team needs a knowledge graph. Chapter 12 spends most of its length arguing the opposite, because the failure mode of this decade is not too little structure, it is structure adopted for its own sake. The test the book is trying to help you pass is narrow and mechanical: Every important output can be traced to an objective, a plan, an artifact, a source, a graph path, an evaluator decision, and a bounded execution record. When that sentence is true, adding agents adds throughput. When it is false, adding agents adds opacity. That is the whole of graph engineering, and the rest is detail. How To Read It Part I is the argument — three short chapters on why loops forget and what the alternative looks like. Read it straight through; it is under an hour. Part II is the structure — the lattice recap, the metagraph promotion, semantic spacetime, and the concrete schema. This is the part that changes how you model. Part III is the mechanism — building the graph, assembling context from it, running a swarm against it, and the rewired pipeline. This is the part you implement. Part IV is judgment — metrics, the ways this goes wrong, and a staged build path from one loop to a graph-grounded swarm in two months. Three appendices carry the one-page reference, the full schema, and the prompts. If you are impatient, read Chapter 3, then Appendix A, then decide whether the rest earns your afternoon. Preface xii
Page 14
Part I The Argument Three chapters on a single observation: the industry has spent two years perfecting the loop and almost no time on the thing the loop is supposed to leave behind. Chapter 1 states the core message. Chapter 2 puts the loop in a ladder of architectures and shows what each rung actually buys you. Chapter 3 makes the distinction that the rest of the book depends on — that there are two graphs in any serious agentic system, they answer different questions, and collapsing them destroys both.
Page 15
(This page has no text content)
Page 16
1 Everyone's Building Loops, Almost Nobody's Building the One That Remembers "The memory isn't the sixth piece of the loop. It's the thing the loop exists to produce." Loop engineering arrived fully formed. Within about a year the practice converged on five pieces, and you can find the same five in every serious writeup: Automations — the loop itself. Generate, critique, revise. One self-review cycle beats a smarter model with none. Tools — search, code execution, database access, file operations. Thinking without tools is hallucinating with extra steps. Worktrees — isolation, so parallel agents editing the same repository do not corrupt each other. Skills and plugins — packaged capability, so the loop does not re-derive how to run your test suite every session. Sub-agents — fan-out, fresh context per worker, a reducer at the end. This is a good list. It is also, in every version of it I have read, followed by a sixth item introduced with a shrug: and you'll want some kind of memory — a scratchpad, a NOTES.md, a task list the loop updates as it goes. That shrug is the whole problem. 1. 2. 3. 4. 5.
Page 17
1.1 What Loop Memory Actually Captures Look at what the conventional loop persists between iterations. Almost universally it is some variant of: ## Done - [x] Add passkey registration endpoint - [x] Wire WebAuthn ceremony - [x] Set MAX_RETRIES = 3 ## Next - [ ] Add credential rotation job - [ ] Migrate existing OAuth users This is a work-state ledger. It records what happened and what is queued. It is genuinely useful and you should keep it. But run your finger down that list and ask what a new agent — or you, in March — can reconstruct from it: Why passkeys and not WebAuthn-over-OAuth? Not recorded. Why is MAX_RETRIES three? Not recorded. Does "credential rotation" mean 90 days because of a policy, a compliance requirement, or because someone typed a plausible number? Not recorded. Which of the forty commits is the one that established the invariant everything downstream now assumes? Not recorded. The ledger captures work state and drops reasoning state. And reasoning state is the expensive part. Work state can be recomputed by looking at the repository — git log is a work-state ledger and a better one than any NOTES.md. Reasoning state cannot be recomputed from anything. Once the context window closes, it is gone, and the only remaining copy was in a transcript nobody will read. 1.2 The Three Honest Risks The loop-engineering literature is unusually candid about its own failure modes. Addy Osmani names three, and they are the right three: Verification burden stays on the engineer. The loop produces more diff than any human can read. You either read it all and lose the throughput gain, or you skim and lose the assurance. Nothing in the loop resolves this. • • • • • Chapter 1 4
Page 18
Comprehension erodes across cycles. Each iteration is locally justified and globally undocumented. After forty of them, the system does things for reasons that were once good and now unrecoverable. The codebase becomes archaeology. Cognitive surrender becomes comfortable. This is the one that ends careers quietly. Approving diffs you do not understand is uncomfortable the first week and routine by the third. The discomfort was the signal, and it habituates. Now notice something about all three: none of them is a model-capability problem. A better model produces more diff you cannot read, more locally justified iterations, and a smoother slide into surrender. Scaling the model scales the failure. These are architecture problems, and specifically they are problems about where memory and evaluation live. 1.3 The Inversion The conventional framing puts memory sixth, as a support function for the loop. Invert it: The loop is the mechanism. The memory is the product. Under this framing the five pieces do not disappear — they get a purpose. Each one exists to contribute something durable to a substrate that outlives every individual run: Piece Conventional purpose Purpose under the inversion Automations Iterate until it passes Produce a decision with an evaluation attached Tools Ground the model in reality Produce sourced claims, not fluent prose Worktrees Prevent file conflicts Produce independent lineages that can be compared Skills Package capability Encode in-force constraints the loop must honor • • 5 Everyone's Building Loops, Almost Nobody's Building the One That Remembers
Page 19
Piece Conventional purpose Purpose under the inversion Sub-agents Parallel throughput Produce findings as typed nodes, not transcripts Same five pieces. Completely different systems. In the first, the artifacts are the point and the memory is a side effect. In the second, the memory is the point and the artifacts are the side effect — which is exactly the move The Clarity Engineer made one level up, when it argued that the spec is the durable artifact and the code is the side effect. This book is that argument applied one level deeper. The spec was durable relative to code. The graph is durable relative to specs. 1.4 Why Markdown Files Stopped Being Enough The forge's answer to lost intent was a set of files: proposal.md, design.md, spec.md, ADRs, and — in the bonus chapter — the lat.md/ lattice. For a human paced pipeline running one change at a time, files are the right answer. They are diffable, reviewable, greppable, and they survive every tool change. Files break on three specific pressures, and a swarm applies all three at once. Pressure one: concurrent writers. Two agents in two worktrees both discover that the checkout flow needs an idempotency key. Both mint lat:invariant/checkout‑idempotency. With files, you get a merge conflict at best and two divergent nodes at worst. The lattice's own anti-pattern list warns against forking the lattice across services; a swarm forks it across workers, ten times an hour. Pressure two: retrieval under a token budget. A worker needs the constraints relevant to its task. With files, "relevant" means either catlat.md/**/*.md — which blows the budget and buries the signal — or a grep whose recall you cannot characterise. Neither is retrieval. Both are context dumping with different failure modes. Pressure three: claims that need to be checked, not read. A file can state that the change honors lat:invariant/totals‑non‑negative. Nothing checks it. When the evaluator is a model reading prose, "honors" means "the prose asserts it." The forge's lat lint verified that references resolve — a real gate, and the right first one — but resolving is not the same as being satisfied. To check satisfaction you need the invariant, the claim, and the evidence to be addressable objects with edges between them. Chapter 1 6
Page 20
Every one of these is a graph problem wearing a filesystem costume. The files were never wrong; they were an encoding that stopped fitting the load. 1.5 What "Graph Engineering" Actually Names The term is currently doing a lot of viral work on social media, mostly attached to claims of thousand-fold improvements that nobody measured. Strip that off and a real practice remains, with a precise definition: Graph engineering is the practice of moving an agentic system's memory and evaluation out of the context window and into explicit, typed, queryable structures with provenance — so that what one agent learns is addressable by every other agent, in this run and in every future run. Three words in that definition are load-bearing. Explicit. The structure is written down and inspectable, not implied by a prompt or latent in a transcript. If you cannot ls it, it does not exist. Typed. Nodes have kinds and edges have named predicates from a closed set. Untyped graphs are just prose with arrows; you cannot write a gate against them. With provenance. Every claim knows where it came from, which run produced it, and what evidence supports it. A claim without provenance is an opinion the system will eventually mistake for a fact. Note what the definition does not require: a graph database, embeddings, a specific vendor, or a rewrite. Chapter 13's Day 1 step is a single reflective loop that stores its versions. The graph arrives in Month 1, and it arrives as files plus an index. 1.6 The One‐Sentence Test Here is how to know whether your loop remembers, without reading any code. Pick the last non-obvious thing your agentic system produced. Then try to complete this sentence about it: This output traces to objective ____, plan ____, artifact ____, source ____, graph path ____, evaluator decision ____, and ex- ecution record ____. If you can fill every blank by querying something rather than by remembering something, you have a loop that remembers. If you fill them by opening a transcript, you have a loop that logged. If you cannot fill them at all, you have a loop that forgot — and every agent you add from here makes the forgetting faster and harder to notice. That sentence is the acceptance criterion for this entire book. Chapters 2 and 3 establish why it needs a graph and not a bigger file. The rest of the book builds the thing that makes it true. • • • 7 Everyone's Building Loops, Almost Nobody's Building the One That Remembers
The above is a preview of the first 20 pages. Register to read the complete e-book.

Recommended for You

Loading recommended books...
Failed to load, please try again later

Tip the Site

Scan the WeChat Pay or Alipay code to tip. No login required.

WeChat Pay
Alipay
← Back to List