Field notes on agentic AI
Practical, opinionated writing on building agents and RAG systems that hold up in production — the failure modes, the fixes, and the things the tutorials skip. Organised by depth so you can start where you are.
37 posts
Basic
Start here. Foundations, definitions, and the mental models you'll use everywhere else.
Agentic AI vs Generative AI: The Difference That Actually Matters in 2026
Generative AI predicts the next token. Agentic AI decides what to do next. The gap between those two sentences is the gap between a chatbot and a colleague — and where most teams quietly burn six months.
Word2Vec: The Foundational Root of Modern LLMs
A from-scratch, beginner-to-advanced tour of word2vec: the distributional hypothesis, one-hot to dense vectors, CBOW vs Skip-gram, the softmax bottleneck and negative sampling, vector arithmetic that does analogies — and the straight line from that 2013 idea to the embedding and attention layers of modern LLMs.
Why We Built TypeScript Notebooks (and Skipped Python)
We shipped 50+ runnable TypeScript notebooks for learning agentic AI — real LangChain, LangGraph, Vercel AI SDK and OpenAI Agents code that executes in your browser with one click, no install. This is why runnable beats readable, how to actually learn from them, the real reason we couldn't do Python notebooks (and why that turned out to be a feature), and how it sets our agentic-AI education apart.
Should You Even Build an Agent? A Feasibility Framework
Most agentic AI projects fail before a line of code is written: the problem was wrong. This is a feasibility framework — a 2×2 mental model, a candidate scorecard, an honest ROI calculator, and the accuracy-compounding trap that kills long agent chains at scale. Learn to say 'no, use a workflow' as confidently as 'yes, build the agent'.
50 Agentic AI Interview Questions Asked in 2026
A tiered bank of the agentic AI interview questions actually being asked in 2026 — junior (ReAct, tool calling, RAG), mid (orchestration, MCP, evaluation), and senior/staff (observability for non-deterministic systems, injection defense, knowing when NOT to use agents). With the answers interviewers are listening for.
Intermediate
Applied patterns and comparisons — once you know the basics, this is the real day-to-day.
Building AI Agents with the OpenAI Agents SDK: A Practical Guide
A hands-on guide to the OpenAI Agents SDK (Python): the core primitives (agents, tools, handoffs, guardrails, sessions, tracing), runnable code for each, and how to go from a single agent to a guarded multi-agent system.
Building AI Agents with Google ADK (Agent Development Kit)
A practical guide to Google's Agent Development Kit (ADK): the LlmAgent building block, tools as plain Python functions, deterministic workflow agents (Sequential, Parallel, Loop), multi-agent routing with sub_agents, and lifecycle callbacks for safety — with runnable code.
How to Build an AI Agent: A Step-by-Step Guide
A practical, step-by-step guide to building an AI agent: pick a job and model, write the system prompt, add typed tools, ground it with RAG, then add memory, guardrails and evaluation — with runnable code and a clear path from first agent to production.
How to Build a Multi-Agent System (LangGraph & CrewAI, Step by Step)
A practical guide to building multi-agent systems: when you actually need more than one agent, the core orchestration patterns (supervisor, sequential, parallel, hierarchical, network), runnable LangGraph.js and CrewAI examples, and how to build one visually on AgentSwarms.
15 Real AI Agent Examples (and the Template to Build Each One)
Fifteen concrete AI agent examples across support, research, engineering, data and marketing — with the real companies shipping each pattern (Klarna, Bank of America, JPMorgan, Morgan Stanley, Mastercard) and a runnable AgentSwarms template for every one.
Autonomous AI Agents: What They Are and How to Build One
A clear, buildable guide to autonomous AI agents: the reason–act–observe loop, how they differ from workflows and chatbots (per Anthropic), the ReAct pattern, a minimal runnable agent in TypeScript, and when a plain workflow is the smarter choice.
Why Do Multi-Agent LLM Systems Fail? The Research, the Case Studies, and the Fixes
A research-grounded look at why multi-agent LLM systems fail: the MAST taxonomy (14 failure modes, 3 categories, measured shares), real case studies from Anthropic, Cognition and ChatDev, the arithmetic of compounding error, and the prevention stack that works.
How to Build AI Voice Agents in 2026: Vapi vs Retell AI vs Amazon Bedrock Nova Sonic vs ElevenLabs (with Real Case Studies and Deployment Guides)
The definitive 2026 comparison of AI voice agent platforms — Vapi, Retell AI, Amazon Bedrock Nova Sonic, ElevenLabs Conversational AI, LiveKit Agents, Pipecat, Deepgram, and OpenAI Realtime — with pricing, latency, enterprise case studies (Bank of America, DoorDash, Klarna, JPMorgan, Air India) and step-by-step deployment guides.
Deploy a Custom MCP Server to AWS, Azure, and GCP: A Runnable Python & TypeScript Guide
A hands-on, runnable guide to building and deploying custom MCP servers. Full Python (FastMCP) and TypeScript (MCP SDK) servers over Streamable HTTP, one Dockerfile each, and working deploy recipes for Cloud Run, Azure Container Apps, and Amazon ECS Express Mode — plus auth, statelessness, and testing.
Multi-Agent Simulation: How to Test Complex Agentic Workflows in a Sandbox Before They Touch Production
Why you can't unit-test a swarm, what multi-agent simulation actually is, the research and industry environments doing it (Smallville, Melting Pot, τ-bench, Project Sid, SWE-bench), and how to build a sandboxed harness that finds emergent failures before your users do.
AI Agents in Financial Services: What the Biggest Institutions Actually Ship — and How They Keep It Safe
An institutional-grade look at AI agents in banking, markets and payments: who ships them and for what, the risks that matter in a regulated shop, and how accuracy, security and governance are actually handled — with public case studies and references.
Building Voice Agents: Everything You Know About Chat Agents Still Applies
The two architectures for voice agents (cascaded STT+LLM+TTS vs unified speech-to-speech models like Amazon Nova Sonic), the sub-second latency budget that makes or breaks them, turn-taking and barge-in, and how every chat-agent principle carries straight over.
Agentic AI Frameworks: A 2026 Comparison Guide
A builder's comparison of the major Agentic AI frameworks — LangGraph, CrewAI, PydanticAI, AutoGen, OpenAI Agents SDK, and AWS Strands — across state management, orchestration patterns, type safety, observability, and production scalability. Includes a matrix and a decision flow.
Retrieval, Chunking, and Reranking: The Parts of RAG That Actually Decide Quality
Chunking, two-stage retrieval, and cross-encoder reranking decide RAG quality more than the LLM does. A practical guide — popular reranker models, when each fits, and where LlamaIndex helps vs where it's overkill.
Flowise vs Langflow vs Dify vs n8n vs AgentSwarms: The Honest 2026 Comparison
n8n is a workflow engine, Flowise is a LangChainJS canvas, Langflow is a Python LangChain canvas, Dify is an LLM app platform, AgentSwarms is a multi-agent design studio. Here's the deep comparison nobody else writes.
Pydantic: The Contract Layer Your Agents Are Missing
LLMs generate plausible text, not reliable data. Pydantic turns that text into typed, validated objects — and that single change quietly removes a whole class of agent bugs. We go from type hints to structured outputs, self-correcting validators, discriminated-union routing, and PydanticAI — then weigh the honest alternatives (msgspec, attrs, Zod, provider-native JSON).
Memory Management in Agentic AI: From STM to LTM in Production
Memory is what turns a clever chatbot into an agent that knows you. A practical, institutional-grade walkthrough: the four memory types, the strategies (buffer, window, summary, vector, hybrid), how to test memory in AgentSwarms, and production-ready snippets for CrewAI, LangChain, LangGraph, OpenAI Agents SDK, and Strands.
When Agents Burn Money: Cost Control in Multi-Agent Systems
Multi-agent costs don't add up — they multiply. Why loops and fan-out send spend geometric, how a stuck agent racks up a five-figure bill, and the enforcement, dedup, and observability tooling that keeps it bounded.
Which GPU Runs Which LLM? The Complete Hardware Guide
VRAM is the gatekeeper of local LLMs. Learn the memory math, quantization, and the llmfit tool; see which GPU runs which model; benchmark with the right tools; compare desktop vs datacenter cards; and weigh cost, availability, and buy-vs-rent — all with hands-on interactive diagrams.
7 Failure Modes That Kill Multi-Agent Systems
Most multi-agent systems don't fail loudly. They drift, loop, and quietly degrade. We walk the seven failure modes that kill swarms in production — hallucination snowballs, runaway loops, goal drift, silent quality decay — and the concrete fix for each, with broken swarms you can repair.
LangGraph vs CrewAI vs AutoGen: 2026 Benchmark
We ran the same researcher → writer → reviewer pipeline through LangGraph, CrewAI, and AutoGen and looked at the two numbers that matter: did it finish the task, and what did it cost? A builder's benchmark with an opinionated verdict and a decision flowchart — not another feature table.
Agentic RAG vs Traditional RAG: Key Differences
Vanilla RAG is a straight line: embed, retrieve, stuff, generate. Agentic RAG adds a brain that can route, grade its own retrieval, and self-correct. We compare the three architectures with working code, show when NOT to upgrade, and cover the RAG-poisoning attack that should keep you up at night.
Advanced
Production hardening, security, self-improving systems, and the stuff that bites at 3am.
Human-in-the-Loop Agents on LangGraph, Deployed to Amazon Bedrock AgentCore
Most agent demos skip the part where a human says yes. This is the long version: when to require approval, how LangGraph suspends and resumes a graph mid-flight, and how to deploy the whole thing onto Bedrock AgentCore — production-grade, end to end.
Advanced Context Engineering: Beyond Prompts, Beneath the Hallucinations
Why prompt engineering is no longer the bottleneck, how context rot quietly destroys long-running agents, and the concrete patterns — JIT retrieval, typed state, compression, quarantined inputs — that make context engineering a real discipline.
Building MCP Servers That Agents Can Actually Use — and Trust
A builder's guide to MCP servers: tool-design best practices, exposing remote servers securely (transports, OAuth scopes, validation, audit), and the exact flow to connect, allow-list, and test a remote server inside an AgentSwarms agent.
Securing Agentic AI: A Layered Defense Playbook
A layer-by-layer security playbook for production agents — identity, prompt, model, tools, memory, network, governance — with reference architectures for Bedrock AgentCore, Azure AI Foundry, and Vertex Agent Engine, and an open-source toolkit to harden the rest.
Designing Agentic AI for Production: The Six Pillars
Most agentic AI projects die in the gap between 'works in the notebook' and 'survives Monday morning traffic'. We walk the six pillars of production agent design — identity, security, scalability, high availability, observability, and cost control — then deploy a LangGraph multi-agent system on AWS Bedrock AgentCore, mapping every pillar to a concrete service.
The Agent That Remembers: Inside Hermes and Self-Improving Agents
A static system prompt is a ceiling; a stateless agent is Groundhog Day. Hermes breaks both. We unpack its evolving cross-session memory (and how it persists without blowing up the context window), the agentskills.io standard that turns winning trajectories into searchable, portable markdown tools, and its parallel sandboxed sub-agents — plus an honest enterprise-feasibility scorecard.
Deploy Agents to Bedrock, Azure & Google Cloud — One Open-Source CI/CD Pipeline
The companion build guide to our DevOps playbook. First-time setup for each cloud's agent runtime, then a unified GitHub Actions pipeline that deploys the same containerized agent to AWS, Azure, and GCP — with OIDC, eval gates, progressive rollout, and OpenTelemetry tracing. No long-lived keys, no vendor lock-in on the pipeline.
DevOps for Agentic AI: An Open-Source Playbook
Why agentic AI needs its own brand of DevOps, how to plan before you build, what the over-time pipeline actually looks like, the open-source stack to assemble it from, the gotchas that take teams down, and a gamified maturity self-assessment. The longest, most practical DevOps-for-agents read we could write.
The MCP Server You Actually Ship: 2026 Playbook
MCP solves the n×m integration mess that was strangling agent tooling. We cover what it actually is (and isn't), how the JSON-RPC handshake works, why it wraps but doesn't replace REST — and the security work that separates a demo MCP server from one you'd put in production, including the confused-deputy attack.
Keeping RAG Honest When Your Documents Change
RAG is only as fresh as its index. Why retrieval rots as docs change, how to detect drift with content hashing, and re-indexing strategies that scale.