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 mid-July 2026 waves added a new Chapter 13 on Loop Engineering and two further timeline entries, on top of twelve earlier timeline entries and the early-June wave. Most recent first (full chronological log: CHANGELOG.md):

  • 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)

From the early-June wave (full detail in CHANGELOG.md):

  • June 2 Microsoft Build — MAI-Thinking-1 + MAI-Code-1-Flash — Microsoft ships its first in-house reasoning model (reported trained without OpenAI data) plus a 5B coding model trained directly against the production GitHub Copilot harnesses. The framework beat: harness-native training is the symmetric inverse of harness synthesis — instead of evolving the harness for a fixed model, you shape the model to fit a fixed harness (Ch04 §4.5, Ch11, glossary)
  • June 1 IETF MCP security I-D (draft-mohiuddin-mcp-security-considerations-00) — the first standards-track document scoped to MCP security, opening on "The MCP specification does not define normative security requirements." Catalogs six vulnerability classes (SSRF, excessive tool permissions, prompt-injection surface, lifecycle bypass, information leakage, auth-enforcement gaps) with mitigations + the open-source mcp-safeguard scanner; MCP security maturation moves out of the vendor spec into independent scrutiny (Ch07, Ch11)

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).
  • 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)?
PROMPT ENG        -->   CONTEXT ENG       -->   HARNESS ENG       -->   LOOP ENG (emerging)
                        (Karpathy)              (Fowler, OpenAI)        (Steinberger, Osmani)

"Craft the              "Construct the          "Orchestrate the        "Design the system
 perfect prompt"        dynamic context         entire system           that prompts
                        window"                 around the model"       the agent"

Each generation does not replace the last -- it contains it. Harness engineering includes context engineering, which includes prompt engineering. Loop engineering, the newest and still-contested layer, wraps all three -- the system that runs the harness on a timer, spawns helpers, and feeds it back to itself.

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

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: July 2026