Chapter 16 — Reps

The final conditioning. Each rep rehearses one organ of the AI-native architecture so the whole body holds together when you assemble it in the capstone. Do them in order — they build the document set the final asks for.

Ground rules

• Type it yourself. Draw the diagrams by hand at least once. Architecture you cannot draw from a blank page is architecture you do not own.
• Run everything. The two scripts in code/ run with python3. Run them, change the inputs, watch the numbers move. Predict the answer before you run it.
• Predict before you measure. Every rep with a number asks you to guess first, then compute. The gap between your guess and the answer is the lesson.
• AI policy — Phase 2, the final week (AI is ON and agentic). Use AI the way you will in the field: to draft, to size, to challenge your architecture. But every rep ends in a judgment an agent cannot make — a recommendation defended, a tradeoff committed to, a date you verified against a primary source, an owner you named. Keep an honest running note of what you delegated and where it was wrong; that note is the seed of your capstone agent-log.txt. The architecture decisions are yours. The agent may draft prose and YAML; it may not decide where the judgment lives.
• Date every fast-moving fact “as of mid-2026,” and pin model IDs / SKU codes / version lines, never “latest.”

Reps 1–3: See the Whole Body

Rep 1 — The two-lane reference architecture, from a blank page

On paper (or a whiteboard tool), draw the AI-native reference architecture as two lanes — a training/pipelines lane and a GenAI inference lane — sharing a GPU pool, sitting on one Kubernetes control plane, with one observability backbone and one governance spine. Label every layer of the §16.1 table with both its traditional half and its AI half.

Then check yourself against code/inference-platform.yaml: did your inference lane include a serving engine, a runtime, a model source, a pinned model ID, and the governance hooks (telemetry, audit log, agent interop, spend cap)?

Reflect: Which cell of the table was hardest to fill from memory? That is the organ you understand least — go re-read its chapter before the final.

Rep 2 — Name the AI half of every organ

For each of the five traditional components on the capstone canvas — identity, virtualization, monitoring, security, backup — write one sentence naming its AI half as a tool and one naming its AI half as a workload. Example for storage: tool = AI-assisted data classification/tiering; workload = sizing and protecting model weights, vector DBs, and embeddings.

Reflect: Where did “tool” and “workload” collapse into the same answer? Those are the organs where the two threads are most entangled — flag them for extra care.

Rep 3 — Bet on standards, not brands

List the five durable open standards an AI-native architecture should bet on (per §16.1 and the brief). Beside each, name one 2026 product that implements it — and one product in the same space that was renamed, deprecated, or relicensed in the last 18 months.

Reflect: If every product you named disappeared tomorrow, would your architecture survive? Standards survive renames; brands do not. That is the whole point.

Reps 4–6: Governed Autonomy

Rep 4 — Build the autonomy ladder

Open code/autonomy-ladder.yaml. Add three new ops actions of your own — for example drain_node, apply_terraform_plan, block_ip_at_firewall. For each, assign a tier (observe / recommend / approve / act), state the guardrails, and write a one-sentence rationale grounded in reversibility and blast radius.

# validate your YAML parses (no schema enforcement — just well-formedness)
python3 -c "import yaml,sys; yaml.safe_load(open('code/autonomy-ladder.yaml')); print('ok')"

Reflect: Which of your three actions did you want to put on “act” for the demo, but had to keep at “approve” or “recommend”? Name the temptation. That gap is governed autonomy.

Rep 5 — Break the ladder on purpose

Take one irreversible action (delete_persistent_volume) and one security-sensitive action (rotate_credential) and move each up to the act rung. Write a short paragraph for each describing the specific disaster a prompt injection or confident-wrong agent could now cause, mapped to OWASP LLM06 (Excessive Agency) and the lethal trifecta.

Reflect: Apply Meta’s “Rule of Two.” For each broken action, which two of {untrusted input, sensitive-data access, ability to change state} were present — and what made adding the third unsafe?

Rep 6 — Map a workflow to the regulation

Take one autonomous remediation workflow (event → diagnose → remediate → verify). Map it to EU AI Act Art. 14 (human oversight) and Art. 12 (logging), and to the four NIST AI RMF functions (Govern / Map / Measure / Manage). Then do the part an agent cannot: go find the current EU AI Act high-risk enforcement date yourself from a primary or reputable source, and write down both the date and its adoption status as of the day you looked.

Reflect: Why does an architect design the logging and oversight before the deadline is settled? (Hint: re-read the §16.4 lesson about designing for the regulation to move.)

Reps 7–9: Size and Cost the Estate

Rep 7 — Size the AI estate

Predict, then compute, the VRAM for serving a 70B model at INT4 with a 32K-context KV cache, and the raw storage for a 5M-vector store at 1536 dims in float32. Use the rules from the brief (~0.5 GB/B at INT4; vector bytes = N × dims × bytes/component, 4 bytes for float32; add ~8×M bytes/vector HNSW overhead at M=32).

Reflect: Did the KV cache or the index overhead surprise you? At long context the KV cache can exceed the weights; that is the trap that blows a GPU budget.

Rep 8 — Run the cost crossover

python3 code/estate_cost.py

Then change MONTHLY_INPUT_TOKENS and MONTHLY_OUTPUT_TOKENS to find the volume where self-hosting an 8×H100 node beats every per-token API in the table. Write the crossover volume down. Then write a two-sentence recommendation for a real org at 500M tokens/month: self-host or API, and why.

Reflect: Output tokens cost 4–8× input, and agentic stacks multiply call counts. How did that change where the crossover landed?

Rep 9 — Classify the stack by license

Take the full 2026 inference stack (Kubernetes, GPU Operator, vLLM, KServe, NIM, Open WebUI, an AIOps agent of your choice, a vector DB). Classify each as open-source / commercial / source-available, and flag the ones that changed license or owner recently. Then justify, in three sentences, a stack chosen to minimize lock-in.

Reflect: Which single dependency would hurt most if it were relicensed tomorrow? That is your concentration risk — name a fallback for it now.

Reps 10–11: Governance and Continuity

Rep 10 — Fill the governance checklist

Open code/governance-checklist.txt. Fill every cell of the ten-row control table for a hypothetical AI-native org: name a (fictional but specific) human owner, the concrete artifact, and the gate/cadence for each control. No empty owner cells.

Reflect: Which control was hardest to assign an owner to? Unowned controls are how governance frameworks become decorative. The hard-to-own row is the one most likely to fail in a real org.

Rep 11 — Sort the AI estate for DR

List every AI asset class in your architecture (model weights, fine-tuned weights, vector DB, HNSW indexes, embeddings, prompt library, datasets, configs). Tag each reproducible or irreplaceable, and assign each a backup strategy (3-2-1, snapshot, WORM/immutable). Compute a rough RPO/RTO for the irreplaceable ones.

Reflect: What is the single most irreplaceable asset in your estate, and how many independent, signed, off-site copies does it have? If the answer is fewer than two, you have not built the ark — you have drawn it.

Done? One Last Thing.

Now do the capstone in miniature, in one sitting, with the clock running. On a single page, sketch the complete AI-native architecture for a 200-person Christian relief organization that runs a local LLM for case notes (PII), an AIOps agent for its small ops team, and a public donation portal. Your one page must show: the two-lane architecture, the identity/virtualization/monitoring/security/backup organs with their AI halves, an autonomy ladder with at least one action on each rung, a one-line cost decision (self-host vs API, with a number), and a governance spine with at least one named owner. Then write the single hardest architectural decision you made and defend it in two sentences — the call an agent could not have made for you.

That one page is the capstone, compressed. If you can do it here in an hour, you can do it for the final. If a cell is blank or a decision is undefended, that is exactly the gap to close this week.

Up next: Project 14 — Project 14: Architect the 2030 Organization (the capstone final). Keep Appendix C open for the agent-log.txt discipline.