Engineering Series · Course 6 of 6
// Assemble the full platform. Ship it.

The Enterprise AI OS.
docker compose up and it runs.

Every component from E1-E5 assembled into one running platform. Add the missing layers (organisational agents, intelligence systems, desktop shell). The capstone of the Engineering Series.

26
lessons
6
modules
10–12
weeks self-paced
Get on the waitlist
€197 waitlist
Self-paced · Built on the full Engineering Series · Full code repos (Apache 2.0)
The gap

You've built the parts.
Now assemble the platform.

You finished E1-E5. A production API layer. A trust measurement system. An accountable agent architecture. A security posture. A context pipeline. Five capstones. Each does one thing well.

An enterprise doesn't need five separate systems. It needs one platform. One platform where agents are governed by default, trust is measured on every output, security is tested and monitored, context is permission-filtered, and every decision has an audit trail.

One platform you can deploy with docker compose up and hand to an ops team that didn't build it. That's the difference between a portfolio of demos and an operating system.

A platform that compounds value instead of compounding risk.
The complete architecture · 4 layers

Every layer assembled. The full Enterprise AI OS.

Two layers you built across E1-E5. Two new layers in E6. One running platform. Each layer has one job. The seams are the contract.

Layer 4 apps
Desktop Shell (Tauri) + AIOS Connector + forked agent core. The employee experience. Six minutes, three tasks, governance invisible.
Built in E6
Layer 3 platform
Trust & Governance Middleware. Seven services: auth, guardrails, actions, context, gateway, monitor, audit. The Platform Protocol (~15 APIs).
E3 + E4
Layer 2 org intelligence
Organisational Agents (certified, version-controlled, company assets). Domain Intelligence Systems with knowledge store, isolation filter, learning loop.
Built in E6
Layer 1 data & context
Git-versioned context repos + database connectors + Connector Framework. context-router. context-kubernetes. Permission-filtered knowledge.
E5
// E6 builds the two missing layers and assembles all four into one deployable platform. docker compose up.
The method

26 lessons. 6 modules.
From components to a deployed platform.

This is not a lecture course. You assemble every component from E1-E5 into a running platform, build the missing layers, deploy two certified AI systems, and hand off the documentation. Module 6 is the capstone build.

Module 1 01
"The AI Factory."

From Components to Platform

Review the 4-layer architecture and what E1-E5 already built. The "AI Factory" concept: build the platform once, deploy AI systems in days. Six implementation paths compared (Microsoft, Salesforce, AWS, Google Cloud, Databricks, DIY) and the AIOS Quadrant (deep governance + vendor-neutral) where no path fits.

Lab: Map E3 middleware + E5 context to the full architecture
4 lessons
Module 2 02
"Company assets, not personal assistants."

Layer 2: Organisational Agents

Local agents (Layer 4) belong to employees. Organisational agents (Layer 2) belong to the company. Triggered by events, schedules, or other agents. Certified before deployment, version-controlled, monitored. The certification chain: process → permissions → guardrails → reliability → monitoring. Invoked through Layer 3, never directly.

Lab: Build and certify an Invoice Processing org agent
3 lessons + lab
Module 3 03
"The organization's institutional memory."

Layer 2: Intelligence Systems

Why fifty agents reinventing the wheel is not enough. The five components: Knowledge Store, Reasoning Engine, Isolation Filter, Learning Loop, Domain Guardrails. Ingestion pipelines (git webhooks, DB polling, agent logs). The 2-stage Isolation Filter: pre-retrieval scope + post-generation scan. The Learning Loop: signals → patterns → insight delivery. Aggregation rules that respect access boundaries.

Lab: Build a Sales Domain Intelligence System with isolation filter
5 lessons + lab
Module 4 04
"What your users actually see."

Layer 4: The Employee Experience

Three components of a Local AI System: Desktop Shell (UI), Agent Core (reasoning), AIOS Connector (bridge). The Connector implements the Platform Protocol (~15 calls): Auth Client, Context Client, Action Client, Org Intelligence Client, Cost Reporter. Workspace model: multiple contexts, persistent memory. The approval experience: Tier 2 (inline) vs Tier 3 (separate device).

Lab: Build the Desktop Shell + AIOS Connector against E3 middleware
4 lessons + lab
Module 5 05
"Architecture is choices."

The 12 Decisions + Systems Portfolio

Twelve decisions before deploying: middleware location, gateway vs direct, data-as-context, permission granularity, guardrail language, first intelligence domains, local agent strategy, LLM strategy, context versioning, monitoring boundary, migration strategy, reliability standard. The Accountable Systems Portfolio: augmentation → automation → autonomous. ROI tied to hard KPIs, not "productivity."

5 lessons
Module 6 · Capstone 06
"From blueprint to running platform."

The 90-Day Plan + The Final Build

Phase 1 (weeks 1-4): context audit, 12 decisions, middleware skeleton. Phase 2 (5-8): full trust layer, guardrails, action control, gateway, monitoring. Phase 3 (9-12): local agents to 5-10 users, first domain intelligence, reliability cert. Phase 4 (month 4+): full rollout. Capstone: deploy the full 4-layer Enterprise AI OS with two certified systems (one Augmentation, one Automation) and hand off the documentation.

5 lessons + capstone
The capstone arc · across the series

One project. Six courses. Four layers.

E6 is where it all converges. The same project that started as a versioned API in E1 now ships as a 4-layer Enterprise AI Operating System with two certified AI systems running on it.

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 · Done
+ Context
Multi-source. RAG. Context Router. RBAC.
E6 · Now
Full Platform
All 4 layers. Org Agents. Intelligence. Desktop Shell.
Prerequisites & tech stack

What you need. What you'll use.

Prerequisites

E1 to E5 completed. If you've shipped the prior capstones, you have the components. E6 teaches you to compose them into one running platform.

Tech stack

Python 3.12, FastAPI, PostgreSQL 16 + pgvector, Redis 7, Gitea, LiteLLM, Authlib, Tauri (desktop), Docker Compose. All six Cohorte open-source repos. Apache 2.0.

Honestly

This is for you if:

→You've completed E1-E5 and want to assemble the full platform
→You're an AI systems architect building enterprise-grade platforms
→You want a portfolio piece that proves you can ship and operate, not just demo
→You need to hand a platform to an ops team with full documentation
→You want the capstone that ties the entire Engineering Series together

Don't take this if:

→You haven't completed E1-E5. Assembly assumes the parts.
→You want to learn one skill. Take the specific E-course.
→You want theory or strategy slides. This is one hundred percent build.
Pricing

One price. Lifetime access.

€197
One-time payment. All future updates included.
  • 26 lessons across 6 modules (video, written, runnable code) plus the Final Build capstone
  • Certified Organisational Agent + Domain Intelligence System with isolation filter
  • Desktop Shell (Tauri) + AIOS Connector + Platform Protocol (~15 APIs)
  • The 12 Decisions Document + 90-Day Implementation Plan templates
  • docker compose production deployment, runbook, monitoring config, full code repos (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].

Do I have to complete E1–E5 to take this?
Yes. E6 is the capstone — it assembles every component from E1–E5 into one running platform. The €797 Engineering Series bundle is the correct path if you're heading here. Buying E6 standalone is possible but not recommended.
What ships at the end? Demo or real platform?
A running platform. 'docker compose up' starts the full Enterprise AI OS on your machine: the four-layer architecture, two certified AI systems, observability, audit, HITL, the works. It's a reference implementation you adapt to your org, not a demo.
Can I use this with my company's actual data?
Yes, with sensible caution. The platform is yours to deploy in your VPC, with your auth, your storage, your models. It's reference architecture + working code. CM's done this with real enterprise data — the patterns are battle-tested.
Open-source license on the code?
Apache 2.0 for the entire codebase. You can use it commercially, modify it, integrate it into proprietary stacks. No copyleft, no enterprise license tier.
Stack requirements?
Docker, Python, PostgreSQL with pgvector (included), an LLM API key (or self-hosted via E1 patterns). Runs on a laptop for development. Production deployment guidance for AWS / GCP / Azure / on-prem in module 6.
Time commitment?
25–35 hours across 6 modules. The 90-Day Plan in module 6 is the actual rollout plan you can take to a CTO.
Can my company pay for this?
Yes — especially the bundle (€797), which is the typical purchase path. 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 right purchase if you want refundability.

Assemble the full platform.
Ship it.

Four layers. Seven services. Two certified AI systems. docker compose up and it runs. The portfolio piece. €197.

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