Project 14 — Architect the 2030 Organization

“Unless the LORD builds the house, those who labor build in vain.” — Psalm 127:1 (ESV)

Chapter: 16 — The AI-Native Enterprise: Capstone Due: End of Week 16 (take-home build) + a scheduled 60-minute live session Submit: A link to a public GitHub repository containing the document set below, the reference configs, REPORT.docx, and (required) agent-log.txt. See Appendix A for the toolchain + git workflow, Appendix B for the local + cloud AI stack, and Appendix C for the agentic-AI rules and agent-log.txt format. Allowed tools: Anything. Diagramming tools, an AI agent (Claude Code / Copilot / Cursor), the textbook, the appendices, the open internet, the reference configs in code/. This is the open-AI, agentic final. AI — Phase 2, the FINAL (agentic AI is fully ON): You may delegate drafting, sizing, and config generation to an agent. An agent-log.txt is REQUIRED — every task you delegated, what the agent produced, where it was wrong, and where you intervened. The architecture and the governance decisions are yours. The agent may draft prose, generate YAML, and size estimates; it may not decide where the judgment lives, which actions are gated, or which tradeoff the organization will accept. That is the part this final grades, and it is the part an agent cannot do for you. This is the FINAL — graded most of all on the documents written first.

The Setup

It is 2030. Cornerstone Relief International (CRI) is a 600-person Christian relief and development organization with field offices on four continents, a headquarters IT team of nine, and a board that has just approved an “AI-native” mandate after a hard year. Last year a field director nearly wired US$240,000 to a deepfaked “CFO” on a video call (the board read the 2024 Arup case and went pale). A ransomware scare took the donor database offline for a weekend. And a well-meaning staffer pasted three years of confidential beneficiary case notes — names, locations, medical details of vulnerable people — into a public chatbot to “summarize them faster.”

The board’s mandate is two sentences. Use AI to do far more with our nine people. And never again put the people we serve, or the trust they place in us, at the mercy of a tool we did not govern.

You are the architect they hired. Your job is not to build the whole thing this week — it is to design the house so it stands, and to write the documents the nine-person team will run on for the next five years. They will live with your decisions. Make them defensible.

Setup (the starter)

This chapter’s code/ directory holds your reference scaffolding — adapt these, do not just submit them:

• code/inference-platform.yaml — the GenAI inference lane sketch (K8s + GPU Operator + DRA + KServe/vLLM, weights as OCI artifacts, governance hooks).
• code/autonomy-ladder.yaml — the governed-autonomy policy: each ops action on a rung with a gate, a guardrail, and a rationale.
• code/governance-checklist.txt — the ten-row control set anchored to NIST AI RMF / EU AI Act / ISO 42001.
• code/estate_cost.py — the self-host-vs-API cost crossover model.

Learning Targets

By completing this capstone, you will demonstrate that you can:

• Produce a complete, defensible architecture for an AI-native organization — traditional and AI components in one coherent design.
• Write the six governing documents an organization runs on: architecture diagram, AI strategy, automation plan, security plan, cost analysis, governance framework.
• Place every traditional organ (identity, virtualization, monitoring, security, backup) and every AI organ (local LLM infra, AI governance, AI-assisted monitoring, AI-assisted automation, AI security controls, AI DR) into one architecture.
• Design governed autonomy — an autonomy ladder with gates that honor OWASP LLM06, the lethal trifecta, the Rule of Two, and EU AI Act Art. 14.
• Size and cost the AI estate with real numbers and state the self-host-vs-API crossover.
• Make and defend an architectural judgment an agent could not make for you.

Normal Tier

Goal: A complete, defensible AI-native architecture for CRI, delivered as the six-document set plus reference configs. Written for a real nine-person team to execute.

Required deliverables (the documents come FIRST and weigh most)

1. Architecture diagram (architecture.docx or an image) — the two-lane reference (training + inference) on one control plane, showing every layer of the §16.1 table with both halves filled: identity, virtualization, monitoring, security, backup AND local LLM infrastructure, AI governance, AI-assisted monitoring, AI-assisted automation, AI security controls, AI DR. No blank cells; justify any deliberate omission.
2. AI strategy (ai-strategy.txt) — what CRI uses AI for (the tool thread) and what AI workloads it runs (the workload thread), the model-tier choices (right model for the job), and the build-vs-buy-vs-self-host stance, each defended.
3. Automation plan (automation-plan.txt) — the AIOps + agentic ops design with an autonomy ladder (adapt code/autonomy-ladder.yaml): at least one action on each of observe/recommend/approve/act, each gated by reversibility and blast radius, each audited.
4. Security plan (security-plan.txt) — traditional controls (identity, least privilege, segmentation, the out-of-band wire-verification that would have stopped the deepfake) AND AI security: an OWASP LLM Top 10 → MITRE ATLAS threat map for CRI’s local LLM and its case-note RAG, plus the prompt-injection trust-boundary design.
5. Cost analysis (cost-analysis.txt) — the AI estate sized (VRAM + storage napkin math) and the self-host-vs-API crossover (run code/estate_cost.py), with a recommendation and consumption spend caps.
6. Governance framework (governance.txt) — the filled ten-row control set (code/governance-checklist.txt) anchored to NIST AI RMF + EU AI Act + ISO 42001, every row with a named owner, an artifact, and a gate.

Plus REPORT.docx (a one-page executive summary the board can read) and agent-log.txt.

Normal-tier rubric (out of 100)

Medium Tier (+up to 25% extra credit)

Goal: Deepen two documents from “complete” to “convincing.”

1. A measured cost crossover. Don’t just run the script — extend it. Add the KV-cache term to the VRAM sizing, model two real workload growth scenarios (CRI doubles its field offices; CRI adds a public chatbot), and show where the self-host-vs-API decision flips. Present a sensitivity table.
2. A real threat model. Take CRI’s case-note RAG (PII of vulnerable people + an LLM + a retrieval tool + an email/export capability) and walk an indirect prompt-injection / EchoLeak-style kill chain through it, labeling each step with an OWASP LLM ID and a MITRE ATLAS technique. Then design the architectural mitigations (trust boundaries, output handling, least privilege, the Rule of Two) — not a single filter.
3. A regulation-mapping appendix. Map one autonomous remediation workflow to EU AI Act Art. 14 + Art. 12 and NIST RMF functions, and state the current high-risk enforcement date with its adoption status (you researched it; cite the source and date you checked).

Hard Tier (+up to 25% additional extra credit)

Goal: The architect’s judgment — the part the grade is really for, and the part an agent cannot supply.

Write a decision memo (decision-memo.docx, ~1–2 pages) to CRI’s board on the one or two architectural decisions the organization will live with for the next five years. Candidates: self-host vs API for the case-note LLM (data residency for vulnerable people’s PII vs cost vs the nine-person team’s capacity to run GPUs); how high CRI’s autonomy ladder may climb given a nine-person team and a four-continent footprint; whether to adopt a managed AIOps agent or build on open standards given the org’s lock-in risk and budget.

The memo must: state the decision plainly; lay out the real tradeoff (cost, risk, residency, team capacity, lock-in) with at least one measurement; make a recommendation and commit to it; and name what would have to change for you to reverse it. An agent can draft the prose. It cannot weigh CRI’s vulnerable beneficiaries against CRI’s budget against CRI’s nine-person team — that weighing is the architect’s, and your agent-log.txt must show you made it, not the agent. This memo is where the human-in-the-loop thesis of the entire course is graded.

Submission

Push a public GitHub repo containing: the six documents, REPORT.docx, the adapted reference configs, agent-log.txt, and (for Hard) decision-memo.docx. Bring the repo to your scheduled 60-minute live session, where you will walk the board (the instructor) through the architecture, defend two decisions out loud, and answer the question every architect must answer in person: where, in this design, does the judgment live, and who answers when it fails?

Hints (Read Before You Begin)

• Write the documents before you touch a config. The grade weights the thinking, and the configs should fall out of the documents, not the other way around. An architecture is decisions, not YAML.
• No blank cells. The single most common capstone failure is a strong tool-thread and a blank workload-thread (or vice versa). Walk the §16.1 table and fill both halves of every organ.
• Name owners. Every governance row, every gated action — a named (fictional) human. A control without a controller is decoration.
• Pin and date. Pin model IDs and version lines; date every “as of 2026” claim; phrase the EU AI Act timeline as “deferred, pending adoption — verify.”
• Bet on standards. Reviewers reward an architecture that survives a rename. Name products as implementations of OTel / OpenAI-compatible API / OCI artifacts / MCP, not as load-bearing brands.
• Use the Canvas first. The AI-Native Architecture Canvas on the chapter page is your first-pass completeness check. Clear its checklist, screenshot it, and let the architecture grow from there.

What Mastery Looks Like (Beyond the Rubric)

A mastery submission reads like a document a real nine-person team could actually run on. Its governance is owned, not narrated. Its autonomy ladder is conservative where it should be and bold where it safely can be — and it can tell you why for each rung. Its cost analysis has a number you could defend to a board. And its decision memo makes a hard call, commits to it, and names the condition under which it would change its mind. It is, in a word, founded — you could see, reading it, what it rests on.

Coach’s Note — The temptation in a capstone is to make it impressive — to put the agent on the top rung, to self-host everything, to draw the biggest diagram. Resist it. The architect the board needs is not the one with the most autonomous system; it is the one who can tell them, precisely, where they are exposed and what they decided to live with. Impress me with your judgment, not your maximalism.

When You’re Done (a short checklist)

• All six documents present; both halves of every §16.1 organ filled.
• Autonomy ladder has at least one action on each rung, each gated and audited.
• Security plan maps OWASP LLM → MITRE ATLAS and designs the trust boundaries.
• Cost analysis states the crossover number and spend caps.
• Governance: ten rows, every owner named, three frameworks cited.
• agent-log.txt: what you delegated, where it was wrong, where you intervened.
• (Hard) decision-memo.docx: a decision made, defended with a measurement, committed to.
• You can answer out loud: where does the judgment live, and who answers when it fails?

A theological footnote. Psalm 127 is honest about labor: it never says effort is wasted, only that effort can be in vain if the house rests on the wrong foundation. You are about to do real labor — sizing, costing, gating, documenting. Do it well. But the verse, and the wise builder of Matthew 7, both put the weight not on the height of the house or the speed of its building but on the foundation that is invisible until the flood. For CRI that foundation is the people it serves — vulnerable people whose names and locations and wounds were entrusted to a tool you did not make. To architect so that the flood — the injection, the deepfake, the drifted model, the agent that deleted the wrong volume — does not reach them is not piety added to the engineering. It is the engineering, done as stewardship of what was entrusted and not surrendered to a fast, confident, sometimes-wrong servant. Build the house on the rock. Be found faithful with what you did not make.

See you next week.