Oct. 20, 2026
pi-durable, from the ground up
I built a runnable example of pi-durable and tested every lesson in it. The code lives at avparkhi/pi-durable-hello. The example has five scripts and one SQLite file. It uses a free fake model by default. It needs no server, no web UI, and no cloud. This post explains what the library does, and why each piece exists.
[... 1,423 words]June 12, 2026
Hermes Agent: The Self-Improving Story
An AI assistant that gets a little better every time you talk to it. Nobody retrains the model. Here is how that actually works, told as a story.
[... 1,884 words]May 29, 2026
Claude Code Dynamic Workflows: Inside Out
Dynamic workflows look like a feature. Mechanically they are something more interesting: a tiny JavaScript runtime that the orchestrator model writes a program for, mid-turn, and then runs deterministically.
[... 2,710 words]April 24, 2026
AgentCore Harness, Inside Out
What actually runs when AWS says “declarative agents”, and when it is the right tool.
[... 2,589 words]April 23, 2026
MCP Apps Explained: How AI Agent Shows Live Widgets Inside the Chat
I built a greeting card generator and got confused. The AI agent showed a real card with buttons inside the chat, and I couldn’t understand why. Here’s what I learned. I explain it the way I wanted someone to explain it to me.
[... 2,162 words]April 14, 2026
AgentCore Registry: The Missing Yellow Pages for AI Agents
How we stopped hardcoding ARNs. What we learned when we published an MCP server and an A2A agent. The VPC-endpoint footgun that shipped into every team’s first demo.
[... 2,484 words]April 9, 2026
Beyond Tool Calling: A Practical Tour of Advanced MCP Concepts
If you used MCP for a few weeks, you already know the basics. A server exposes tools, resources, and prompts. A client (usually an LLM-driven agent) calls them. That mental model gets you surprisingly far. But it also flattens MCP into “just tool calling.” You start to wonder what makes the protocol more interesting than a plain JSON-RPC schema.
[... 2,870 words]I Built an Agent in 5 Minutes: Anthropic Managed Agents vs AWS AgentCore + Strands
A side-by-side look at two very different bets on what “agent infrastructure” should mean.
[... 1,670 words]April 5, 2026
AgentCore Auth from First Principles: How JWT Flows from Browser to Agent Container
Suppose you deploy a React frontend on S3+CloudFront that talks directly to AWS AgentCore Runtime. No API Gateway, no Lambda proxy. Is that secure? We traced every byte from browser to agent container to answer that question.
[... 1,430 words]HTTP vs AG-UI: What Actually Changes in Your React Code
One question appears after you understand how AG-UI works: isn’t this just HTTP streaming with a defined event format? Could you achieve the same thing with the HTTP protocol if you defined the same output structure?
[... 1,467 words]April 4, 2026
All Four AgentCore Protocols Are Just HTTP: What AG-UI, MCP, and A2A Actually Do
A question that appears once you understand how AG-UI works: isn’t this just HTTP streaming with a defined event format? Could you achieve the same thing with the HTTP protocol if you defined the same output structure?
[... 1,469 words]HTTP vs MCP vs A2A vs AG-UI: The Four Protocols of AgentCore Runtime
When you deploy an agent to AWS AgentCore Runtime, you pick a protocol: HTTP, MCP, A2A, or AGUI. This choice determines how your agent talks to the outside world: what it receives, what it sends back, and who it talks to. All four run on identical infrastructure. The differences live entirely in the framing and application layers.
[... 2,407 words]AG-UI Protocol: A Layer-by-Layer Deep Dive with Real Network Captures
There’s a common misconception about AG-UI: people treat it as a transport protocol. It isn’t. AG-UI rides on top of HTTP and WebSocket. It doesn’t replace them. Understanding where each layer starts and stops is the key to debugging, optimizing, and building correctly with it.
[... 2,095 words]AG-UI Protocol: The Missing Standard for AI Agent Interfaces
If you built applications with AI agents, you hit this wall: every framework has its own way of streaming responses to the UI. LangChain uses callbacks and streaming iterators. CrewAI returns completed results. AutoGen has its own message protocol. Amazon Bedrock Agents uses a proprietary streaming format. OpenAI Assistants has yet another event structure.
[... 1,995 words]March 31, 2026
Does Claude Code Test Itself? Yes — Here’s What’s Actually in the Source
Anthropic published a blog post on demystifying evals for AI agents. It recommends three grader types, eight setup steps, and a feedback loop from production back into improvement decisions. The interesting part is what the Claude Code source code reveals. The product doesn’t just follow the philosophy. It IS the eval system.
[... 1,467 words]Claude Code’s Design Philosophy: 10 Patterns to use for Your Agent Systems
This post examines Claude Code’s engineering decisions: the prompt architecture, tool philosophy, concurrency model, permission system, and memory design that make it work. Each section includes what you can apply to your own agent systems.
[... 2,426 words]Multiple MCP Servers Through Amazon Bedrock AgentCore Gateway
As AI agents scale in enterprises, teams build dozens of specialized MCP (Model Context Protocol) servers. One is for order management, another is for the product catalog, and yet another is for promotions. Each server has its own endpoint, its own auth, its own tool definitions. The agent that consumes these tools suddenly becomes an integration nightmare.
[... 1,728 words]March 28, 2026
OpenUSD: Advanced Patterns and Common Gotchas.
This post covers deeper OpenUSD concepts: schemas, rendering rules, performance patterns, and the gotchas that surprise people.
[... 1,141 words]March 25, 2026
OpenUSD Mastery: From Composition to Pipeline — A SO-101 Arm Journey
OpenUSD (Universal Scene Description) is not just a 3D modeling format. It is a universal language that describes complex scenes, their relationships, and their properties. Think of it as JSON for 3D worlds, but one that can do infinitely more.
[... 1,305 words]March 19, 2026
Learning OpenUSD — From Curious Questions to Real Understanding
Written as I explored OpenUSD before my exam. These are real questions I asked, and the answers that actually made things click for me.
[... 1,135 words]March 18, 2026
7 Mental Models for Building Agent Skills (From Anthropic’s Internal Playbook)
Anthropic just published their internal playbook for Claude Code Skills. It draws on hundreds of skills in active use. Deep mental models for building better agents sit inside the practical advice. Here’s what they’re really telling you.
[... 1,293 words]From Prompt Engineering to Harness Engineering: Building Infrastructure for Autonomous Agents
2025 was the year of agents. 2026 is the year of harnesses. A harness is the persistent infrastructure that gives a foundation model hands, feet, and senses. The shift is fundamental: from prompt engineering to harness engineering. Prompt engineering optimizes single interactions. Harness engineering builds the systems that control long-running, autonomous agents.
[... 1,179 words]March 15, 2026
The Agent Loop Iceberg — 10 Hard Problems Hiding Beneath the Simple Loop
The basic agent loop is: LLM call, tool execution, observe result, repeat. That loop is maybe 10% of a production agent’s code. The other 90% makes it reliable, resumable, extensible, and production-grade. I traced real agent source code. Here are the ten hard problems hiding beneath the surface that nobody shows you in tutorials.
[... 1,708 words]March 13, 2026
Autoresearch and Context Rot — How a Stateless Agent Loop Avoids Memory Problems (And Where It Breaks)
In the autoresearch pattern, a coding agent runs hundreds of autonomous experiments to optimize code. The pattern produced a 53% speedup on Shopify’s 20-year-old Liquid codebase and a 69x speedup on a demo text processor. But there’s a fundamental flaw nobody talks about: the agent has no memory of failed experiments. Here’s exactly how the pattern works, where it breaks, and how Tobi Lütke’s team quietly fixed it.
[... 2,409 words]How Skills Work in AI Agents — From Lazy-Loading Instructions to LLM Attention Weights
When you hear “skills” in AI agents, it sounds like a new concept. It is not. Skills are a lazy-loading pattern for instructions. The same tool-calling mechanism the LLM already uses delivers them. But the details reveal deep truths about how LLMs actually work:
[... 2,808 words]Coding in the AI Agent Age — Why Typing Code Is Dying But Engineering Is Thriving
Maybe you think coding is just putting human-defined processes into structures, loops, functions, rules, packages, and web pages. If so, you’re not wrong about the past. But that definition is dying. AI automates the typing. What remains is the thinking.
[... 1,396 words]Mental Models in the AI Agent Age
Mental models are compressed knowledge of human experience. Many thinkers discovered these patterns over centuries across physics, biology, economics, mathematics, and systems theory. In the age of AI agents, these same patterns don’t just help you think better. They help you build better systems, debug reality faster, and make decisions that compound over decades.
[... 1,760 words]March 12, 2026
I Ran 100 Parallel Tool Calls on AgentCore — The microVM Didn’t Break, But the LLM Did
What happens when you fire 100 tool calls in parallel inside a single AgentCore microVM? Does the microVM crash? Does it run out of memory? Does the thread pool explode? I deployed an agent with 100 tools to Amazon Bedrock AgentCore Runtime and ran a scaling test from 5 to 100 parallel tool calls. Here’s exactly what happened.
[... 2,716 words]The 95% Rule: Why Your Agent Is Slow and How to Prove It
Your agent takes 5 seconds to respond. Where did those 5 seconds go? AgentCore gives you 6 observability layers, 30 hidden metrics, and a debugging decision tree. But you have to know where to look. Here’s everything you can’t see by just reading the code.
[... 2,831 words]What Actually Happens When You Call invoke_agent_runtime()
You call invoke_agent_runtime(). Your agent responds 3 seconds later. But what actually happened in those 3 seconds? There’s an entire orchestration layer that you never see: sidecars, health checks, microVM boot sequences. Here’s the full picture.