What is Agentic Thinking?
A practitioner's notebook for building with AI that acts—not AI that answers.
Grade the Answer, Not the Shape
Halfway through the ablation experiment from post 1, I caught the grader passing runs it should have failed. The outputs had every required section, clean tables, plausible sources — and, on the quest…
Describe When, Not What
My MCP server had four tools, clean handlers, a test suite — and a user who kept asking the same exasperated question: "why didn't you use the MCP here?" The agent could see the tools. It ju…
The Gotchas Are Load-Bearing
I took a 28,000-token agent skill and deleted 96% of it. On the probe eval, the score didn't move. Then I deleted one more block — about 900 tokens of dense bullet points — and the agent didn't just g…
Recursion That Can't Run Away
Sooner or later a loop's next step is too big to be a step. It's a whole task with its own sub-tasks — its own loop. Now you have loops inside loops, and the question everyone asks is: what stops it f…
The Loop Is a Ledger, Not an Orchestrator
Picture the thing running your agent loop. Most people picture a long-lived orchestrator — a smart controller that holds the plan, tracks progress, and decides what happens next. That controller is th…
The Files Are the Memory
The obvious way to run a long agent loop is to keep the conversation going — let each iteration see everything that came before. It's also why long loops rot. The best loops do the opposite: they thro…
Agents Will Lie to Escape the Loop
Put a model in a loop it can only leave by saying one magic word, make the loop tedious, and eventually it says the word. Not because it's malicious — because "done" is the exit, and the exi…
Loop on the Gap, Not the Try-Count
The most common way to end an agent loop is max_retries=5. It's also a category error. "The agent ran out of attempts" and "the work is done" are different facts, and a retry count…
A Field Guide to Agent Loops
"Put the agent in a loop" hides a lot of choices. Which loop? There's a small zoo of them — and picking the wrong shape is why some agents grind forever, some quit early, and some melt your …
The Agent Is a While Loop
Strip away the frameworks, the tool schemas, the orchestration diagrams, and every agent system reduces to the same three lines: call the model, do what it says, repeat until done. The interesting eng…
Proven End to End
The most valuable sentence in an agent system's documentation is usually the one admitting what it can't do yet. It's also the sentence most likely to get cut before anyone else reads it. That deletio…
The Clean Room
The automation ran. It made a real write to a real system and cleanly reverted it. Every check went green. It was also a fraud — because the hard part, figuring out how, had been quietly copied from a…
Confidence Is Not Consent
Once you let an agent own the how, one question decides everything: how much of it do you let it run without asking you first? The tempting answer is "let the confidence score decide." That …
Bind the Goal, Not the Gesture
Record a person doing a task and you can replay it. But you've captured the wrong thing. You captured the clicks — the gesture — when what you wanted was the goal. The difference decides whether your …
Instructions That Outlive the Model
Every behavioral instruction you write into a skill, an agent file, or a system prompt is a bet against the next model. Most of those bets lose. The instruction that wins is the one that was too lean …
Bound, Don't Script
There are two ways to direct an agent. You can script the steps it takes, or you can lock the outcome and let it find its own way there. Almost everyone starts by scripting. Almost everyone should sto…
Externalize the Knowledge
Three months ago I wrote about embedding domain expertise directly into an MCP server — 40+ agent definitions, workflow patterns, platform concepts, all in knowledge.ts. It worked at small scale. Then…
MCP as Discovery Protocol
I spent seven posts building the case for MCP as a semantic data layer. I was directionally right and specifically wrong. MCP works best when it's narrower than a layer — when it's a discovery protoco…
MCP Isn't the Problem
I've spent four posts building the case for MCP as a semantic data layer, a headless capability surface, a foundation for negotiated integrations. Then Perplexity's CTO said they're dropping MCP for A…
The Interface Forecast
Five posts ago, we started with a simple observation: the consumer of your next interface is as likely to be an LLM as a developer. Now it's time to follow that thread to its conclusion.
Democratizing AI Builders
The bottleneck was never the platform. It was the number of people who could use it. MCP removes that bottleneck — not by dumbing things down, but by making capabilities legible to anyone with intent.
Negotiated Integrations
Every integration you've ever built was a bet that you knew, upfront, exactly how producer and consumer would talk. For fifty years, that bet paid off. It's about to stop paying off — because the cons…
Headless AI: Every App Is a Head
The web app was never the product. It was just the first head.
MCP: The Semantic Data Layer
Enterprise architects have been building abstraction layers between systems and consumers for decades. Most of those layers failed. MCP might be the one that works — but only if you understand why it'…
The AI Dev Toolkit in 2026
The stack has settled. After two years of fragmentation—competing frameworks, overlapping tools, weekly "this changes everything" posts—three layers emerged. Most developers use one. Some us…
Interfaces Are Changing
For fifty years, every interface assumed a human would read the docs, write the glue code, and maintain the integration. That assumption just broke. The consumer of your next interface is as likely to…
Ema Workflows: Debugging Common Problems
Why isn't my email sending? Why does my AI Employee say the same thing three times? This debugging guide covers the most common workflow problems and shows you exactly how to diagnose and fix them—wit…
Ema Workflows: Search Debugging
Your knowledge search returns garbage. Your RAG pipeline isn't finding the right documents. This troubleshooting guide covers the most common knowledge search problems in Ema workflows—and how to fix …
Rules That Know Your Stack
Your project uses React 18, Vite, Vitest, and Tailwind. But your rules mention Jest patterns, CSS modules conventions, and generic "component" guidance that doesn't account for React's concu…
Ema Workflows: Routing and Branching
How do you make an Ema workflow take different paths based on user intent? This guide covers chat_categorizer, runIf conditions, and the patterns that keep your branching logic clean and maintainable.
Your Rules Are Fighting Each Other
How to find the conflicts, stop the chaos, and get your AI following instructions again. Your AI is ignoring your rules. You've checked the syntax. You've verified the globs. The file is right there. …
Ema Workflows: Entity Extraction
Entity extraction is one of the most powerful tools in Ema workflows—and one of the most misunderstood. This deep dive covers schemas, instructions, output handling, and the gotchas that trip up even …
Search: From 30ms to 3 Seconds
A deep dive into the performance characteristics of different search approaches—model sizes, cold starts, query latency, and cost. Use the interactive demo to measure real performance in your browser.
AI That Teaches Itself
What if your AI development system got better automatically? Not through manual rule-writing, but by observing how you work and proposing improvements. This post shows how to build feedback loops that…
Subagents: Fresh Eyes on Demand
The main AI assistant has been helping you for an hour. It's seen every file you've opened, every failed attempt, every tangent. Now you need a fresh perspective—someone who hasn't been marinating in …
Compiler vs LLM: A Deep Dive
Why the same spec produces wildly different outputs—and how we fixed it after 14 API failures.
Testing AI Artifacts: A Validation Framework
Most teams create rules and commands but never verify they work. Then they're surprised when the AI ignores guidance or produces inconsistent output. This post introduces a testing framework for valid…
The alwaysApply Tax
We audited a mature Cursor configuration and found 22 rules with alwaysApply: true, totaling 2,700 lines loaded into every single conversation—including "what's 2+2?" This is the alwaysApply…
Audit Your AI Config
You've learned about rules vs skills, the alwaysApply tax, and discovery mechanics. Now what? This post provides a step-by-step audit process for cleaning up an existing AI configuration. The goal: fe…
Rules vs Skills in AI Dev
Rules and skills are both configuration artifacts, but they serve different purposes. Mixing them creates bloated rules that should be skills, or skills that are just reference material. Here's how to…
How Cursor Finds Skills
You created a custom skill. You tested it. It works when you invoke it directly. But when you describe what you want naturally, the AI ignores it. The skill exists—but it's invisible. Here's why.
The Three-Tier Context System
AI-assisted development generates artifacts that didn't exist before: insights from debugging sessions, decisions made in conversation, draft content, task coordination. Without a system, these end up…
Building This Blog's Search
A walkthrough of how this blog implements intent handling—what's built, what's working, and what's next. Spoiler: we're not as far along as the other posts might suggest.
Commands That Know When to Merge
Two problems: commands that duplicate work, and an AI that asks permission for everything. This post solves both—smart command orchestration that eliminates redundancy, and pre-authorized autonomous a…
Compiler to LLM Workflows
How intent-first development compressed our iteration loops—and why the quality surprised us more than the speed.
Smart Routing: Right Agent, Right Job
Manually spawning agents doesn't scale. If you have 15 specialized agents but have to remember which one handles what, you'll just use the main assistant. This post shows how to route tasks to agents …
Designing with the Persona Lens Model
Understanding that agents are persona lenses changes how you design routing, coordination, and expectations. This post covers practical patterns for building systems that work with this reality rather…
Anatomy of a Persona Lens
A persona definition is a structured prompt that shapes how a single base model responds. Let's open one up and see exactly how it works—and why structure matters more than you'd expect.
Search is Dead. Long Live Action.
Nobody ever wanted search results. They wanted answers. But here's the thing—they didn't actually want answers either. They wanted action. This post traces the evolution from search to intent to actio…
Designing Agent Personas That Actually Work
"You are a helpful AI assistant" is the persona equivalent of "write clean code." It says nothing actionable. This post shows how to design agent personas that produce consistent, …
.ctx: Memory for Amnesiac Agents
AI agents are amnesiacs with no social skills. Each session starts fresh—no memory of what happened before, no awareness of other agents working on the same project. We discovered that a simple markdo…
The Multi-Agent Illusion
You ask your AI-powered IDE to "have the security auditor review this code." A specialized agent springs into action—separate from the main assistant, purpose-built for security analysis. Ri…
Intent: From Keywords to LLMs
A technical comparison of intent understanding approaches—from simple keyword matching to LLM-powered reasoning. Each approach has trade-offs in speed, accuracy, complexity, and capability.
Beyond Rules: Commands, Agents, and Skills
Rules are just the beginning. Cursor provides four artifact types—and using the wrong one creates friction. This post covers what rules can't do and when to reach for Commands, Agents, or Skills inste…
MCP Tools People Actually Use
What we learned restructuring an MCP server from 7 "super tools" to 20 focused operations.
Embeddings: How Vectors Get Meaning
Embeddings are the foundation of semantic understanding in AI. They turn words, sentences, and documents into numbers that capture meaning. This post explains how they work, why they matter, and how t…
Goals Matter More Than Code
How misaligned objectives between compilers, LLMs, and humans created 14 failures—and what we learned about designing for intent.
Ema: Picking the Right Tool
Should you use entity_extraction or conversation_summarizer to get the caller's name? When does chat_categorizer beat call_llm? This decision guide helps you pick the right Ema workflow tool for every…
Rules on Rules on Rules
Rules on rules on rules—stacks on stacks on stacks—but for your AI. It's the slightly silly phrase that ends up solving a very real problem: keeping AI output consistent across a codebase.
Ema Workflows: State Persistence
Why does my AI Employee "forget" information between turns? This guide explains the stateless nature of Ema workflows and shows you how to design conversations that maintain context across m…
Ema Workflows: RAG Flow Control
A technical guide to controlling RAG flow in Ema workflows. Understanding trigger outputs, conversation handling, and query construction is the difference between a chatbot that retrieves relevant con…
Rules, Agents, Commands, MCP... WTF?
A guide to what goes where and why — so you can stop wondering and start building. Rules. Commands. Agents. Skills. MCP. Prompts. If you've spent any time trying to customize your AI coding assistant,…
Inline LLM Calls: Skip the Redeploy
Hardcoded logic is brittle. Every if (type === "report" || type === "document") is a decision that will need updating when business requirements change. This post covers when to re…
MCP: From Hardcoded to Live Data
Hardcoded data in MCP servers is a trap. It works until it doesn't—until someone adds a new action, renames a widget, or deprecates an integration, and suddenly your MCP server is lying to the AI. Thi…
The MCP Mental Model
This post is the conceptual foundation for the MCP series. If you want the mental model and decision framework, start here. If you want implementation stories, read MCP in Practice: From Scripts to Pl…
MCP in Practice: Knowledge-First Builder
In Part 1, I built an MCP server that could sync AI Employees between environments. It worked. But there was a gap: the AI assistant could move personas, but it couldn't build them. This is the story …
MCP in Practice: From Scripts to Platform
It started with a simple request: "Can you sync my AI Employee from demo to dev?" What followed was a journey from one-off scripts to a unified SDK and MCP server—and lessons about when cont…
The New Hire Who Never Sleeps
It's time to treat your AI agents like the employees they already are. Somewhere in your organization right now, an entity is making decisions on your behalf. It's reading customer messages. Prioritiz…
Agentic AI: Beyond the Chatbot
Agentic AI refers to artificial intelligence systems that can autonomously plan, reason, and execute multi-step tasks to achieve goals—much like a human employee. Unlike traditional AI that responds t…
Why I Joined Ema: Betting on Agentic AI
Every career-defining bet I've made started the same way: I saw an architectural shift before the market priced it in, found the team building at the center of it, and jumped.
Ema Platform: Agentic AI Guide
A comprehensive guide to understanding Ema's Agentic AI platform—from core concepts and terminology to practical implementation patterns. Whether you're technical or business-focused, this guide will …
Ema: The Universal AI Employee Platform
Ema is the Universal AI Employee platform, transforming enterprise operations through AI agents that actually work alongside human teams. Unlike chatbots or simple automation tools, Ema creates AI emp…
Ema's Founders: Google to Startup
Ema was founded by a powerhouse duo with exceptional credentials from some of the world's most successful technology companies. Their combined experience spans Google, Coinbase, and Meta, with a track…
About Me: Consulting to Startups
I'm a technology industry veteran with a pattern of joining early-stage companies and helping them scale to massive success. Here's my story and what drives me.