AI Platform + Capstone

Months 49-60. The synthesis year. Build the agent layer (Tier 9) on top of everything from Y1-Y4. Close the loop: agents you built operate the platform you built. Launch Abukix Studio publicly. Ship mlship v2 + the pattern paper. Graduate.

Exit ramp: Staff/Principal AI Platform Engineer

Year 5 is the year ROOT stops being a private discipline and becomes a public artifact. Y1-Y4 built the platform; Y5 turns it into something other engineers can clone, visit, and learn from. The curriculum becomes a brand. The platform becomes self-operating via agents. The journey becomes the content.

This is also the year the role identity changes one last time. The Y4 → Y5 transition is the operator-to-architect inflection: you stop building services and start building the agents that operate services. By Month 60 the platform runs on a Tier 9 you authored — agents that triage incidents, propose runbooks, execute pre-approved actions, and learn from history. The same loops you ran by hand in Y1-Y4 now run themselves; your job is to design the loops, not pull the levers.

Graduation is not a ceremony. It’s the moment a stranger can land on studio.abukix.dev, poke at the hosted demo, clone basecamp, read the pattern paper, and conclude “this person reasons in patterns and ships real systems” — without ever meeting you. The Final Exam audits whether that’s true.

What you’ll know at the end of Year 5

Staff/Principal-grade is not a longer list of tools. It’s a different shape of competence: you reason about systems at the level of what trade-off was made and why, you mentor by writing rather than telling, and you ship artifacts that survive longer than the project they came from.

• Agent development at depth — LangGraph state machines, tool use, debugging, eval. You build agents the way you build distributed systems: with explicit state, observable transitions, and failure modes that have runbooks. See patterns/agents/.
• MCP (Model Context Protocol) — the standard for tool integration in 2025+. You author MCP servers that expose platform-ctl, triage, and Trino queries as agent tools.
• AIOps in practice — agents that triage incidents, execute pre-approved runbooks, learn from history. Implemented in services/aiops/, feeding off Prometheus alerts, Trino history, and the ops-handbook corpus.
• Platform-as-product UX — Abukix Studio (the portal + command palette + composition recipes) is your public surface. The platform finally feels like a product, not a stack.
• AI security — prompt injection defense, output filtering, capability allowlisting, signed model verification. The Tier 9 surface is the new attack surface; you defend it.
• Synthesis writing — mlship v2 capstone OSS launch + pattern paper published. Staff/Principal engineers are recognized as much by what they write as what they ship.

You’ll have shipped artifacts that prove Staff/Principal-level engineering, not just learned skills.

An AI Platform that doesn’t operate itself isn’t AI

AIOps is the inflection that earns the Staff/Principal AI Platform Engineer title. A platform with LLM serving but human-driven operations is infrastructure with an LLM bolted on. A platform whose alert triage, runbook execution, and pattern detection are all running through agents that you authored — that’s an AI platform. Phase 28 is where the title becomes accurate.

Phase map

Phase	Title	Approx. weeks	Approx. hours
26	Agent Development	8	100
27	MCP + Tool Use	6-7	80
28	AIOps: services/aiops/	8	100
29	Platform Portal + Governance: Abukix Studio launches	10	120
30	Capstone: mlship v2 + Pattern Paper	16	200
	Year 5 Final Exam = ROOT Graduation	2	24
Total		~50 weeks	~624 hrs

12 hrs/week × 52 weeks = 624 hrs. Year 5 is fully scoped — the 4-month capstone (P30) consumes 32% of the year.

What ships during Year 5 (the year of public launches)

Year 5 is when you stop being a homelabber-with-projects and become a public AI platform engineer with a brand. Multiple launches stack into one synthesis arc:

Project	Phase	Launch energy
Abukix Studio (Portal)	P29	The public launch. studio.abukix.dev live. Hosted demo of the platform (rate-limited, CPU-only, free for visitors). Blog post + LinkedIn + Show HN.
services/aiops/	P28	Public via basecamp’s repo. Year 5 service that closes the operational loop.
platform-ctl	P29	Goes PUBLIC (private since Y2). The CLI that wraps the whole platform. Released alongside Studio launch.
mlship v2	P30 (capstone)	The biggest launch. Show HN front page, LinkedIn announcement, blog post, demo video, docs site. Aim: 200+ stars launch week, 5+ real users, inbound conversations.
Pattern paper	P30 (capstone)	The writing artifact. 5,000-10,000 words, peer-reviewed, conference-submitted, published on abukix.dev/blog. The Staff/Principal-grade synthesis writeup.
home-dash personal service	P29	Private. The dashboard pulling from triage + personal-api + notes-rag + agents. Surfaces in Studio command palette.

The brand surface goes from “engineer with private homelab” to “engineer with a public platform anyone can clone or visit.” See brand/identity for how Studio and the program are positioned together.

What the pattern paper signals to the industry

The OSS launch proves you ship code. The pattern paper proves you reason at the level Staff/Principal engineers are paid to reason at — distilling 5 years of operating real systems into transferable patterns, with trade-offs named and alternatives considered. Two external readers and a conference submission are not vanity; they’re the audit. A paper accepted (or seriously engaged with) by external reviewers is the thing recruiters and hiring panels can’t fake-evaluate. It survives a job change. It survives a tool change. It survives ROOT itself.

Studio composition recipes: all 5 land this year

By Y5 end, the 5 documented composition recipes are runnable end-to-end:

Recipe	Status going into Y5	Lands
1. Personal RAG over weekly logs	done in Y4 P24	—
2. Auto-incident triage loop	new	P28
3. Train → register → deploy	done in Y4 P23	—
4. Homelab life API	done in Y3	—
5. AI-assisted on-call	new	P28 + P29

Each lives as runnable code in basecamp/examples/recipe-*/ + a short page in Studio composition + (for Studio) a hosted demo at studio.abukix.dev/recipes/{slug}. The recipes are how a stranger evaluates the platform in five minutes — they’re the cinematic surface.

Patterns deepened in Year 5

• agents/agent-loop (P26 — DEEP)
• agents/tool-use-as-capability (P26-27 — DEEP)
• agents/prompt-as-program (P26 — DEEP)
• security/zero-trust-security (P29 — DEEP for AI surface)
• security/threat-modeling (P29 — DEEP for AI threat surface)
• infrastructure-and-platform/platform-as-product (reinforced — Studio launch is the proof)

By Y5 end, ~50 patterns DEEP. The pattern library is the durable knowledge artifact ROOT promised — the thing that survives whatever replaces LangGraph, MCP, or vLLM.

Cloud requirements

Year 5 cloud spend: ~$30-80

  studio.abukix.dev demo hosting:
    Cloudflare Pages (frontend)         — $0
    Small Cloud Run / Fargate (API)     — $5-10/month
    Cloud Run jobs for demo compute     — $20-50/month, capped
    Demo runs CPU-only models (Phi-3-mini quantized via llama.cpp)

  Cloud GPU (P30 capstone for mlship vLLM testing): ~$20

  Discipline: kill all demo compute when not actively launching/showing.
              Demo is for the launch event, not 24/7 hosting.

The Final Exam: ROOT graduation

Year 5 Final Exam IS the ROOT Final Exam. Full day. Three parts, panel/AI-administered:

1. Live system review (180 min) — external/AI reviewer of your live Abukix Studio. Is the platform production-shaped? Are all 9 tiers operational? Does AIOps actually help during a simulated incident? Reviewer triggers a fault; the agents in services/aiops/ either help, hinder, or stay out of the way — all three are graded outcomes.
2. Capstone defense (120 min) — present mlship v2 + the pattern paper to a panel. Defend choices, accept critique. Questions like “why this trade-off and not its opposite?” are the heart of the exam.
3. Career story (60 min) — articulate “what’s true now that wasn’t true 5 years ago.” Specific examples from weekly logs, runbooks, and postmortems. The story is the audit.

See final-exam.md for the full spec.

The Final Exam is harder than any phase exit because it has no scope: the whole platform is in scope, the whole pattern library is in scope, and 5 years of weekly logs are fair game.

Reading order

1. This index
2. P26 (Agents) — sets the agent-as-state-machine frame
3. P27 (MCP) — makes agents tool-extensible
4. P28 (AIOps) — agents operate the platform
5. P29 (Studio) — the public launch
6. P30 (Capstone) — the OSS + writing artifacts
7. final-exam.md ~3 weeks before end of P30

Year 5 reading spine: published agent research (Anthropic, DeepMind, OpenAI), the MCP spec, and one Staff/Principal-grade engineering book per quarter (e.g., Software Architecture: The Hard Parts, The Manager’s Path, An Elegant Puzzle).

What “graduation” means

Graduation is what’s true about you on Month 60 that wasn’t true on Month 1. Not credentials. Not titles. Capability and evidence.

You can:
- Architect + operate a complete data/AI platform from kernel to LLM
- Reason in patterns; tools are interchangeable implementations
- Build agents that operate real systems (not toy demos)
- Ship OSS that other engineers find useful
- Write Staff/Principal-grade synthesis (the pattern paper)
- Defend architectural choices to peer reviewers

You have:
- Abukix Studio publicly launched at studio.abukix.dev
- mlship v2 launched (Show HN, GitHub stars, real users, inbound conversations)
- Pattern paper published
- platform-ctl public, basecamp public, terralabs public
- ~10 OSS projects shipped
- 5+ merged upstream PRs
- ops-handbook with ~140 runbooks, ~25 postmortems, ~250 weekly logs, 15+ ADRs
- ~50 patterns DEEP
- 5-year journal in The Story doc

You are: Staff/Principal AI Platform Engineer (or chosen elective endpoint)

The Month-1 version of you couldn’t have read this index without flinching. The Month-60 version of you wrote the platform this index describes. That gap — measured in shipped artifacts, written patterns, and operated incidents — is the graduation.

The depth is yours forever. The next chapter is whichever one you pick. See the Master Plan for the framing this whole journey was built on, and Year 4 for the operator-mode foundation Year 5 builds on top of.

→ The Final Exam