Give agentic systems a memory that survives every run by turning decisions, evidence, and execution history into durable, traceable graph structures
Key Features
- Separate work history from durable knowledge with a two-graph architecture and clear bridge rules
- Assemble bounded context from graph paths so agents get the right constraints within token budgets
- Run parallel workers with scoped promises, validated writes, reducer contracts, and hard budgets
Book Description
Agent loops are good at producing work, but the reasoning behind that work often disappears when the context window closes. As teams add parallel agents, lost decisions, duplicated discoveries, and untraceable claims become harder to spot. Graph Engineering shows how to move that reasoning out of transcripts and into explicit structures. You will model execution history separately from durable knowledge, connect the two with a small set of bridge relationships, and keep Markdown as the authoritative source while generating a disposable index for queries. From there, the book turns the model into a working mechanism. It shows how to parse structured repository data, extract only genuine prose, resolve entities, assemble typed relations, and retrieve small, relevant neighborhoods instead of dumping an entire knowledge base into context. You will also see how evaluations can check supporting paths, how concurrent workers publish changes without corrupting shared state, and how a pipeline can preserve lineage from objective to artifact. The final section focuses on judgment: which metrics reveal graph quality, how false merges and bad incentives create confident errors, what the architecture costs, and when a simple ADR log or relational table is the better answer.
What you will learn
- 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
Who this book is for
This book is for senior software engineers, AI and agent engineers, software architects, and platform teams already experimenting with agent loops, coding agents, or multi-agent workflows. It is most useful when decisions, constraints, evidence, and execution history need to survive across runs or be shared between workers. Prior books in the Clarity series are helpful but not required; the manuscript recaps the lattice before extending it. Readers should be comfortable reasoning about software architecture and structured engineering workflows.
