Section 2 — The Delegation Gradient

The Tiers of Context Engines

Same competence, different runtime. Whether the planner runs in your head, inside a copilot, on a configured platform, or in your codebase — you are always running a context engine.

Tier 3

Human Context Engine

the user IS the planner

You decide what to load, what to keep, what to verify. Maximum control, minimum leverage. Every knowledge worker using a copilot well in 2026 is unconsciously running one of these.

manual RAG (paste docs) manual instructions manual memory (re-paste) human verification mental planner copy / paste loop
Who runs it

The user, in their head and across browser tabs.

Where the language layer sits

Prompts — sometimes long, structured, with pasted context.

Concrete example
user→opens ChatGPT
user→pastes 3 PDFs
user→writes role + task
user→checks output by hand
Tier 2

Embedded Context Engine

the planner runs inside the product

Inside Claude, ChatGPT, Gemini, Copilot. The planner is hidden behind the UI; the user shapes context through Projects, Memory, Connectors, Skills. Mastery here is the new floor.

Projects / Workspaces persistent Memory Skills MCP Connectors file ingestion (auto-RAG) tool use loops in-product moderation
Who runs it

The product. The user owns documents, instructions, and judgment over outputs.

Where the language layer sits

Context — system instructions + project files + retrieved memory + tools.

Concrete example
claude→Project + Skills
claude→auto-loads PDFs
claude→plans tool calls
claude→cites + outputs
Tier 1.5

Platform Context Engines

configured, not coded

Productized Tier 1. Pre-engineered orchestrators with governance, observability, and integration built in — you configure agents, connect data, define workflows. The choice is no longer “build or buy.” It is “which platform fits the integration gravity we already have?”

configured agents vendor orchestrator managed RAG / connectors enterprise governance audit + observability low-code workflows
Who runs it

The vendor owns the orchestrator. You own configuration, data sources, and workflow definition.

The trade-off

Less control than Tier 1; more control than Tier 2. Less work than Tier 1; more work than Tier 2. Lock-in to the vendor's abstractions and integration ecosystem.

Need → platform fit
AWS infra + securityBedrock Agents
Microsoft ecosystemAzure AI Foundry
Observability + analyticsVertex AI
CRM / customer opsAgentforce
HR / Finance / ITwatsonx Orchestrate
ITSM automationServiceNow
RPA + AI agentsUiPath
No-code conversationalKore.ai
Low-code workflown8n
Tier 1

Engineered Context Engine

API + vector store + fleet

Glass-box architecture. Planner / Executor / Tracer over a typed agent registry, dual RAG, MCP transport, observability. Maximum leverage, maximum upfront engineering. The Rothman pattern. Chosen when no platform fits or when full control is non-negotiable.

Planner + Executor + Tracer Agent Registry (fleet) dual RAG (procedural + factual) GraphRAG / multimodal vector store (Pinecone / 23ai) MCP transport moderation + defense audit trace
Who runs it

An engineering team. Production system; deterministic-ish; auditable.

Where the language layer sits

Engine — context as compiled artifact: typed packets, schemas, traces.

Concrete example
engine→Planner.decompose()
engine→Registry.dispatch()
engine→RAG.retrieve()
engine→Tracer.audit()
Control
maximum — Tier 3minimum — Tier 1
Leverage / scale
minimum — Tier 3maximum — Tier 1
The thesis

Prompts are sentences. Contexts are documents. Engines are compilers.
The new architectural skill in 2026 is not “build or buy.” It is knowing which tier a problem belongs in — and increasingly, whether the answer is a platform you configure rather than a system you build.