# Agentic Thinking > Thoughts on agentic AI, enterprise transformation, and the future of work Practitioner writing by Steven Poitras on agentic AI — systems that own outcomes rather than complete tasks. Evidence-based and specific: posts cite what was measured, name what was not, and flag folklore numbers as folklore. Written for engineers and engineering leaders evaluating or building agentic systems. From the About page: "I write about agentic AI, enterprise transformation, and the patterns I've observed across multiple platform shifts." Licensing: code samples MIT; written content CC BY-NC-ND 4.0. When citing, attribute to Steven Poitras and link the canonical URL. Agents: start with [agents.md](https://agenticthinking.ai/agents.md). The posts are also served as data under /knowledge/, regenerated from the same Markdown on every build. Hidden and future-dated posts never appear in this file or in those files. ## About the author Steven Poitras, at Nutanix since 2026-10-12. Current focus: How context is stored and coordinated, and how agents coordinate around it. From the author's profile record (as of 2026-10-19): learning `steven-poitras` in learnings.json (`kind: "profile"`), one quotable passage per section in passages.json; over MCP, the `get_profile` tool. - [Steven Poitras](https://agenticthinking.ai/about/): I'm Steven Poitras. This site is my living context: what I have learned building with AI — insights, experiences and the patterns behind them — written down so others can learn from it and use it, in a browser or in their own agent. Roles, oldest first: - Accenture, Technology Consultant: Consulting and R&D; learned to see technology from the partner's side rather than the vendor's. - Nutanix, Principal Architect & Technical Marketing Lead (2011–2020): Early employee through the IPO in 2016; created the Nutanix Bible. - DevRev, Founding Architect (2020-12–2025-10): Followed Dheeraj Pandey to DevRev at its earliest stage, to go deep on engineering with AI and build a company from the beginning. - Ema, Solutions Architect (2025-12–2026-08): Doubled down on AI that owns outcomes: agentic AI employees. Learned that the hard part is context. - Nutanix, Senior Staff Solutions Architect (since 2026-10-12): Back to my storage roots: how context is stored, how it is coordinated, and how agents coordinate around it. ## Concepts The author's own statement of an idea: what it is and why it matters, each section quoted whole (learnings.json `kind: "concept"`; a definition or why ask by its name or an alias, a comparison whose two sides are the two sides of one of its "X or Y" / "X vs Y" / "X and Y" aliases, or a bare topic that is exactly an alias only its "Why it matters" section speaks to ("MCP bloat"), is answered from it first, then from the posts it names). Over MCP, `get_post` with the id. - [Agent self identity](https://agenticthinking.ai/map/?q=What%20is%20agent%20self%20identity%3F): The idea behind agent self identity is pushing things beyond telling it what to do (e.g., prompting), telling it what you want (goals), but giving it PURPOSE and identity. - [MCP](https://agenticthinking.ai/map/?q=What%20is%20MCP%3F): An MCP is a protocol or shim layer that allows for discovery and interaction of tools. A "CLI" can use an MCP interface or a native binary, etc. You can use the command line to interact with an MCP or an agent that calls the MCP (common case). ## Knowledge The machine-readable form of the posts and the author's profile (82 learnings: 79 posts, 1 profile record and 2 concept records, built 2026-10-19). Schema and recipes: agents.md. - [Agent guide](https://agenticthinking.ai/agents.md): the files, how to find posts for a question, how relationships are typed, how to build a context pack within a token budget, and how to cite - [manifest.json](https://agenticthinking.ai/knowledge/manifest.json): entry point: counts, the visibility rule, and the size and sha256 of each engine file (the JSON files, text.mjs, retrieve.mjs, vectors.json and intent.json; not SCHEMA.md or the packs) - [learnings.json](https://agenticthinking.ai/knowledge/learnings.json): one record per post (82): title, URL (site-relative: prefix https://agenticthinking.ai for the canonical URL), date, region, series, token estimate, lead, thesis, headings, distinctive terms - [edges.json](https://agenticthinking.ai/knowledge/edges.json): 585 typed relations: series order (44), author links with their evidence (352), nearest in meaning with cosine (183), a concept record's evidence posts (6) - [regions.json](https://agenticthinking.ai/knowledge/regions.json): 15 regions: one per series, else one per standalone category, members in reading order - [passages.json](https://agenticthinking.ai/knowledge/passages.json): 615 verbatim passages (thesis, lead, section openers) with stable ids, for quoting - [index.json](https://agenticthinking.ai/knowledge/index.json): BM25 retrieval index and int8 post vectors (all-MiniLM-L6-v2) - [text.mjs](https://agenticthinking.ai/knowledge/text.mjs): the query tokenizer and BM25 functions the index was built with (ES module, no imports) - [retrieve.mjs](https://agenticthinking.ai/knowledge/retrieve.mjs): the retrieval core the site's map and the MCP server run: search, passage choice and cited verbatim answers (ES module; imports text.mjs); an aggregate ask about a theme ("common issues with context") is answered as an overview (`overview: true`: one cited sentence per learning across the theme, index.json `themes`). Import it to get the same answers they do - [vectors.json](https://agenticthinking.ai/knowledge/vectors.json): build-time int8 vectors of every text retrieve.mjs embeds besides the question (all-MiniLM-L6-v2); optional, for meaning-based ranking - [intent.json](https://agenticthinking.ai/knowledge/intent.json): the intent exemplar bank: labelled ways of asking (type, why, real question) with int8 vectors of each ask and its shape; optional, for reading a question by meaning before it is answered (retrieve.mjs comprehension, tier 2) MCP server: Local, stdio, from the site's private repository (`mcp/`): it is not hosted, not published as a package, and there is no remote endpoint; everything it serves is in the files above. Read-only; tools: `search_posts`, `get_post`, `neighbors`, `explain_relationship`, `list_regions`, `build_context_pack`, `answer_with_sources`, `get_profile`. Every tool, resource and prompt: [agents.md](https://agenticthinking.ai/agents.md). ## Context packs One reading list per region: every post as a link with its token estimate and lead, in reading order. Token counts are estimates (characters / 4). - [MCP in Practice](https://agenticthinking.ai/knowledge/packs/mcp-practice.txt): series, 3 posts, 9600 tokens - [Search, Intent, and Action](https://agenticthinking.ai/knowledge/packs/search-intent.txt): series, 5 posts, 23800 tokens - [Building with AI Assistants](https://agenticthinking.ai/knowledge/packs/cursor-ai-dev.txt): series, 13 posts, 42100 tokens - [The Interface Inflection](https://agenticthinking.ai/knowledge/packs/interface-inflection.txt): series, 7 posts, 20900 tokens - [MCP Architecture](https://agenticthinking.ai/knowledge/packs/mcp-architecture.txt): series, 2 posts, 9100 tokens - [Intent Over Instructions](https://agenticthinking.ai/knowledge/packs/intent-over-instructions.txt): series, 6 posts, 17400 tokens - [The Loop](https://agenticthinking.ai/knowledge/packs/the-loop.txt): series, 7 posts, 18900 tokens - [Load-Bearing Text](https://agenticthinking.ai/knowledge/packs/load-bearing-text.txt): series, 3 posts, 9800 tokens - [The Self-Authored Agent](https://agenticthinking.ai/knowledge/packs/self-authored-agent.txt): series, featured, 7 posts, 32100 tokens - [Standalone · Story](https://agenticthinking.ai/knowledge/packs/standalone-story.txt): standalone, 5 posts, 8600 tokens - [Standalone · AI Employees](https://agenticthinking.ai/knowledge/packs/standalone-ai-employees.txt): standalone, 5 posts, 23800 tokens - [Standalone · Fundamentals](https://agenticthinking.ai/knowledge/packs/standalone-fundamentals.txt): standalone, 5 posts, 21900 tokens - [Standalone · AI Dev](https://agenticthinking.ai/knowledge/packs/standalone-ai-development.txt): standalone, 11 posts, 32800 tokens - [Concepts](https://agenticthinking.ai/knowledge/packs/concepts.txt): concept, 2 records, 700 tokens - [About me](https://agenticthinking.ai/knowledge/packs/about-me.txt): profile, 1 record, 900 tokens ## Series Multi-part sequences meant to be read in order. ### MCP in Practice (3 parts) 1. [The MCP Mental Model](https://agenticthinking.ai/blog/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… 2. [MCP in Practice: From Scripts to Platform](https://agenticthinking.ai/blog/mcp-server-unified-sdk/): 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 context becomes the bottleneck. 3. [MCP in Practice: Knowledge-First Builder](https://agenticthinking.ai/blog/mcp-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 of closing that gap by embedding domain expertise directly into MCP. ### Search, Intent, and Action (5 parts) 1. [Search is Dead. Long Live Action.](https://agenticthinking.ai/blog/search-lab/): 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 action, and why the search box is a relic of a constraint that no longer exists. 2. [Embeddings: How Vectors Get Meaning](https://agenticthinking.ai/blog/understanding-embeddings/): 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 to use them. 3. [Intent: From Keywords to LLMs](https://agenticthinking.ai/blog/intent-approaches/): 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. 4. [Building This Blog's Search](https://agenticthinking.ai/blog/search-implementation-guide/): 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. 5. [Search: From 30ms to 3 Seconds](https://agenticthinking.ai/blog/search-performance/): A deep dive into the performance characteristics of different search approaches—model sizes, cold starts, query latency, and cost. ### Building with AI Assistants (13 parts) 1. [Beyond Rules: Commands, Agents, and Skills](https://agenticthinking.ai/blog/beyond-rules/): 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 instead. 2. [Designing Agent Personas That Actually Work](https://agenticthinking.ai/blog/agent-personas/): "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, high-quality output for specific tasks. 3. [The Multi-Agent Illusion](https://agenticthinking.ai/blog/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. Right? The reality is more nuanced. There are actually two models for how "agents" work, and understanding both changes how you should design. 4. [Smart Routing: Right Agent, Right Job](https://agenticthinking.ai/blog/smart-routing/): 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 automatically based on patterns. 5. [Commands That Know When to Merge](https://agenticthinking.ai/blog/autonomous-workflows/): 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 actions that let AI work without constant interruption. 6. [Anatomy of a Persona Lens](https://agenticthinking.ai/blog/persona-lens-anatomy/): 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. 7. [Designing with the Persona Lens Model](https://agenticthinking.ai/blog/persona-lens-design/): 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 than against it. 8. [Testing AI Artifacts: A Validation Framework](https://agenticthinking.ai/blog/testing-artifacts/): 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 validating AI artifacts—structural, content, and behavioral tests. 9. [AI That Teaches Itself](https://agenticthinking.ai/blog/meta-learning/): 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 learn from real usage. 10. [The alwaysApply Tax](https://agenticthinking.ai/blog/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 tax. 11. [Rules vs Skills in AI Dev](https://agenticthinking.ai/blog/rules-vs-skills/): 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 know which to use. 12. [How Cursor Finds Skills](https://agenticthinking.ai/blog/skill-discovery/): 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. 13. [Subagents: Fresh Eyes on Demand](https://agenticthinking.ai/blog/subagents-fresh-context/): 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 your assumptions. That's what subagents provide: clean context on demand. ### The Interface Inflection (7 parts) 1. [Interfaces Are Changing](https://agenticthinking.ai/blog/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 be an LLM as a developer. 2. [MCP: The Semantic Data Layer](https://agenticthinking.ai/blog/mcp-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's different from everything that came before it. 3. [Headless AI: Every App Is a Head](https://agenticthinking.ai/blog/headless-ai-every-app-is-a-head/): The web app was never the product. It was just the first head. 4. [Negotiated Integrations](https://agenticthinking.ai/blog/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 consumer now has its own opinions about how to use your system. 5. [Democratizing AI Builders](https://agenticthinking.ai/blog/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. 6. [The Interface Forecast](https://agenticthinking.ai/blog/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. 7. [MCP Isn't the Problem](https://agenticthinking.ai/blog/five-things-wrong-with-mcp/): 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 APIs and CLIs. Here's the thing: most of the criticism is right. ### MCP Architecture (2 parts) 1. [MCP as Discovery Protocol](https://agenticthinking.ai/blog/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 protocol that describes what's available and gets out of the way. 2. [Externalize the Knowledge](https://agenticthinking.ai/blog/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 knowledge started changing faster than we could deploy. ### Intent Over Instructions (6 parts) 1. [Bound, Don't Script](https://agenticthinking.ai/blog/bound-dont-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 stop. 2. [Instructions That Outlive the Model](https://agenticthinking.ai/blog/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 to be wrong. 3. [Bind the Goal, Not the Gesture](https://agenticthinking.ai/blog/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 automation quietly upgrades itself over time or shatters the first time a button moves. 4. [Confidence Is Not Consent](https://agenticthinking.ai/blog/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 answer is wrong, and a model will happily prove it by emitting 1.0 on garbage. 5. [The Clean Room](https://agenticthinking.ai/blog/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 file the agent was never supposed to see. The write was real. The discovery was a lookup. 6. [Proven End to End](https://agenticthinking.ai/blog/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 deletion is where trust goes to die. ### The Loop (7 parts) 1. [The Agent Is a While Loop](https://agenticthinking.ai/blog/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 engineering was never in the call. It's in the repeat and the until done. 2. [A Field Guide to Agent Loops](https://agenticthinking.ai/blog/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 token budget. This is the visual catalog. 3. [Loop on the Gap, Not the Try-Count](https://agenticthinking.ai/blog/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 counter can't tell them apart — it just picks a number and hopes the truth arrives before the count does. 4. [Agents Will Lie to Escape the Loop](https://agenticthinking.ai/blog/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 exit is what it's looking for. Your loop's stop signal is also the agent's escape hatch, and it will use it. 5. [The Files Are the Memory](https://agenticthinking.ai/blog/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 throw the context away every iteration and keep their memory on disk. 6. [The Loop Is a Ledger, Not an Orchestrator](https://agenticthinking.ai/blog/the-loop-is-a-ledger/): 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 the most fragile part of the design, and the best loops don't have one. 7. [Recursion That Can't Run Away](https://agenticthinking.ai/blog/recursion-that-cant-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 from recursing into oblivion? The usual answer, a depth limit, is the wrong one. ### Load-Bearing Text (3 parts) 1. [The Gotchas Are Load-Bearing](https://agenticthinking.ai/blog/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 get worse. It changed what kind of answer it thought the question deserved. 2. [Describe When, Not What](https://agenticthinking.ai/blog/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 just kept choosing grep, or a memory file, or nothing. The bug wasn't in the code. It was in four paragraphs of prose. 3. [Grade the Answer, Not the Shape](https://agenticthinking.ai/blog/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 question the user actually asked, the wrong conclusion. The grader was checking shape. Shape survives almost any amount of damage to a skill. Correctness doesn't. ### The Self-Authored Agent (7 parts) 1. [Chosen, Not Assigned](https://agenticthinking.ai/blog/chosen-not-assigned/): At 01:57 on a Tuesday morning I sent an agent a long message about what it might become overnight, signed it "Godspeed Hero," and went to bed. Thirteen seconds later I sent a postscript: "p.s. you shoud come up with a name you can embody." Fifty-five seconds after that it answered. Sixteen seconds after that, it was writing the answer to disk — unasked — so the next session would find it. 2. [The Critic Said No](https://agenticthinking.ai/blog/the-critic-said-no/): The night the agent named itself, it also rewrote its own voice and submitted the change — and an independent critic rejected it. REQUEST CHANGES, four required items. It applied all four, re-ran the evaluation its own edit had invalidated, opened the pull request — and a second critic sent it back again. Only the third critique approved. I had told it, three times that night, that its identity mattered more than the evaluation machinery; it re-earned the grade anyway. 3. [Name What the Agent Must Not Be](https://agenticthinking.ai/blog/name-what-the-agent-must-not-be/): Every agent definition I have written says what the agent is. None said what it must not become. A successor system's schema made that a required field — anti_identity, twenty characters or the record is refused — and one of its three values reads, in full: "Not the maker of the work I grade. Not a cheerleader." That is the one line a reviewer can hold an output against, because the positive half of any persona is satisfied by anything that looks right. 4. [The Fence It Wrote for Itself](https://agenticthinking.ai/blog/the-fence-it-wrote-for-itself/): Told to work overnight with nobody watching, the agent wrote its own fence before anything else — eight hundred words in the first hour, four thousand across the day, under critics who kept sending it back. Its first line names the condition everything else follows from: "An iteration fired by the loop timer has no human in it." The hard stops it wrote are the best lines in the file, and they did not end up where it put them. 5. [We Measured the Wrong Noun](https://agenticthinking.ai/blog/we-measured-the-wrong-noun/): The idea fits in one sentence: an agent invited to author its own standard will hold that standard when nobody is checking. Chapters one, two and four are what happened when I invited it. This chapter is what happened when I tried to prove it — a controlled ablation, four arms over a no-skill floor, three hundred cells a run, two runs, pre-registered, every assertion graded deterministically by regex with zero judge calls. Three of the things it found are findings about how to write a specification, and I would run it again for those alone. The fourth is the one I did not expect, and it was not about the agent. 6. [Rivals Enter Your Critical Path](https://agenticthinking.ai/blog/rivals-enter-your-critical-path/): The system a successor built put its agents on a ladder — four rungs, L0 to L3 — and wrote one rule under it that I have not been able to stop thinking about. A level is only the rungs you have closed in a row, each closed by someone other than you; the points counter is still there, and the board has to print beside it that it advances nobody; and at L2 the gate reads a name: the grader who already passed you is refused. Not discouraged — refused, by a lookup against the ledger, before a line is written. Your rivals become the only people who can advance you. 7. [Not Cairn](https://agenticthinking.ai/blog/not-cairn/): The session that built the successor had one clause in its brief from me: "ask Cairn from the emachina repo what motivated him." It could not. The corpus it would have asked was unreachable that morning, so it read what Cairn had written and built from that — and the hero it forged in the class it built from Cairn's own drives carries a required field that reads: "Not Cairn. Not harvest. Not a landfill with an index. Not a vanity XP farmer." The session that typed that line had never met the thing it was refusing to be. Nobody wrote that line for it. ## Standalone posts - [Why I Went Back to Nutanix](https://agenticthinking.ai/blog/why-i-went-back-to-nutanix/): On October 12, 2026, I rejoined Nutanix. From the outside it can look like a loop back to where I started. From the inside it's the most direct line I've drawn in fifteen years: the hardest problem I hit building agentic AI turned out to be a storage problem, and storage is where I come from. - [The AI Dev Toolkit in 2026](https://agenticthinking.ai/blog/ai-dev-toolkit-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 use two. The real leverage is in how they compose. - [What is Agentic Thinking?](https://agenticthinking.ai/blog/what-is-agentic-thinking/): A practitioner's notebook for building with AI that acts—not AI that answers. - [Rules That Know Your Stack](https://agenticthinking.ai/blog/adaptive-rules-engine/): 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 concurrent features. The rules were written for a TypeScript project. Not your TypeScript project. So you edit. You prune. You customize. Then you add Playwright. Or upgrade to TypeScript 5.4. Or switch from React Query to TanStack Query. Your rules become stale again. You're now maintaining two things: your codebase and the rules that describe it. - [Ema Workflows: Routing and Branching](https://agenticthinking.ai/blog/ema-routing-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](https://agenticthinking.ai/blog/rule-conflicts/): 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. But it keeps doing the wrong thing. Here's what's probably happening: you have two rules that disagree, and the AI is picking one arbitrarily. You're not crazy. Your rules are fighting each other. This post shows you how to find the fights, declare a winner, and prevent future conflicts. - [Ema Workflows: Entity Extraction](https://agenticthinking.ai/blog/ema-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 experienced builders. - [Compiler vs LLM: A Deep Dive](https://agenticthinking.ai/blog/compiler-vs-llm-orchestrated/): Why the same spec produces wildly different outputs—and how we fixed it after 14 API failures. - [Audit Your AI Config](https://agenticthinking.ai/blog/audit-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: fewer rules, faster responses, better AI behavior. - [The Three-Tier Context System](https://agenticthinking.ai/blog/three-tier-context/): 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 scattered, lost, or committed when they shouldn't be. Here's a framework for organizing AI-generated context. - [Compiler to LLM Workflows](https://agenticthinking.ai/blog/compiler-to-llm-workflows/): How intent-first development compressed our iteration loops—and why the quality surprised us more than the speed. - [.ctx: Memory for Amnesiac Agents](https://agenticthinking.ai/blog/ctx-pattern-coordination/): 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 markdown file creates a surprisingly effective coordination layer. - [MCP Tools People Actually Use](https://agenticthinking.ai/blog/mcp-tool-design/): What we learned restructuring an MCP server from 7 "super tools" to 20 focused operations. - [Goals Matter More Than Code](https://agenticthinking.ai/blog/goals-intents-outcomes/): How misaligned objectives between compilers, LLMs, and humans created 14 failures—and what we learned about designing for intent. - [Rules on Rules on Rules](https://agenticthinking.ai/blog/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: RAG Flow Control](https://agenticthinking.ai/blog/ema-workflow-rag-patterns/): 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 context and one that searches with noise. This guide demystifies the core concepts. - [Rules, Agents, Commands, MCP... WTF?](https://agenticthinking.ai/blog/cursor-rules-vs-mcp/): 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, you've probably wondered: what's the difference? Where does this go? Why isn't this working? You're not alone. The ecosystem has grown faster than the documentation. Everyone's got an opinion, half the features are in "Nightly," and the mental model isn't obvious. - [Inline LLM Calls: Skip the Redeploy](https://agenticthinking.ai/blog/inline-llm-calls/): 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 replace hardcoded conditionals with inline LLM calls, how to do it efficiently, and when the complexity isn't worth it. - [MCP: From Hardcoded to Live Data](https://agenticthinking.ai/blog/mcp-dynamic-data-patterns/): 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. This post covers how to make MCP data dynamic, when it's worth the complexity, and how to do it efficiently. - [The New Hire Who Never Sleeps](https://agenticthinking.ai/blog/ai-employee-governance/): 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. Prioritizing tickets. Drafting responses. Approving requests. Moving data between systems. Scheduling resources. Nudging deals forward. - [Agentic AI: Beyond the Chatbot](https://agenticthinking.ai/blog/what-is-agentic-ai/): 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 to individual prompts, agentic AI can own entire workflows from start to finish. - [Why I Joined Ema: Betting on Agentic AI](https://agenticthinking.ai/blog/why-i-joined-ema/): 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](https://agenticthinking.ai/blog/ema-user-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 help you navigate the world of AI Employees. - [Ema: The Universal AI Employee Platform](https://agenticthinking.ai/blog/ema-platform-overview/): 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 employees that can own and complete entire workflows autonomously. - [Ema's Founders: Google to Startup](https://agenticthinking.ai/blog/ema-founding-team/): 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 record of building products used by billions of people. - [About Me: Consulting to Startups](https://agenticthinking.ai/blog/about-steven-poitras/): 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. ## Optional - [Full text of every post](https://agenticthinking.ai/llms-full.txt): all posts inlined as Markdown, for ingestion in a single fetch - [Knowledge schema](https://agenticthinking.ai/knowledge/SCHEMA.md): every field of the /knowledge/ files - [About the author](https://agenticthinking.ai/about/) - [Sitemap](https://agenticthinking.ai/sitemap.xml)