Engineering Series · Course 5 of 6
// The document is the AI OS layer, engineered.

Context Architecture.
The pipeline that makes AI systems smart.

Context engineering as a production discipline. Audit, classify, store, route, filter, serve. Permission-filtered knowledge orchestration. Beyond RAG. Built on CM's Context Kubernetes paper (2604.11623).

29
lessons
6
modules
6–8
weeks self-paced
Get on the waitlist
€197 waitlist
Self-paced · Built on arXiv 2604.11623 · Full code repo (Apache 2.0)
The gap

A simple prompt with rich context beats
a perfect prompt with no context.

The industry spent two years optimizing prompts. Prompt engineering. Prompt libraries. Mega-prompts. Chain-of-thought prompts. Most of it was solving the wrong problem.

The prompt is the instruction. Context is the knowledge. An instruction without knowledge produces plausible garbage. Knowledge with a simple instruction produces useful output.

A basic prompt — "summarize this for the board" — with rich, permission-filtered context about the project, the board's priorities, the previous meeting's decisions, and the current quarter's numbers produces better output than any engineered prompt without that context.

Context is not "RAG." Context is not "upload a PDF." Context is a production pipeline that audits what you have, classifies it by type and sensitivity, stores it efficiently, routes the right context to the right agent at the right time, filters by permission level, and serves it in the right format.

The quality of AI output is bounded by the quality of context provided. Not by the cleverness of the prompt.
The context pipeline · 6 stages

Each stage is an engineering decision.

From organisational knowledge audit to permission-filtered serving at enterprise scale. Six stages, each with measurable engineering choices. The output of one is the input of the next.

01 audit What context exists. What's missing. What's stale.
02 classify Type. Sensitivity. Freshness level.
03 store Vector. Graph. Key-value. Hybrid.
04 route Which context for which agent.
05 filter Permission level. Who sees what.
06 serve Right format, right time, right agent.
// arXiv 2604.11623 — Context Kubernetes. Three-tier permission model: 0/5 attacks blocked by flat permissions → 5/5 by three-tier.
The method

29 lessons. 6 modules.
From context audit to enterprise knowledge orchestration.

This is not a RAG tutorial. This is the full production context engineering pipeline, from organisational knowledge audit to permission-filtered serving at enterprise scale.

Module 1 · Primer 01
"The hidden discipline."

Context Engineering

Why context matters more than the model (the model is a commodity; context is the moat). The shift from prompt engineering to context architecture. Organisational knowledge as infrastructure. The folklore problem: knowledge in heads, not systems. Git as context store.

Lab: Audit a sample enterprise's knowledge landscape
4 lessons
Module 2 02
"From naive to production."

RAG Architecture

Naive RAG (chunk → embed → retrieve → generate) and why it breaks. Advanced RAG: re-ranking, hybrid search, query decomposition, self-RAG. Agentic RAG: retrieval as a tool the agent decides when to use. Vector databases compared (Pinecone, Weaviate, ChromaDB, Qdrant). Evaluation: MRR, NDCG, relevance@k.

Lab: Build a production RAG pipeline (naive → advanced)
5 lessons
Module 3 03
"The right data to the right agent."

Context Routing

context-router architecture and API. Intent classification (understand the query before retrieving). Multi-source routing: different questions, different data sources. Rule-based vs LLM-assisted routing with confidence fallback. Freshness enforcement: don't answer with stale data.

Lab: Implement context-router with 4 enterprise data sources
5 lessons
Module 4 04
"Who sees what."

Permission-Aware Context

The critical principle: the agent should never see more than the user is allowed to see. Role-based context filtering at the retrieval layer. The Context Kubernetes permission model (sessions, roles, domains). The 2-stage isolation filter: pre-retrieval and post-generation. Preventing data leakage.

Lab: Add role-based access control to context-router
4 lessons
Module 5 05
"Enterprise knowledge orchestration."

Context Kubernetes

The Context Kubernetes architecture from the arXiv paper (2604.11623). Declarative context architecture: manifests and domains. The CxRI (Context Resource Interface): standardized connectors to data sources. Reconciliation loops keeping the knowledge graph current. Three-tier permission model.

Lab: Deploy context-kubernetes prototype with security experiments
5 lessons
Module 6 · Capstone 06
"The Enterprise Knowledge System."

The Capstone

Multi-source: database, document store, API, git repo. Context Router with intent-based routing. Role-based access control with 3 user roles. Freshness enforcement and reconciliation loops. Integration with the E3 accountable agent (governed context). Full audit trail of every context access. The data layer of the Enterprise AI OS.

6 lessons + capstone
The capstone arc · across the series

One project. Six courses. Six layers.

In E5 your hardened E4 capstone gets the full context layer. The same project carries forward to E6 for the full Enterprise AI Operating System assembly.

E1 · Done
Foundation
Versioned prompts. Multi-model. MCP. GRAIL eval. Logging.
E2 · Done
+ Trust
Self-consistency. TrustGate. Reliability guarantees. Drift detection.
E3 · Done
+ Governance
7 services. Platform Protocol. ~15 APIs.
E4 · Done
+ Security
Guardrails. Agent Auth. Sandboxing. Red-team tested.
E5 · Now
+ Context
Multi-source. RAG. Context Router. RBAC.
E6
Full Platform
All 4 layers. Org Agents. Intelligence. Desktop Shell.
Prerequisites & tech stack

What you need. What you'll use.

Prerequisites

E1 and E3 completed (E2 and E4 recommended), or equivalent experience building secured, accountable AI agents. Basic understanding of databases and data architecture.

Tech stack

Python 3.12, FastAPI, PostgreSQL 16 with pgvector, Redis 7, Gitea, Docker Compose, ChromaDB or Qdrant. Open-source repos (Apache 2.0): context-router, context-kubernetes.

Honestly

This is for you if:

→You're building AI systems that need access to organisational knowledge
→You've done "RAG" and want the production version with permissions and routing
→You need permission-filtered context serving (different roles see different data)
→You've completed E1-E4 or have equivalent production AI experience
→You want AI systems actually smart about your organization, not just the internet

Don't take this if:

→You want to learn prompt engineering. Context beats prompts. That's the point.
→You haven't built production AI systems yet. Start with E1.
→You want a RAG tutorial. This goes far beyond retrieval.
Pricing

One price. Lifetime access.

€197
One-time payment. All future updates included.
  • 29 lessons across 6 modules (video, written, runnable code)
  • Context audit framework with templates and methodology
  • Production RAG pipeline (naive to advanced) and Context Router
  • Permission filtering system with role-based access control
  • Annotated arXiv 2604.11623 walkthrough and full code repo (Apache 2.0)
3 months in the Engine Room. Where alumni and operators go to get unstuck.
Get on the waitlist

Want all six courses?

See the Engineering Series bundle →
FAQ

Before you ask.

Anything else? Email [email protected].

Is this just RAG, or beyond?
Beyond. RAG is module 2. Modules 3–5 build context routing (different queries hit different stores), permission-aware context (the same query returns different documents depending on who's asking), and Context Kubernetes (orchestration across many context sources). RAG is the entry point, not the destination.
What's 'Context Kubernetes'?
The term from CM's arXiv paper 2604.11623. It's the orchestration layer for context: which sources to query, in what order, with what filters, with what budget. Module 5 builds it. Think of it as the routing layer for an AI system's memory.
Vector DB requirement? Which one?
The course uses Qdrant in examples (open-source, runs in Docker). The patterns translate to pgvector, Weaviate, or commercial vector DBs. You can complete the course on a laptop with Qdrant in Docker.
Do I need E1–E4 first?
E1 strongly. E2–E4 helpful but not strict prerequisites. If you're already a RAG practitioner, you can take E5 standalone — but the GRAIL Loop and evaluation patterns from E1 are assumed.
Will this work for an enterprise with 50M docs and granular ACLs?
Module 4 (Permission-Aware Context) is built around that exact problem. The capstone is the architecture pattern, not a hosted product — you'll adapt it to your storage and IAM stack.
Time commitment?
25–35 hours across 6 modules. Module 4 (Permission-Aware Context) and Module 5 (Context Kubernetes) are the densest.
Can my company pay for this?
Yes. Invoices issued. Email [email protected] subject 'Reimbursement.'
What's the refund policy?
€197 courses are non-refundable once you open the course. Unopened, they are refundable in full within 14 days of purchase. The Engineering Series bundle (€797) offers a 14-day conditional refund.

The document is the AI OS layer.

Engineered. Audit, classify, store, route, filter, serve. The pipeline that makes AI systems actually intelligent about your organization. €197.

Get on the waitlist
See the full series: The Engineering Series