Share E-Book
Scan to open this page

Scan with your phone to open this page

Author: Volodymyr Pavlyshyn

Rating 3.5 AI initial rating

No description

AI Reading Assistant

Whole-book reading guide from stratified index samples; jump to passages in the text

AI guide
【One-Line Pitch】 A practical architecture guide for teams whose AI agent loops produce work but lose the reasoning behind it: it shows how to turn Markdown-based knowledge into a disposable, queryable graph so every output stays traceable. Best for engineers and tech leads building or debugging multi-agent workflows who want durable memory without adopting a graph database. 【Book Arc】 - **Opening (~0%–10%)**: Frames the core problem — agent loops forget, so decisions get contradicted across runs — and previews the solution: an explicit knowledge graph built on Markdown, with the graph as a disposable index rather than a second source of truth. - **Early (~10%–32%)**: Establishes the argument. Defines "graph engineering" (explicit, typed, provenance-bearing structures), offers a one-sentence traceability test, and presents a five-rung architecture ladder (loop, chain, swarm, DAG, graph) ordered by what each externalizes. - **Middle (~32%–50%)**: The structural core. Separates the work plane (historical, high-volume run/commit records) from the knowledge plane (curated, in-force facts), explains the two failure modes of collapsing them, and introduces bridge predicates, node types (ADR, vocabulary, invariant, pattern, principle), and a closed predicate set. - **Late (~50%–70%)**: The mechanism. Covers the schema and graph invariants, then a four-stage pipeline — extraction, resolution, assembly, query — plus a seven-step context builder that retrieves small relevant neighborhoods instead of dumping the whole knowledge base into context. - **Ending (~70%–100%)**: Judgment and rollout. Discusses graph-quality metrics, how false merges and bad incentives produce confident errors, what the architecture costs, when a simple ADR log or relational table is the better answer, and a staged build path from one loop to a graph-grounded swarm. 【Key Takeaways】 - **Loops log; they don't remember** (Early): Persisted transcripts capture what happened but not why, so the same bug gets rediscovered and old decisions get silently contradicted. The fix is moving reasoning into inspectable structures. - **The acceptance test is a fill-in-the-blank sentence** (Early): Every important output should trace to objective, plan, artifact, source, graph path, evaluator decision, and execution record — by querying, not by remembering. This is the book's whole criterion. - **Pick architecture by what you need externalized** (Early): Loop externalizes iteration, chain externalizes order, swarm externalizes parallel search, DAG externalizes experiment lineage, graph externalizes shared facts and provenance. Start at the lowest rung that fits. - **Two graphs, not one** (Middle): Work history is monotonic, machine-written, and never deleted; knowledge is curated, gated, and superseded rather than edited. Collapsing them yields either a well-structured event log with no checkable facts or a clean ontology with no audit trail. - **Markdown stays authoritative; the graph is disposable** (Middle): Nodes are files with typed predicates and provenance; the index can be rebuilt. This keeps the system inspectable and avoids vendor lock-in or a graph database requirement. - **Provenance, confidence, and validity are load-bearing** (Middle): Every assertion knows its source run and supporting evidence; a claim without provenance becomes an opinion the system mistakes for fact. - **Retrieve neighborhoods, not the whole base** (Late): A typed, time-aware context assembler and grounded evaluator check claims against graph paths rather than prose alone, preventing context bloat and unsupported assertions. - **Know when not to build a graph** (Ending): The book spends real length arguing against structure for its own sake — a simple ADR log or relational table is often the better answer, and the staged path starts with a single reflective loop. 【Reading Tips】 - If short on time, follow the author's own advice: read Chapter 3 (the two-graph split), then Appendix A (the one-page reference), then decide whether the rest earns your afternoon. - Read Part I straight through — it's under an hour — then slow down in Part II, which changes how you model data; Part III is where you actually implement. - Treat the schema chapter as a reference to revisit while building, not a linear read; the invariants and predicate set are the parts you'll check against your own design. - Skim the swarm and pipeline chapters if you're running a single loop; they matter most once concurrency and shared state enter the picture. 【Coverage Limits】 The excerpts cover the preface, table of contents, and early-to-middle chapters in detail, but the later mechanism and judgment chapters (evaluation internals, metrics, build path) are represented mainly by headings and summaries; specific examples there are not covered.
Page 1
dd provenance, confidence, and validity to graph assertions Compute NEAR links to surface duplicates without making them facts Build a context assembler with...
View in text
Page 10
................................................................... 96 13.2 Day 2 — Add One Tool................................................................
View in text
Page 20
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 criter...
View in text
Excerpt 4
e query for runs producing commits that honor the same node. This is the swarm's duplicate-discovery detector, and it costs one traversal. None of those four...
View in text
Excerpt 5
TEXT PRIMARY KEY, src TEXT NOT NULL REFERENCES nodes(id), predicate TEXT NOT NULL, -- closed set; see Chapter 7 dst TEXT NOT NULL REFERENCES nodes(id), reifi...
View in text
Excerpt 6
elation as prose. That rule has not changed and should not. Next: the schema, in full, with the work plane and the two bridge edges. 51 The Schema Type Holds...
View in text
Excerpt 7
audit queries, layer 3 only for the context builder itself. • budget_tokens — a hard ceiling. When it binds, drop lowest-confidence edges first and say so in...
View in text
Excerpt 8
s, one graph. Chapter 10 76 The core principles: • Autonomy. An agent can only make promises about its own behaviour. No agent can impose obligations on anot...
View in text
Tags
AI categories
Artificial IntelligenceSoftware
ISBN: 1808812476
Publisher: Packt Publishing
Publish Year: 2026
Language: English
Pages: 138
File Format: PDF
File Size: 3.0 MB
Text Preview (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.

Generating text preview…