0.1 Series Overview
Most agentic AI tutorials jump straight to “build a LangGraph agent” without ever showing why each piece exists, or what a plain (non-agentic) baseline even looks like. This series starts there instead: one running use case, X-ray void detection on a synthetic dataset with exact ground truth, carried all the way from a bare CV model with zero agentic anything, through tool calling and structured output, into a real multi-node LangGraph pipeline, then multi-agent orchestration, RAG, fine-tuning, VLM-first architectures, and finally the production concerns (evaluation, cost, deployment, monitoring) that tutorials usually skip.
A companion series, Agentic Architecture: Supply Chain, takes the same architecture built here and re-applies it to a completely different domain – proof that the pattern, not the domain data, is the reusable part.
Two more series are planned to follow this one (both coming soon): an agentic AI software factory for the inspection system, where agents take tickets and change the pipeline built here behind a gate they cannot edit, and an agentic AI software factory for robust segmentation models, where agents run the experiments that build a better detector for it.
This is a roadmap post: links go live as each part is written, in order.
Rewritten on 2026-10-18. Parts 1 to 8 first ran on the public GDXray casting radiographs. GDXray is free for research and education only and does not allow redistribution, so I rebuilt the whole series on a synthetic void dataset that I generate myself, with fresh runs, new numbers and new animations. Several conclusions changed, and each post says where.
0.1.1 Arc 1 – Foundations
- Introduction – why agentic AI, why X-ray defect detection as the teaching example
- The dataset and the baseline model – the synthetic void dataset, a plain classical CV detector, no agent yet, scored honestly against exact ground truth
- Your first tool-calling LLM – wrapping the detector as a “tool”, one LLM call that reads structured output and writes a plain-English explanation
- Prompting and structured output – getting reliable JSON/structured responses from the LLM about defect type, severity, confidence
0.1.2 Arc 2 – The Agent Loop
- What makes it an “agent” – planning, tool use, memory, control flow; a hand-written agent loop, scored against real ground truth
- Building the graph – LangGraph basics: state, nodes, edges; the Part 5 loop redrawn as a graph, with a pause-and-resume demo and tests for every edge
- The inspection pipeline – classify defect, check business rules, decide, report, as a real LangGraph graph where the code owns the order and the model owns two judgments; scored on held-out frames, with the model’s guidance taken away as a control
- Tool design – plain code vs. a small typed model vs. a language model, measured head to head on two real calls from the Part 7 pipeline (is this box a real defect? what does this note say?): a rule, the open-source Laya (Apache-2.0, runs locally) and the local Qwen3-Coder, compared on accuracy, calibration, latency and tokens. TypeSafe’s Jev (hosted) was meant to be the other typed model, but I had no API access: its adapter is written and not run, and the post says so. The typed models’ probabilities are what the review-vs-escalate threshold in post 9 would be set on
- Human-in-the-loop – flagging uncertain cases for review, approval workflows
0.1.3 Arc 3 – Scaling Up: Multi-Agent and Deep Agents
- When one agent isn’t enough – sub-agents per defect category or per inspection stage
- Deep Agents harness – planning, virtual filesystem, context management for long-running investigations
- Orchestration patterns – supervisor agents, delegation, aggregating sub-agent results
- Wayfinder-style planning – handling investigations that span multiple sessions, ticket-based maps for open-ended defect investigations
0.1.4 Arc 4 – Knowledge and Precision
- Context engineering starts with retrieval – grep, paged reads, offloading, paths instead of payloads and sub-agents that see one file, measured on this series’ own archive (a 4,000-row CSV, 200 pipeline reports, DINOv3 + LanceDB visual search). Stuffing the prompt wins when the archive fits; the harness wins when it does not. Replaces the earlier “RAG over your defect catalog” plan; what to embed is in Retrieval and RAG
- Building the retrieval pipeline – chunking, embeddings, vector store, evaluation of retrieval quality
- 15b. Graphs from your own data – extracting entities and relations (defect type, batch, decision, rule) from the pipeline reports and building a knowledge graph from them (planned)
- 15c. Graph RAG – the same questions as Part 14 answered by graph queries instead of vector search, measured honestly, including where the graph does not win (planned)
- Fine-tuning – when RAG isn’t enough, fine-tuning a model on your labeled defect explanations and decisions for domain precision
- Vision-language models – letting the model reason directly over the X-ray image instead of only structured detector output; comparing VLM-first vs. CV-model-first architectures
0.1.5 Arc 5 – Production and Evaluation
- Evaluation – building an eval set, using LangSmith (or similar) to trace and score agent decisions
- 18b. A self-improving eval loop – the agent proposes a change (a skill, a prompt rule), the eval set decides whether it is kept; builds on skill induction from the adaptive agents hands-on post (planned)
- Cost and latency tuning – model selection per step, caching, batching; includes a measured comparison of the local vLLM server against a hosted API (latency and tokens measured, API cost calculated from list prices) (planned)
- Failure handling – retries, fallbacks, graceful degradation
- Deployment – turning the pipeline into a real triggered service
- Monitoring in production – drift detection, feedback loops, continuous improvement
0.1.6 Arc 6 – Expert-Level Topics
- Security and safety for agents – prompt injection risks when reading external documents or web content, guardrails around autonomous actions vs. actions requiring human approval
- Multi-agent communication protocols and standards – how agents talk to each other, emerging standards in the field
- Agent memory design – long-term vs. short-term memory, deciding what an agent should remember across sessions vs. what it should forget
- Cost and business ROI framing – justifying an agent project to management, measuring time saved and errors caught, not just technical cost/latency tuning
- Testing and simulation – testing an agent before production using simulated and adversarial scenarios, not just live evaluation
- Choosing an agent framework – the broader landscape beyond LangGraph and Deep Agents, how to evaluate and pick a framework for a given use case
- Versioning and change management for agents – prompts, tools, and models drift over time; how to version agent behavior and roll back safely when a change breaks production
0.1.7 Capstone
- Putting it all together – the finished inspection pipeline, lessons learned, and the bridge into the two factory series: what the pipeline needs before agents are allowed to change it, and the gates and controls that make that safe
Reuse
Citation
@online{goni2026,
author = {Goni, Hasan},
title = {Agentic {Developer:} {Zero} to {Advanced}},
date = {2026-10-26},
langid = {en}
}