Artificial intelligence program

KRATOS

Agnostic Multi-Harness Control Plane Engineering

Designing Deterministic Governance over Heterogeneous AI Agent Harnesses

$1,200

12 phases · 21 modules · capstoneHands-on lab · Kratos / bridle2 recorded tutorials / month · spoken in Spanish, English subtitles

Course roadmap · 12 phases

Phase 1

WIRE

Kratos / bridle

Phase 2

CONTRACTS

Request, result, receipt

Phase 3

WORK UNIT

State machine

Phase 4

SEAL

Lineup + human /seal

Phase 5

ADAPTERS

Normalized I/O

Phase 6

PIPELINE

Implementer → Reviewer

Phase 7

RECEIPTS

Content-bound evidence

Phase 8

OPERATOR

Deterministic delivery

Phase 9

HEALTH

Quotas and gates

Phase 10

SIDECARS

Researcher / auditor

Phase 11

BOUNDS

Agnosticism vs marketing

Phase 12

CAPSTONE

Governed work unit

Twelve technical phases. Twenty-one academic modules (I–XXI) live inside them. Coursework clock is not sealed. Same path as the accordion below.

Mission and vision

Mission

Train engineers to materialise HEFESTO's design space in a deterministic, auditable, fail-closed control plane over heterogeneous coding-agent CLIs.

Vision

A governed architecture that separates roles, state, and policy from harness adapters and agent CLIs, and that will not accept a delivery without verifiable evidence.

Why KRATOS CORE

KRATOS CORE is the advanced course after HEFESTO. HEFESTO asks how multi-agent and multi-harness infrastructure is designed correctly. KRATOS CORE asks how that engineering is materialised in a deterministic, auditable, fail-closed control plane.

The live system is a local sequential control plane over coding-agent CLIs, with registered adapters, execution contracts, a state machine, receipts, and delivery gates. If this page and `E:\bridle` disagree, bridle wins.

Who it is for

Graduates of HEFESTO, senior AI and agent-infrastructure engineers, platform architects, DevOps engineers, AI governance engineers, and technical leads who must govern heterogeneous coding and research agents. Not an introductory agents course.

What it is not

Not HEFESTO. HEFESTO teaches the design space on a student repo. This course teaches a governed, concrete implementation on the real Kratos / bridle product — not a classroom mock. Automatic failover, a director-LLM, and OpenRouter as backup stay out — Module XIX studies why those claims are currently no.

What you'll be able to do

Separate KRATOS (product / control plane) from BRIDLE (wire / execution system)
Write a provider-independent execution contract before the agent runs
Seat authority: who may propose, write, review, ship, and override
Run a fail-closed work unit through seal, review, receipt, and Operator
Refuse BEST EFFORT when a transition cannot be demonstrated

Course content

Phase 1 — WIRE 1 module

Module 1 — Kratos product / bridle wire Outline

KRATOS = product / control plane · BRIDLE = wire / execution Read

Phase 2 — CONTRACTS 2 modules

Module 1 — Contract-first architecture Outline + lab L2

CONTRACT before the agent Read

Lab L2 — Execution Contract Open lab

Module 2 — Role seats and authority Outline + lab L3

logical role ≠ harness ≠ model ≠ provider Read

Lab L3 — Authority Matrix Open lab

Phase 3 — WORK UNIT 1 module

Module 1 — Work-unit engineering Outline

The unit is the Work Unit, not the conversation Read

Phase 4 — SEAL 2 modules

Module 1 — Human sealing Outline

The LLM does not freeze its own scope Read

Module 2 — Lineup engineering Outline

ROLE + HARNESS + MODEL + PROVIDER as an explicit combination Read

Phase 5 — ADAPTERS 1 module

Module 1 — Harness adapter engineering Outline + lab L6

Normalized Request → Adapter → CLI argv → Normalized Result Read

Lab L6 — New adapter Open lab

Phase 6 — PIPELINE 4 modules

Module 1 — Correlation governance Outline + lab L8

Correlation mitigation ≠ fault independence Read

Lab L8 — Correlation Gate Open lab

Module 2 — Pipeline governance Outline

Governor → /seal → Implementer → Reviewer → Operator Read

Module 3 — Review contract Outline + lab L10

approved AND scope_ok, or NO SHIP Read

Lab L10 — Machine-verifiable review Open lab

Module 4 — Governor engineering Outline

Coordinates policy; does not implement; does not issue delivery verdict Read

Phase 7 — RECEIPTS 2 modules

Module 1 — Receipt engineering Outline

RECEIPT = plan_hash + candidate_hash + verification + decision Read

Module 2 — Evidence-first engineering Outline

.bridle/ ledger, units, receipts, runs, session Read

Phase 8 — OPERATOR 2 modules

Module 1 — Deterministic Operator Outline

Operator is software: no git add, no auto push, no product judgement Read

Module 2 — Fail-closed system design Outline

Undemonstrated transition → BLOCK, not BEST EFFORT Read

Phase 9 — HEALTH 1 module

Module 1 — Health, quotas and resource governance Outline

10% WARN · 5% CONFIRM · 0% BLOCK — and the real debt Read

Phase 10 — SIDECARS 2 modules

Module 1 — Researcher sidecar Outline

Knowledge without ship authority Read

Module 2 — Auditor and Challenger Outline

REVIEW ≠ CHALLENGE ≠ AUDIT Read

Phase 11 — BOUNDS 2 modules

Module 1 — Agnosticism: reality vs marketing Outline

Contract-agnostic yes · CLI-independent no · failover no Read

Module 2 — Documentation as governance Outline

CODE ≠ STALE DOCUMENTATION Read

Phase 12 — CAPSTONE 1 module

Module 1 — Capstone Outline

Governed Work Unit: /start → seal → receipt → Operator Read

Course content is Phase → Module → Chapter using KRATOS's twelve-phase path. Module numbers restart inside each phase. Labs remain chapters inside their module. Lecture bodies and lab procedures are not authored yet.

Instructor

Elmer Niño

Founder, VTAlgo Group · Systems Engineer · MSc in Computer Science

Algorithmic trader since 2009, running trading as an enterprise. Owner of Kratos: the control plane that governs coding-agent CLIs already on the desk — seal, seats, receipt — not another agent.

Programa de inteligencia artificial

KRATOS

Agnostic Multi-Harness Control Plane Engineering

Diseño de gobernanza determinista sobre harnesses heterogéneos de agentes de IA

$1,200

12 fases · 21 módulos · capstoneLab práctico · Kratos / bridle2 tutoriales grabados / mes · hablados en español, subtítulos en inglés

Mapa del curso · 12 fases

Fase 1

WIRE

Kratos / bridle

Fase 2

CONTRACTS

Request, result, receipt

Fase 3

WORK UNIT

Máquina de estados

Fase 4

SEAL

Lineup + /seal humano

Fase 5

ADAPTERS

I/O normalizado

Fase 6

PIPELINE

Implementer → Reviewer

Fase 7

RECEIPTS

Evidencia atada al contenido

Fase 8

OPERATOR

Entrega determinista

Fase 9

HEALTH

Cuotas y gates

Fase 10

SIDECARS

Researcher / auditor

Fase 11

BOUNDS

Agnosticismo vs marketing

Fase 12

CAPSTONE

Work unit gobernada

Doce fases técnicas. Veintiún módulos académicos (I–XXI) viven dentro de ellas. El reloj de cursada no está sellado. El mismo recorrido que el acordeón de abajo.

Misión y visión

Misión

Formar ingenieros para materializar el espacio de diseño de HEFESTO en un plano de control determinista, auditable y fail-closed sobre CLIs heterogéneas de agentes de código.

Visión

Una arquitectura gobernada que separa roles, estado y política de los adapters de harness y las CLIs de agente, y que no acepta una entrega sin evidencia verificable.

Por qué KRATOS CORE

KRATOS CORE es el curso avanzado posterior a HEFESTO. HEFESTO pregunta cómo se diseña correctamente la infraestructura multi-agent y multi-harness. KRATOS CORE pregunta cómo se materializa esa ingeniería en un plano de control determinista, auditable y fail-closed.

El sistema en vivo es un plano de control local y secuencial sobre CLIs de agentes de código, con adapters registrados, contratos de ejecución, una máquina de estados, receipts y gates de entrega. Si esta página y `E:\bridle` discrepan, gana bridle.

A quién va dirigido

Graduados de HEFESTO, ingenieros senior de IA e infraestructura de agentes, arquitectos de plataforma, ingenieros DevOps, ingenieros de gobernanza de IA y technical leads que deban gobernar agentes heterogéneos de código y research. No es un curso introductorio de agentes.

Qué no es

No es HEFESTO. HEFESTO enseña el espacio de diseño en el repo del alumno. Este curso enseña una implementación gobernada y concreta sobre el producto real Kratos / bridle — no un mock de aula. El failover automático, un director-LLM y OpenRouter como backup quedan fuera — el Módulo XIX estudia por qué esas afirmaciones hoy son no.

Lo que vas a poder hacer

Separar KRATOS (producto / plano de control) de BRIDLE (cable / sistema de ejecución)
Escribir un execution contract independiente del proveedor antes de que corra el agente
Sentar autoridad: quién puede proponer, escribir, revisar, entregar y override
Correr una work unit fail-closed por sello, review, receipt y Operator
Rechazar BEST EFFORT cuando una transición no se puede demostrar

Contenido del curso

Phase 1 — WIRE 1 module

Module 1 — Kratos product / bridle wire Outline

KRATOS = product / control plane · BRIDLE = wire / execution Read

Phase 2 — CONTRACTS 2 modules

Module 1 — Contract-first architecture Outline + lab L2

CONTRACT before the agent Read

Lab L2 — Execution Contract Open lab

Module 2 — Role seats and authority Outline + lab L3

logical role ≠ harness ≠ model ≠ provider Read

Lab L3 — Authority Matrix Open lab

Phase 3 — WORK UNIT 1 module

Module 1 — Work-unit engineering Outline

The unit is the Work Unit, not the conversation Read

Phase 4 — SEAL 2 modules

Module 1 — Human sealing Outline

The LLM does not freeze its own scope Read

Module 2 — Lineup engineering Outline

ROLE + HARNESS + MODEL + PROVIDER as an explicit combination Read

Phase 5 — ADAPTERS 1 module

Module 1 — Harness adapter engineering Outline + lab L6

Normalized Request → Adapter → CLI argv → Normalized Result Read

Lab L6 — New adapter Open lab

Phase 6 — PIPELINE 4 modules

Module 1 — Correlation governance Outline + lab L8

Correlation mitigation ≠ fault independence Read

Lab L8 — Correlation Gate Open lab

Module 2 — Pipeline governance Outline

Governor → /seal → Implementer → Reviewer → Operator Read

Module 3 — Review contract Outline + lab L10

approved AND scope_ok, or NO SHIP Read

Lab L10 — Machine-verifiable review Open lab

Module 4 — Governor engineering Outline

Coordinates policy; does not implement; does not issue delivery verdict Read

Phase 7 — RECEIPTS 2 modules

Module 1 — Receipt engineering Outline

RECEIPT = plan_hash + candidate_hash + verification + decision Read

Module 2 — Evidence-first engineering Outline

.bridle/ ledger, units, receipts, runs, session Read

Phase 8 — OPERATOR 2 modules

Module 1 — Deterministic Operator Outline

Operator is software: no git add, no auto push, no product judgement Read

Module 2 — Fail-closed system design Outline

Undemonstrated transition → BLOCK, not BEST EFFORT Read

Phase 9 — HEALTH 1 module

Module 1 — Health, quotas and resource governance Outline

10% WARN · 5% CONFIRM · 0% BLOCK — and the real debt Read

Phase 10 — SIDECARS 2 modules

Module 1 — Researcher sidecar Outline

Knowledge without ship authority Read

Module 2 — Auditor and Challenger Outline

REVIEW ≠ CHALLENGE ≠ AUDIT Read

Phase 11 — BOUNDS 2 modules

Module 1 — Agnosticism: reality vs marketing Outline

Contract-agnostic yes · CLI-independent no · failover no Read

Module 2 — Documentation as governance Outline

CODE ≠ STALE DOCUMENTATION Read

Phase 12 — CAPSTONE 1 module

Module 1 — Capstone Outline

Governed Work Unit: /start → seal → receipt → Operator Read

Instructor

Elmer Niño

Fundador, VTAlgo Group · Ingeniero de Sistemas · MSc en Ciencias de la Computación

Trader algorítmico desde 2009, que lleva el trading como una empresa. Owner de Kratos: el plano de control que gobierna las CLIs de agente de código que ya están en el escritorio — seal, asientos, receipt — no otro agente.