Agentic AI: Projects & Engineering Mastery MOC

Agentic AI: Projects & Engineering Mastery

Hands-on builds and Principal/Staff-level judgment, for L6/L7 engineers

This book assumes everything from AI Architecture & System Design and the five books before it. If this were a book, this page is the table of contents. It closes the series: every practitioner build from the earlier version of this scaffold, the judgment and communication layer an L6/L7 loop actually screens for, and the reference material meant for lookup rather than sequential reading — lettered appendices and the vendor/framework notes the whole series links out to instead of duplicating. Unwritten chapters are listed as stub rows, not empty files.

Parts

00 — Hands-on Engineering Projects

Where the book’s own hands-on lineage lives — every practitioner build from the earlier version of this scaffold moved here rather than being discarded, since building one of these end to end is still the fastest way to internalize everything from AI & LLM Foundations through AI Architecture & System Design.

• Chapter 1. Build Your First Agent — hand-rolled tool calling first, then LangGraph’s state-graph abstraction over the same loop, then how to test and debug it.
  • Setting Up the Development Environment — Python project setup, virtual environments, and installing the OpenAI SDK, LangChain, and LangGraph.
  • Creating a Tool-Using Agent — Designing an agent from scratch — tools, tool calling, prompt templates, response generation.
  • Building Agents with LangGraph — State management, nodes, edges, conditional routing, execution flow.
  • Testing and Debugging Agents — Unit testing tools, mocking LLM calls, debugging agent flows, a troubleshooting guide.
• Chapter 2. Build an MCP Server — (stub) — A Model Context Protocol server exposing a real tool with schema-validated inputs and outputs, deployable end to end. See Appendix H — MCP Reference Guide.
• Chapter 3. Build an Agent with Memory — Hand-rolling short-term and long-term memory — SQLite-backed storage for conversation and investigation history across sessions.
• Chapter 4. Build an Agentic RAG System — the corpus, then the retrieval pipeline built on top of it.
  • Building an Operational Knowledge Base — Turning runbooks, playbooks, architecture documents, and incident reports into a RAG corpus.
  • Retrieval-Augmented Generation (RAG) — Document processing, chunking, embeddings, vector database choice, and the retrieval pipeline.
• Chapter 5. Build a Coding Agent — (stub) — A coding agent that reads a repository, plans a change, edits files, and runs tests in a sandboxed loop with a human-review checkpoint before merge.
• Chapter 6. Build a Multi-Agent System — (stub) — Applies the supervisor and orchestrator-worker patterns from Part 00 of AI Architecture & System Design to a concrete task, with message-passing and failure-handling code.
• Chapter 7. Build an AI SRE Assistant — the capstone-grade practitioner build: wiring an agent’s tool layer directly to Grafana, Loki, and Tempo so it can investigate real incidents. See Grafana MCP, Loki, Tempo, Prometheus, and HolmesGPT — the closest real production implementation of this exact pattern.
  • Connecting Agents to Grafana — Grafana architecture, authentication, metrics API, querying Prometheus, error handling.
  • Building a Log Investigation Tool — Loki API, LogQL basics, time range filtering, log summarization, pattern detection.
  • Building a Trace Investigation Tool — Tempo API, trace retrieval, span analysis, latency investigation, service dependency analysis.
  • Automated Root Cause Analysis — Correlating metrics/logs/traces, evidence collection, confidence scoring, incident summaries.
• Chapter 8. Build an Enterprise AI Platform — (stub) — A minimal enterprise AI platform slice — gateway, registry, one deployed agent — wiring together Part 01 of AI Architecture & System Design‘s architecture into working infrastructure.
• Chapter 9. Production Deployment — Containerizing and deploying an agent through Docker, Kubernetes, and CI/CD — versioning prompts and models as deploy artifacts.
• Chapter 10. Capstone Project — Assembling every book of this series into one deployable system — architecture, project structure, end-to-end workflow, RCA generation, dashboards, and deployment.

01 — Principal & Staff Engineer Mastery

Everything that isn’t code — the judgment and communication layer an L6/L7 loop actually screens for.

• Chapter 1. Technical Strategy for AI — (stub) — Writing a multi-year technical strategy for AI adoption, and sequencing platform investment against product-team demand.
• Chapter 2. Build vs Buy Decisions — (stub) — A worked cost/lock-in/velocity comparison for AI platform components a Staff engineer would present to leadership.
• Chapter 3. AI Platform Roadmaps — (stub) — Translating technical strategy into a quarter-by-quarter roadmap with explicit dependency sequencing.
• Chapter 4. Architecture Reviews — (stub) — The review rubric, common objections a review board raises to agentic designs, and defending a proposal under scrutiny.
• Chapter 5. Engineering RFCs & ADRs — (stub) — Writing RFCs/ADRs for agentic-system decisions, where blast radius (e.g. granting write access) changes how much rigor the document needs.
• Chapter 6. Organizational Design for AI Teams — (stub) — Centralized platform team versus embedded AI engineers versus hybrid, and how ownership shifts as the platform matures.
• Chapter 7. AI Governance at Scale — (stub) — Model approval workflows, audit logging requirements, and policy-as-code enforcement across an enterprise.
• Chapter 8. AI Economics & ROI — Building the cost model and ROI narrative for an AI platform investment in the form a CFO or VP Engineering would accept. Paired with the engineering-levers view in Cost Engineering (Part 03 of Production Agent Systems), which this chapter’s numbers are built on top of rather than re-deriving.
• Chapter 9. Interview Case Studies (L6/L7) — (stub) — Full mock L6/L7 system-design interview transcripts on agentic-AI topics, with follow-up probes and what separates a passing answer from a borderline one.
• Chapter 10. The Future of Agentic AI — (stub) — Closes the series with where agentic AI architecture is heading, and which of today’s patterns are likely to age well.

02 — Appendices

Reference material meant for lookup, not sequential reading.

• Appendix A. Agent Framework Comparison Matrix — (stub) — Compares frameworks (LangGraph, AutoGen, CrewAI, custom) across state management, tool-calling model, and production-readiness.
• Appendix B. Prompt Engineering Cheat Sheet — (stub) — A condensed reference of prompt-engineering techniques with when-to-use guidance.
• Appendix C. Agent Design Pattern Catalog — (stub) — A condensed table of every pattern covered in Part 00 of AI Architecture & System Design, applicability criteria and trade-offs, for interview-day review.
• Appendix D. AI Security Checklist — (stub) — A pre-launch security-posture audit checklist — prompt injection defenses, tool-permission scoping, secrets handling.
• Appendix E. Production Readiness Checklist — (stub) — A pre-launch checklist covering observability, rollback plan, rate limiting, and on-call ownership.
• Appendix F. AI System Design Interview Questions — (stub) — A bank of practice system-design prompts specific to agentic AI, by difficulty.
• Appendix G. OpenAI, Anthropic & Google API Comparison — (stub) — Tool-calling formats, context window/pricing tiers, and streaming semantics across the three major model APIs.
• Appendix H. MCP Reference Guide — (stub) — A condensed reference for the Model Context Protocol specification — message types, capability negotiation, server/client lifecycle.
• Appendix I. AI Engineering Glossary — (stub) — A glossary of the agentic-AI terminology used throughout the series.
• Appendix J. Recommended Papers, Books & Open-Source Projects — (stub) — An annotated reading list for readers who want to go deeper on a specific topic.

Framework & API references

Reference-lookup material for specific tools — LangChain, LangGraph, the OpenAI SDK, Grafana/Loki/ Tempo APIs, OTel-for-AI conventions — lives as standalone single-tool notes in this book’s own reference/ folder rather than as numbered chapters: see CrewAI, Google ADK, MCP Toolbox, Mem0, Vertex AI, OpenClaw, Hermes Agent, Gemini Enterprise Agent Platform (Google’s A2A protocol), and the API-surface companions to Building & Evaluating Agents’ Part 03 framework chapters — OpenAI Agents SDK, LangGraph, AutoGen, Semantic Kernel, LlamaIndex Workflows, and Haystack Agents — plus Grafana MCP, HolmesGPT, Loki, Tempo, and Prometheus, which live in the grafana-cloud/ and observability/ books they belong to instead.

Azure’s AI platform — the counterpart to Vertex AI on GCP — gets its own cluster: Azure AI Services (the service catalog and account model), Azure AI Content Safety (moderation), and Managing, Monitoring, and Securing Azure AI Services (the operational layer), plus Azure SRE Agent for Azure-native incident response. Harness Engineering is a cross-cutting pattern note that also lives here rather than under a numbered chapter — the discipline underneath every framework in this list. See 1-projects/agentic-ai-lab/README.md for the hands-on build backlog that puts Part 00 into practice.

Metadata

Author	Amit Singh
Scope	agentic-ai-projects-and-mastery