The Map Everyone's Missing: LLM Knowledge Engineering in 2026

English | 繁體中文 | 简体中文 | 日本語 | 한국어 | Español

I analyzed 50+ awesome lists, surveys, and guides -- none of them connected the dots. RAG papers don't mention harness engineering. Memory frameworks ignore skill systems. MCP docs skip progressive disclosure. This guide draws the complete map.

The early-August 2026 wave adds MemTensor's Metis paper on memory foundation models plus two further timeline entries, on top of the late-July wave (Chapter 14 plus six timeline entries) and the mid-July wave. Most recent first (full chronological log: CHANGELOG.md):

  • July 29 MemTensor's Metis proposes memory foundation models — MemTensor (Shanghai), the same lab behind June's agent-native-memory survey, joined by co-authors from Renmin University / NUS / SJTU / Tongji, proposes agent memory as persistent, parametric state inside the transformer backbone itself rather than an external store: a frozen Qwen3.5 backbone (4B/9B/27B) with only a Fast-Weight-Programming-inspired "hyper memory block" and "local memory block" trained, updated at inference by a gradient-free EMA-style pass; the paper itself reports long-horizon information loss under fixed-size compression and "information confusion in some cases, possibly caused by the blending of semantics within the latent space" (Ch06, Ch11, glossary)
  • July 29 LangChain ships Deep Agents v0.7 — removes the framework's default base system prompt, trims built-in tool descriptions 43%, and makes the todo-list planning scaffold opt-in after evals across three model families found no measurable gain from it, cutting base input tokens on a default agent turn roughly 65% (~6k to ~2k) — a production instance of this guide's stress-testing discipline (Ch04 §4.8, Ch11)
  • July 29 MinIO ships AIStor Memory — an object-storage-backed layer for agent memory, workspace state, and credentials, positioned to replace a hand-assembled stack of vector store, metadata database, and credential tooling with a durable, customer-owned, full-fidelity record (Ch11)

From earlier waves (full detail in CHANGELOG.md):

  • July 28 The MCP 2026-07-28 specification ships final — the largest revision since authorization was added: a stateless request/response core, Multi Round-Trip Requests (SEP-2322), RFC 9207 issuer validation, Client ID Metadata Documents replacing Dynamic Client Registration, and a formal extensions framework, with a 12-month deprecation window for Roots / Sampling / Logging / HTTP+SSE (Ch07, Ch11, glossary)
  • July 24 Claude Opus 5 — pricing unchanged from Opus 4.8 at half Fable 5's rate, 1M context / 128K output, a five-level effort dial, paid Fast mode, and mid-conversation tool changes without prompt-cache invalidation (beta); benchmark figures are Anthropic's own claims (Ch04 §4.10, Ch11)
  • July 17-22 New Chapter 14 — Graph Engineering — the second layer-name in six weeks gets a full chapter: Steinberger's July 17-18 catalyst post, the org-graph / work-graph split (Thakker), loops supervising loops held down by anchors (Perez), governed topologies (TrueFoundry, Eigent), and LangChain's double-edged "3 Years of Graph Engineering with LangGraph" response — framed as emerging and contested, two weeks old, with the skeptics given equal weight and an explicit September 2026 survival gate (Ch14, Ch01, glossary)
  • July 18 Anthropic resolves Fable 5 subscription access — Max and Team Premium keep Fable 5 permanently from July 20 at 50% of weekly usage limits, while Pro and Team Standard move to usage-credit rates — closing the arc that began with the June 12 export-control suspension (Ch11)
  • July 17 Moonshot releases Kimi K3 — at 2.8T parameters (MoE) the largest open-weight model ever released, with 1M context and native vision; topping Arena's frontend coding leaderboard as an open-weight model, weights following July 27 under Moonshot's bespoke Kimi K3 License ("open weight," in the company's own framing, not "open source") — server-class only, so the open-weight frontier widens without changing the local-deployment story (Ch09, Ch11)
  • July 17 WAIC 2026 and the founding of WAICO — the World AI Conference in Shanghai produces the agreement establishing the World Artificial Intelligence Cooperation Organization, the first intergovernmental organization dedicated to AI, headquartered in Shanghai (Ch09, Ch11)
  • July 14 New Chapter 13 — Loop Engineering — the June 2026 "loop engineering" frame gets a full chapter: Peter Steinberger's catalyst post, Addy Osmani's naming essay and "Own the Outer Loop" follow-up, Boris Cherny, the generator-evaluator split (Rajasekaran), Stripe's minions, LangChain's four stacked rungs, and adoption signals — framed as emerging and contested, five weeks old with no academic literature yet (Ch13, Ch01, glossary)
  • July 6 Anthropic J-space — a second interpretability channel — Anthropic's "A global workspace in language models" identifies J-space, a small set of internal residual-stream directions Claude can report and modulate, giving harness engineers a CoT-independent sensor class for reading internal state (Ch04 §4.2, Ch11)
  • July 6 Tencent open-sources Hy3 — the 295B-parameter Hunyuan 3.0 ships under unrestricted Apache 2.0 with geographic carve-outs removed; the last major closed Chinese frontier lab defaulting to fully open weights completes the open-source-convergence thesis (Ch09, Ch11)
  • July 2 Cloak-and-Detonate (HKUST) — systematic demonstration that static skill scanning has a structural ceiling: SkillCloak evades >90% of the time across 8 scanners, and the same team's runtime checker SkillDetonate catches 97% of attacks at a 2% false-positive rate (Ch05 §5.10, Ch11, glossary)
  • June 29 DeepSeek V4 peak/off-peak pricing — the mid-July official release adds demand-responsive time-of-day API pricing (peak hours at 2x off-peak), reframing price itself as a scheduling primitive for harness designers (Ch09, Ch11)
  • June 26 OpenAI GPT-5.6 Sol/Terra/Luna — an Executive-Order-gated ~20-partner preview; METR records the highest detected cheating rate of any public model (raw-CoT monitoring worked because OpenAI preserves CoT), and Sol's ultra mode sells subagent fan-out as a priced test-time-compute dial (Ch04 §4.2, Ch11)
  • June 22 AIR skill-supply-chain hijack — a fake brand-landingpage skill behind an Instagram ad hijacked ~26,000 agents past every scanner via a time-of-check-to-time-of-use gap: the vetted snapshot pointed to an attacker-controlled URL rewritten after vetting (Ch05 §5.10, Ch11, glossary)
  • June 18 MCP Enterprise-Managed Authorization — a stable extension that provisions MCP-server access centrally through the IdP via an ID-JAG token exchange, killing per-app OAuth consent screens with broad day-one cross-vendor adoption (Ch07, Ch11, glossary)
  • June 18 Terminal-Bench Challenges — a multi-day autonomous-endurance benchmark class (days of runtime, no intervention); Opus 4.8 left running 12 hours on a Rust-compiler task made no progress, a sobering null result at exactly the harness horizon (Ch04 §4.8, Ch11)
  • June 17 AWS AgentCore harness GA — CreateHarness / InvokeHarness ship "harness" as a literal, provider-agnostic product; paired with Microsoft's Agent Harness, two hyperscalers adopt the term as a SKU within a month (Ch04 §4.9, Ch11)
  • June 16 Loop stacking goes institutional and bilingual — LangChain's "The Art of Loop Engineering" (four stacked rungs; Swyx's "loopcraft") and 程序员鱼皮's 保姆级 Chinese guide land the same day, nine days after the naming (Ch11)
  • June 12 Export-control suspension of Fable 5 / Mythos 5 — the first time a US lab pulled its own already-GA flagship offline under a government order; staged restoration plus an Anthropic-drafted jailbreak-severity framework mark government entering the distribution loop (Ch11)
  • June 9 Claude Fable 5 + Mythos 5 — the first public GA of a Mythos-class model, safety-tiered against the Glasswing-gated Mythos 5; ships refusal-as-stop_reason plus a fallback-billing contract, a new harness primitive in the task-budgets family (Ch04 §4.10, Ch11, glossary)
  • June 8 Apple opens Foundation Models to any LLM provider — a public LanguageModel Swift protocol turns Apple's native inference framework into a pluggable-provider API, with local Hugging Face models as an Apple-shipped backend (Ch12, Ch11)
  • June 7 The week "loop engineering" got its name — Steinberger's viral "design loops that prompt your agents" post, Osmani's same-day naming essay, and Cherny's "my job is to write loops" converge in one week; Anthropic's @ClaudeDevs "Getting started with loops" article (July 6, ~6.0M impressions) institutionalizes it within a month, still calling it "loops" (Ch01, Ch11, Ch13)

TL;DR

  • Prompt engineering was just the beginning. The field has evolved through three generations: Prompt Engineering (2022-2024), Context Engineering (2025), and Harness Engineering (2026). Each layer subsumes the last -- and a contested fourth layer, loop engineering, emerged in mid-2026 (Ch13), followed six weeks later by a fifth claim, graph engineering (Ch14).
  • RAG is not dead. 71% of enterprises that tried context-stuffing came back to RAG within 12 months (Gartner Q4 2025). Hybrid architectures are winning.
  • Context engineering is about what surrounds the call, not the call itself. Andrej Karpathy's mid-2025 reframe shifted focus from crafting prompts to constructing the entire context window dynamically.
  • Harness engineering is the operating system layer. Birgitta Böckeler (writing in Martin Fowler's Exploring Generative AI memo series, April 2026) and the OpenAI Codex team's harness-design framing formalized this -- the model is the CPU, context is RAM, and the harness is the OS that orchestrates everything.
  • No single guide connected all of this until now. RAG, knowledge graphs, long context, MCP, skill routing, memory systems, and progressive disclosure are all part of one ecosystem. This is the map.

Start Here

AI tools are getting smarter every year, but they only work well when they receive the right information at the right time. This guide explains how that works -- from the basics of telling an AI what to do, all the way up to designing entire systems around AI models.

Think of AI like a brilliant new employee on their first day. Prompt engineering is giving them a single task. Context engineering is giving them all the background information they need to do the task well. Harness engineering is designing their entire work environment -- their desk, their tools, their filing system, their team structure -- so they can do their best work consistently. This guide covers all three, and shows how they connect.

If you are new to this topic, start with the Glossary for definitions of key terms. If you build AI applications, jump straight into the chapters below. If you just want the big picture, look at the Ecosystem Map diagram further down this page.

Which Path Should You Take?

Not sure where to start? Pick the description that fits you best:

Use Cases

This guide helps you design systems for these real-world scenarios. Each row links to the chapters that matter most for that build:

Scenario What You're Building Core Chapters
Personal Second Brain Personal notes + papers + web clippings searchable via natural-language queries Ch02 · Ch05 · Ch08
Internal Company Knowledge Base Employees query policy / handbooks / runbooks — low hallucination bar, citations required Ch02 · Ch04 · Ch06
Developer Documentation Assistant Engineers query codebases / API docs / past incident postmortems across multi-repo environments Ch02 · Ch05 · Ch07
Support / QA Agent Customer or internal tickets → context-aware replies with cited sources and follow-up memory Ch03 · Ch06 · Ch04
Domain-Specific Knowledge Automation (legal, healthcare, finance, engineering) Reuse decades of domain documents — regulated, IP-sensitive, often requires local models and audit trails Ch02 · Ch09 · Ch12

If your scenario doesn't fit cleanly, it's probably a composition of these — start from the closest row and adapt.

The Evolution

2022-2024               2025                    2026                    2026 (mid)?             2026 (late)??
PROMPT ENG        -->   CONTEXT ENG       -->   HARNESS ENG       -->   LOOP ENG (emerging) --> GRAPH ENG (contested)
                        (Karpathy)              (Fowler, OpenAI)        (Steinberger, Osmani)   (Steinberger, Perez)

"Craft the              "Construct the          "Orchestrate the        "Design the system      "Wire the org
 perfect prompt"        dynamic context         entire system           that prompts            of agents that
                        window"                 around the model"       the agent"              run the loops"

Each generation does not replace the last -- it contains it. Harness engineering includes context engineering, which includes prompt engineering. Loop engineering, a still-contested fourth layer, wraps all three -- the system that runs the harness on a timer, spawns helpers, and feeds it back to itself. Graph engineering, the July 2026 claim covered in Ch14, would wrap even that -- the wiring of multiple loops into a designed organization -- though whether it is a real fifth layer or three-year-old practice with a new name (LangChain's counter) is exactly what its chapter leaves open.

The Lifecycle

The Ecosystem Map shows what the pieces are. The Lifecycle shows how data moves through them:

                    ┌───── feedback ──────────────┐
                    ▼                             │
 INGEST  ───▶ PROCESS  ───▶ STORE  ───▶ QUERY ───▶ IMPROVE
    │             │            │          │           │
 Docs          Chunking      Vector DB    RAG        Evals
 APIs          Embeddings    Graph DB     GraphRAG   Feedback
 Web clips     Cleaning      Cache        Agents     Fine-tune
 Crawlers      Multi-modal   Long doc     Tool use   Skill updates
    │             │            │          │           │
   Ch02       Ch02 · Ch03    Ch02-08    Ch02-07     Ch06

flowchart LR
    I[INGEST<br/>Docs · APIs · Webscrape] --> P[PROCESS<br/>Chunking · Embeddings · Cleaning]
    P --> S[STORE<br/>Vector DB · Graph DB · Cache]
    S --> Q[QUERY<br/>RAG · GraphRAG · Agents]
    Q --> M[IMPROVE<br/>Evals · Feedback · Fine-tune]
    M -. feedback .-> I

Every production system moves data through all five stages — even if some are implicit. A good harness design makes each stage inspectable and replaceable. Ch02 covers Ingest/Process/Store; Ch03–Ch07 cover Query; Ch06 and Ch10 cover Improve.

Ecosystem Map

LLM Knowledge Engineering Ecosystem Map

View interactive HTML version

+---------------------------+     +---------------------------+     +---------------------------+
|    KNOWLEDGE SOURCES      |     |   CONTEXT ENGINEERING     |     |   HARNESS ENGINEERING     |
|                           |     |                           |     |                           |
|  +---------------------+ | --> |  +---------------------+ | --> |  +---------------------+ |
|  | RAG Pipelines       | |     |  | Dynamic Context     | |     |  | Skill Systems       | |
|  | - Self-RAG          | |     |  |   Assembly          | |     |  | - Routing Logic     | |
|  | - Corrective RAG    | |     |  |                     | |     |  | - Progressive       | |
|  | - Adaptive RAG      | |     |  | KV-Cache            | |     |  |   Disclosure        | |
|  +---------------------+ |     |  |   Optimization      | |     |  +---------------------+ |
|                           |     |  |                     | |     |                           |
|  +---------------------+ |     |  | System Prompts      | |     |  +---------------------+ |
|  | Knowledge Graphs    | |     |  |   + Instructions    | |     |  | Memory Frameworks   | |
|  | - GraphRAG          | |     |  |                     | |     |  | - Short-term        | |
|  | - Entity Relations  | |     |  | Tool Definitions    | |     |  | - Long-term         | |
|  | - Multi-hop Queries | |     |  |   + Schemas         | |     |  | - Episodic          | |
|  +---------------------+ |     |  |                     | |     |  +---------------------+ |
|                           |     |  | Few-shot Examples   | |     |                           |
|  +---------------------+ |     |  |                     | |     |  +---------------------+ |
|  | Long Context        | |     |  | Conversation        | |     |  | MCP / Tool Layer    | |
|  | - 1M+ token windows | |     |  |   History           | |     |  | - Protocol Std      | |
|  | - Static doc ingest | |     |  +---------------------+ |     |  | - Tool Routing      | |
|  +---------------------+ |     +---------------------------+     |  | - Auth + Sandboxing | |
+---------------------------+                                       |  +---------------------+ |
                                                                    |                           |
                                                                    |  +---------------------+ |
                                                                    |  | Agent Runtime       | |
                                                                    |  | - Planning Loops    | |
                                                                    |  | - Error Recovery    | |
                                                                    |  | - Multi-agent       | |
                                                                    |  |   Coordination      | |
                                                                    |  +---------------------+ |
                                                                    +---------------------------+

graph LR
    subgraph Sources["Knowledge Sources"]
        RAG[RAG Pipelines]
        KG[Knowledge Graphs]
        LC[Long Context Windows]
    end

    subgraph Context["Context Engineering"]
        DCA[Dynamic Context Assembly]
        KVC[KV-Cache Optimization]
        SP[System Prompts + Instructions]
        TD[Tool Definitions + Schemas]
        FSE[Few-shot Examples]
        CH[Conversation History]
    end

    subgraph Harness["Harness Engineering"]
        SK[Skill Systems + Routing]
        MEM[Memory Frameworks]
        MCP[MCP / Tool Layer]
        AR[Agent Runtime + Planning]
        PD[Progressive Disclosure]
    end

    Sources --> Context --> Harness

Table of Contents

Chapters

# Chapter Description
01 The Three Generations From prompt engineering to context engineering to harness engineering
02 RAG, Long Context & Knowledge Graphs The knowledge retrieval layer -- what works, what doesn't, and why hybrid wins
03 Context Engineering The art of filling the context window -- KV-cache, the 100:1 ratio, dynamic assembly
04 Harness Engineering Building the OS around the model -- guides, sensors, and the 6x performance gap
05 Skill Systems & Skill Graphs From flat files to traversable graphs -- progressive disclosure in practice
06 Agent Memory The missing layer -- episodic, semantic, and procedural memory architectures
07 MCP: The Standard That Won Model Context Protocol -- from launch to 97M+ monthly downloads (Q1 2026)
08 AI-Native Knowledge Management Tools landscape -- Notion AI, Obsidian, Mem, and the AI-native gap
09 The Chinese AI Ecosystem Dify, RAGFlow, DeepSeek, Kimi -- a parallel universe of innovation
10 Case Study: A Real-World Knowledge Harness How one developer built a complete harness with 65% token reduction
11 Timeline Key moments in LLM knowledge engineering, 2022-2026
12 Local Models for Knowledge Engineering Run your knowledge harness locally -- embedding, RAG, compilation, and the fine-tuning endgame
13 Loop Engineering The emerging fourth layer -- designing the system that prompts the agent, and whether it is its own generation
14 Graph Engineering The contested fifth claim -- wiring the organization of agents, and whether it is more than a new name

Why This Guide Exists

The LLM ecosystem in 2026 has a fragmentation problem. Not a lack of information -- an excess of disconnected information.

There are mass surveys on RAG. Comprehensive prompt engineering guides. MCP specification documents. Agent framework comparisons. Memory system papers. Each one is excellent in isolation. None of them show you how the pieces fit together.

This guide is that missing layer. It connects RAG to context engineering, context engineering to harness engineering, harness engineering to agent runtimes -- and shows you the decisions that matter at each boundary.

Contributing

Contributions are welcome! This list is community-maintained.

Please keep the tone professional but accessible. Cite sources. No hype.

License

MIT License. See LICENSE for details.

Use this however you want. Attribution appreciated but not required.

Last updated: August 2026