Beyond RAG: From Demo to Production-Grade Context Blocks

Get tickets for this workshop!

Build a real Context Block, learn the advanced context-engineering skills rarely covered in depth — typed ontologies, evals for context, governance, self-evolving — and leave with a repeatable method you can apply next week.

THE PROBLEM
You’ve built agents on RAG and hit the wall: they hallucinate, don’t know your domain, and confidently give wrong answers. You dumped your docs into a vector DB and it still isn’t enough — because RAG can’t retrieve what was never written down. The hardest, most valuable knowledge — the tribal “we always check X first,” the undocumented conventions — lives in people’s heads, not your corpus. This isn’t a model problem or a prompt problem. It’s a context problem — and almost nobody teaches how to solve it.

WHAT THIS DAY IS
Three things at once: you build a working Context Block, you learn the advanced concepts practitioners are confused about (typed ontologies, evals for context, governance, self-evolving), and you solve the real problem — an agent that knows your domain and knows what it doesn’t. All hands-on, on a provided sample domain you run locally, ending with a sketch and the open-source repo you can plug into your own system next week.

WHO IT’S FOR
AI/ML engineers and practitioners building or improving agent/RAG systems who’ve felt the “confidently wrong” wall. Prerequisites: laptop, Python, an LLM API key, comfort with the CLI. No ontology/semantic-web background needed — that’s the point. Participants modify config files and run scripts; deep framework coding is optional.

WHAT YOU WALK OUT WITH
– A working Context Block you built yourself (sample domain, plus a template for your own).
– A repeatable method (demand-driven: let agent failures tell you what to curate).
– Hands-on fluency in the advanced layer: lightweight ontologies (YAML, not OWL), evals for context, calibrated honesty, a governance plane, and the self-evolving loop.
– The open-source toolkit running locally and a concrete plan to start on your own domain.

AGENDA (full day)
Throughout, we use a pre-built open-source extractor, entity templates, and context-eval scripts, so participants focus on design and interpretation, not wiring.

1. Feel the problem (45 min) — Run a RAG agent on the sample domain with no curated context and watch it hallucinate; quick reflection on what failed and what it missed.
2. BUILD — Demand-Driven Context (2 hrs) — The demand-driven method and the 5-class knowledge model (Clean/Stale/Incomplete/Missing/Tribal); why RAG can’t reach tribal knowledge. Run the extractor on real work items, read the gap report, curate entities, wire them in, and see your own before/after.
3. HARDEN — Structure & Honesty (1h45) — Typed structure via lightweight ontologies (YAML, not OWL); bounded contexts; calibrated honesty (confidence + provenance). Refactor one big file into purpose-scoped blocks and make the agent flag what it doesn’t know.
4. MEASURE & GOVERN (1h30) — Evals for context (everyone evals models and prompts; nobody evals their context); the governance plane (review-state, ownership, approvals); the self-evolving loop. Run a context-eval script, set up a simple review flow, and run a demand wave to watch the block evolve.
5. APPLY — Your Domain (45 min) — Using a one-page template, sketch your own domain’s first work items, candidate blocks, and governance owners. Q&A. Leave with the toolkit and a plan.