Arc 5 of /root. The last year. The platform meets the moment. ~12 phases that complete the AI tier and ship the capstone. Exit ramp: ML Platform / AI Infrastructure

Years 1-4 built the engineer, the substrate, the platform, the data tier, and the ML foundations. Arc 5 stands the AI tier on top: vector stores, LLM serving via KServe, fine-tuning workflows, an LLM gateway that mirrors the production-grade pattern frontier labs build internally, agent runtimes with MCP, AI security + observability, AIOps that operate the platform itself. The capstone is vantage MVP launched publicly plus the Pattern Paper, the synthesis writing that distills 5 years into prose a hiring manager reads in 20 minutes.

By end of Arc 5 a reviewer landing on the program’s public artifacts (basecamp + 9 OSS projects + vantage MVP + Pattern Paper + ~250 blog posts) sees a coherent multi-tier AI platform built by an engineer who understands how the layers fit. That’s the senior-IC pitch.

What you’ll know at the end of Arc 5

• ML lifecycle at production depth: MLflow registry + experiment tracking; model lineage; stage promotion; CI-tested model code
• Feature stores: Feast at depth, train/serve parity verified continuously, point-in-time correctness
• ML evaluation + monitoring: offline + online evals, drift detection, LLM-as-judge for open-ended tasks
• Vector search + RAG: pgvector + Milvus, embedding pipelines, hybrid search, retrieval evals
• LLM serving deep: vLLM via KServe, PagedAttention, continuous batching, KV cache
• Inference optimization: quantization (INT8, INT4), distillation, speculative decoding, batch tuning
• Fine-tuning + PEFT: LoRA, QLoRA, instruction tuning, DPO; production-grade fine-tune workflows
• LLM gateway: routing + caching + observability + fallback; prism shipped publicly
• Prompt engineering as infrastructure: versioned prompts, structured outputs (function calling, JSON schema), prompt evals
• Agent runtime + MCP: LangGraph-style agent loops, MCP servers exposing platform tools, tool-use safety
• AI security + observability: prompt injection defense, capability allowlisting, AI-specific telemetry
• AIOps: agents that operate basecamp, triaging incidents against the chronicle corpus

You’ll be operating an end-to-end AI platform K8s-native end to end, mirroring at small scale what frontier-lab AI platforms (Anthropic, OpenAI, and others) do at hyperscale.

Phase map

Arc 5 is the longest arc (12 phases); the AI stack has real surface area.

What ships publicly during Arc 5

Patterns deepened in Arc 5

ML systems (already touched in Arc 4; deepen here)

• model-registry to DEEP (Phase 39)
• feature-store to DEEP (Phase 40)
• train-serve-skew to DEEP (Phase 40)
• evals to DEEP (Phase 41 + integrated into 46 + 48)
• drift-detection to OUTLINE (Phase 41)

AI/LLM systems (new patterns)

• vector-search to DEEP (Phase 42)
• embedding-store to OUTLINE
• rag-as-pattern to DEEP (Phase 42)
• llm-serving to DEEP (Phase 43)
• inference-optimization to OUTLINE (Phase 44)
• fine-tuning-strategies to OUTLINE (Phase 45)
• llm-routing to DEEP (Phase 46)
• llm-caching to OUTLINE
• prompt-engineering to DEEP (Phase 47)
• structured-outputs to OUTLINE
• agent-loop to DEEP (Phase 48)
• tool-use to DEEP
• mcp-protocol to OUTLINE
• ai-security to OUTLINE (Phase 49)
• ai-observability to OUTLINE
• aiops-agent-loop to OUTLINE (Phase 50)

Reinforced from prior years

• operator-pattern reaches DEEP through Arc 5 (5 years of operating + building operators)
• platform-as-product reinforced via vantage
• token-bucket-rate-limiting reinforced (Phase 46 LLM rate limiting)

By end of Arc 5: ~60-70 patterns at OUTLINE+, ~30-40 at DEEP: the program’s structural target.

Hardware requirements

Arc 5 needs GPU. Recommendation:

• Local GPU: RTX 4060 / 4070 / 4080 or used 3090. Used 3090 is the sweet spot for fine-tuning + serving 7-13B models locally. ~$300-700.
• Cloud GPU bursts: Lambda Cloud, RunPod, AWS spot p3.2xlarge / g5.xlarge for short fine-tune runs or benchmarking. ~$100-300 total Arc 5.

Most of /root’s Arc 5 work fits on a single 24GB GPU + cloud bursts for heavier moments.

Arc 5 Final Exam + Capstone

Scenario-based final exam + Pattern Paper deliverable.

The Final Exam covers AI infrastructure end-to-end. The Capstone produces:

1. vantage MVP deployed at the public site
2. Pattern Paper: 3,500-5,000 words distilling the multi-arc journey

See the full Arc 5 Final Exam + Capstone spec.

Arc 5 graduation

You can:
- Operate ML lifecycle (registry, feature store, evals) at production depth
- Operate the LLM serving stack (vLLM, KServe, quantization, fine-tuning)
- Ship a working LLM gateway (routing, caching, observability, fallback)
- Build agents with proper tool-use, structured outputs, safety
- Defend AI security posture (prompt injection, capability allowlisting)
- Run AIOps agents that operate the platform from its own telemetry
- Build a product surface (vantage MVP) over infrastructure
- Write the synthesis paper that turns 5 years of work into a 20-minute read

The capstone artifact:
- basecamp public on GitHub (all 8 modules alive across multi-cloud)
- 9 OSS projects: sift, pulse, beacon, forge, ascent + custom operator, crag umbrella, prism, MCP servers, vantage
- chronicle: ~250 weekly logs, ~25 postmortems, ~140 runbooks, ~15 ADRs
- ~60-70 patterns at OUTLINE+, ~30-40 at DEEP
- root.abukix.dev (or whatever public site you deploy to): blog with ~250 posts, /talks/ with 5+ recorded talks, /capstone/ with the Pattern Paper
- Senior-IC interview portfolio: complete

Exit ramp: ML Platform / AI Infrastructure at frontier labs
Confidence: real, with end-to-end AI platform K8s-native at homelab scale

→ The program completes. What’s next is the deferred work: vantage v1 (multi-tenant), production-scale AIOps, whatever specialization the next employer enables. Welcome to the senior tier.