<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Wasim Sheikh</title>
    <description>The latest articles on DEV Community by Wasim Sheikh (@anciwasim).</description>
    <link>https://dev.to/anciwasim</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4124806%2F8b135459-4284-4c96-b849-753f453e7a89.jpg</url>
      <title>DEV Community: Wasim Sheikh</title>
      <link>https://dev.to/anciwasim</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/anciwasim"/>
    <language>en</language>
    <item>
      <title>Memory Expiry: Every Agent Lesson Needs a Source and a Date</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Fri, 13 Nov 2026 16:01:40 +0000</pubDate>
      <link>https://dev.to/anciwasim/memory-expiry-every-agent-lesson-needs-a-source-and-a-date-44e6</link>
      <guid>https://dev.to/anciwasim/memory-expiry-every-agent-lesson-needs-a-source-and-a-date-44e6</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #17. Canonical: &lt;a href="https://sheikhwasim.com/insights/memory-expiry-agent-lessons-need-a-source/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/memory-expiry-agent-lessons-need-a-source/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The agent remembered a lesson from a bad Tuesday. It kept applying it for four months.&lt;/p&gt;

&lt;p&gt;Persistent memory is the feature everyone wants in their agents right now. Let the agent learn from past runs, save what worked, and stop repeating mistakes. It sounds like pure upside. In production, it has one quiet failure: a lesson saved for a good reason on one day keeps getting applied long after the reason is gone, and nobody can tell where it came from.&lt;/p&gt;

&lt;p&gt;The fix is &lt;strong&gt;Memory Expiry&lt;/strong&gt;: every saved lesson carries its source, its scope, and a date when it must be rechecked. A lesson nobody can trace back does not get used.&lt;/p&gt;




&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A payments team runs a coding agent that opens pull requests for small fixes: dependency bumps, lint cleanups, minor bugs. The agent has long-term memory. After each run it can save short lessons it will read at the start of future runs.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; During one incident, the shared test sandbox was down for most of a day. Integration tests timed out on every run. The agent, trying to finish its task, saved a lesson: "Integration tests on the payments repo are flaky. Rely on unit tests." It was a reasonable note that day.&lt;/p&gt;

&lt;p&gt;The sandbox came back that evening. The lesson stayed. For four months, the agent skipped integration tests on every payments pull request, and its PR descriptions said "unit tests pass," which was true. Reviewers saw green checks and approved. Then a currency-rounding change shipped that unit tests could not catch, and a batch of refunds went out a few cents wrong.&lt;/p&gt;

&lt;p&gt;When the team went looking for why the agent skipped those tests, they found the lesson in memory with no date, no link to the run that created it, and no note about the outage. Nobody could say whether it was ever true.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Memory Expiry).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Source on every lesson.&lt;/strong&gt; Each saved memory stores the run ID it came from and the evidence that triggered it, for example "sandbox timeout, 14 of 14 integration tests, Jul 8."
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Scope on every lesson.&lt;/strong&gt; The lesson applies to one repo, one task type, or one tool, never "everything."
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Expiry on every lesson.&lt;/strong&gt; Lessons get a recheck date. Anything that tells the agent to skip a safety step gets the shortest one, a few days.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Recheck, don't renew.&lt;/strong&gt; On expiry, the agent retests the claim (run the integration tests once). If the claim no longer holds, the lesson is deleted, not extended.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No source, no use.&lt;/strong&gt; Lessons without a traceable run go to a review queue instead of into the prompt.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same agent, same memory store. After the change, the "flaky tests" lesson would have expired in three days, the recheck would have passed, and the note would have been gone before the rounding change existed.&lt;/p&gt;




&lt;h2&gt;
  
  
  Why agent memory goes stale
&lt;/h2&gt;

&lt;p&gt;A model's knowledge is frozen at training time, and everyone plans for that. Agent memory looks different because it is written during real work, so it feels current. But each lesson is a snapshot of one moment: one outage, one flaky API, one reviewer's preference, one workaround for a bug that has since been fixed.&lt;/p&gt;

&lt;p&gt;Memory also compounds. A lesson read at the start of every run shapes every run, and the agent rarely questions its own notes. A wrong memory is worse than no memory, because it carries the confidence of experience.&lt;/p&gt;




&lt;h2&gt;
  
  
  Memory Expiry (four layers)
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Write with provenance
&lt;/h3&gt;

&lt;p&gt;The memory write path requires a source run, the evidence, and the time. If the agent cannot point to the run, the write is rejected. This is cheap to enforce in code and impossible to rebuild later.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Retrieve by scope
&lt;/h3&gt;

&lt;p&gt;A lesson about the payments repo is not loaded for the billing repo. Retrieval filters on repo, task type, and tool before anything reaches the prompt. Narrow scope keeps one bad day from spreading.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Expire by risk
&lt;/h3&gt;

&lt;p&gt;Set expiry by what the lesson does, not by how old it is. Style preferences can last months. Anything that skips a check, widens access, or changes what gets tested expires in days. Same thinking as the &lt;a href="https://sheikhwasim.com/insights/permission-envelope-consent-that-expires/" rel="noopener noreferrer"&gt;Permission Envelope&lt;/a&gt;: trust that lasts forever was never really granted.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Recheck on expiry and on incidents
&lt;/h3&gt;

&lt;p&gt;When a lesson expires, the agent tests the claim before keeping it. When an incident happens, list every memory loaded in the runs involved. Those lessons are suspects until rechecked. Store the result in the trace, next to the &lt;a href="https://sheikhwasim.com/insights/golden-trace-eval-anchor/" rel="noopener noreferrer"&gt;Golden Trace&lt;/a&gt; you already compare against.&lt;/p&gt;




&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; Memory sits in &lt;strong&gt;State&lt;/strong&gt;, and its writes and reads should show up in &lt;strong&gt;Traces&lt;/strong&gt;.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Done Check.&lt;/strong&gt; A Done Check proves a task is right today. Memory Expiry makes sure yesterday's shortcut doesn't weaken tomorrow's check.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Blast Radius.&lt;/strong&gt; Scope limits on memory are a blast radius for lessons.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; Add one line: no agent with long-term memory ships unless every memory write has a source, a scope, and an expiry.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  A test you can run this week
&lt;/h2&gt;

&lt;p&gt;Export your agent's memory store, or whatever it reads at the start of each run. Pick 20 entries.&lt;/p&gt;

&lt;p&gt;Ask three questions for each one: (1) Can you find the run that created it? (2) Is it limited to the place it was learned? (3) Would it still be true if you checked today?&lt;/p&gt;

&lt;p&gt;If more than a couple fail the first question, stop writing new memories until the write path records a source. Then delete or quarantine anything that tells the agent to skip a step and can't be traced.&lt;/p&gt;




&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;Agents that learn are worth building. Agents that never forget are a liability. Give every lesson a source, a scope, and a recheck date, and treat untraceable memory as a guess rather than experience. The goal isn't an agent with more memory. It's an agent whose memory you can audit.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Wasim Sheikh on Substack (practicalainotes.substack.com)&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>devops</category>
    </item>
    <item>
      <title>Done Check: Write the Test Before You Delegate</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Tue, 10 Nov 2026 16:15:09 +0000</pubDate>
      <link>https://dev.to/anciwasim/done-check-write-the-test-before-you-delegate-1eco</link>
      <guid>https://dev.to/anciwasim/done-check-write-the-test-before-you-delegate-1eco</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #16. Canonical: &lt;a href="https://sheikhwasim.com/insights/done-check-write-the-test-before-you-delegate/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/done-check-write-the-test-before-you-delegate/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Every subagent said "done." The catalog was still broken.&lt;/p&gt;

&lt;p&gt;When you hand work to an agent, "done" means the agent stopped. It does not mean the work is right. Most multi-agent setups let the worker decide when its own task is finished, then ask another model to read the worker's summary and agree. That is two opinions and zero evidence.&lt;/p&gt;

&lt;p&gt;The fix is a &lt;strong&gt;Done Check&lt;/strong&gt;: before the orchestrator delegates a task, it writes a small, machine-checkable test for that task. The check runs against the real system, not the worker's report. Only the check can mark the task done.&lt;/p&gt;




&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; An e-commerce operations team migrates 1,800 product listings to a new catalog schema. An orchestrator splits the work into batches of 50 and hands each batch to a subagent. Each subagent maps old fields to new ones, writes the listings, and returns a summary. A reviewer agent reads each summary and marks the batch complete.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; Thirty-six batches came back green. Every summary said something like "Migrated 50 listings, all fields mapped." The reviewer agreed with every one. Two days after launch, customer service started getting orders for shirts with no size. About 340 listings had an empty size field, because one old format stored sizes inside the variant title, and the subagents skipped what they could not parse. Nothing lied on purpose. The summaries described what each worker tried, not what landed in the catalog.&lt;/p&gt;

&lt;p&gt;The reviewer checked the words. Nobody checked the data.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Done Check).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Write the check first.&lt;/strong&gt; Before delegating a batch, the orchestrator writes its check: every listing ID in the batch exists in the new catalog, and size, color, price, and stock are filled in for every variant.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Check real state.&lt;/strong&gt; The check queries the new catalog directly. It never reads the subagent's summary.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Workers cannot mark done.&lt;/strong&gt; A subagent can only report "submitted." The batch moves to done when the check passes.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fail with specifics.&lt;/strong&gt; A failed check returns the exact listing IDs and fields that are missing, and the batch goes back to a worker with that list attached.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Count the leftovers.&lt;/strong&gt; Anything a worker skipped must be listed as skipped, and the check fails if the skipped count plus the migrated count does not equal the batch size.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same model, same batches. On the rerun, the check failed 9 batches in the first hour, named the 340 listings, and the fix was a parsing rule plus one more pass.&lt;/p&gt;




&lt;h2&gt;
  
  
  Why "the agent said done" is not evidence
&lt;/h2&gt;

&lt;p&gt;An agent's sense of completion comes from its own context. It ran its steps, hit no errors it noticed, and wrote a confident summary. Silent skips, partial writes, and a tool that returned success without doing anything all look fine from the inside.&lt;/p&gt;

&lt;p&gt;Adding a second model to review the summary does not fix this. It reads the same story and finds it reasonable. I learned this the hard way with 18 subagents on one sprint board: each one finished, each one undid someone else's work, and the QA agent signed off on all of it. Review needs something the worker does not control, and the cheapest thing a worker does not control is the actual state of the system.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Done Check (four layers)
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Written at delegation time
&lt;/h3&gt;

&lt;p&gt;The check is part of the task, not an afterthought. If the orchestrator cannot write a check for a task, the task is too vague to delegate. Split it until each piece has a check. This one rule improves planning more than any prompt tweak.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Run against the system of record
&lt;/h3&gt;

&lt;p&gt;Query the database, call the API, run the test suite, diff the file. Read-only, deterministic code where possible. A model can help write the check, but the check itself should be boring code that gives the same answer twice. Same idea as the &lt;a href="https://sheikhwasim.com/insights/boundary-contract-tools-fail-boring/" rel="noopener noreferrer"&gt;Boundary Contract&lt;/a&gt;: hard rules live outside the model.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Only the check closes the task
&lt;/h3&gt;

&lt;p&gt;Status moves through submitted, checking, then done or returned. No agent, including the orchestrator, can skip the check. A pass carries proof with it: which check ran, what it queried, and the counts it saw. That record goes in the trace and in the &lt;a href="https://sheikhwasim.com/insights/handoff-note-agents-fail-at-the-seams/" rel="noopener noreferrer"&gt;Handoff Note&lt;/a&gt; for whoever picks up next.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Failures are work orders
&lt;/h3&gt;

&lt;p&gt;A failed check returns a precise list, not a vibe. "Listings 4411, 4417, and 4502 are missing size" is a task a worker can finish. Cap the number of returns per task, and after the cap, route it to a person. Pair it with a &lt;a href="https://sheikhwasim.com/insights/run-budget-agents-need-a-spend-limit/" rel="noopener noreferrer"&gt;Run Budget&lt;/a&gt; so a stuck task cannot loop forever.&lt;/p&gt;




&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; Done Checks live in &lt;strong&gt;Orchestration&lt;/strong&gt; and write their results to &lt;strong&gt;Traces&lt;/strong&gt;.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Receipt Gate.&lt;/strong&gt; A receipt proves a write happened once. A Done Check proves the result is correct.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Blast Radius.&lt;/strong&gt; The radius limits how much a run can change. The check confirms what it changed is right.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; Add one line: no multi-agent workflow ships unless every delegated task type has a check that reads real state.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  A test you can run this week
&lt;/h2&gt;

&lt;p&gt;Pick one workflow where an agent hands work to another agent, or where an agent marks its own tasks complete. Look at the last 20 tasks it called done.&lt;/p&gt;

&lt;p&gt;Ask two questions: (1) For each one, could a piece of code have confirmed it without reading the agent's summary? (2) Did anything actually run that code before the task was marked done?&lt;/p&gt;

&lt;p&gt;If the first answer is no, the tasks are too vague to delegate. If the second is no, you are trusting a summary. Write the check before the next delegation, not after the next incident.&lt;/p&gt;




&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;Agents are good at doing work and bad at grading it. Write the check when you delegate, run it against the real system, let only the check mark a task done, and send failures back as specific lists. You do not need a smarter reviewer. You need a reviewer that looks at the data.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Wasim Sheikh on Substack (practicalainotes.substack.com)&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>testing</category>
    </item>
    <item>
      <title>Blast Radius: Cap What One Agent Run Can Touch</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Fri, 06 Nov 2026 16:32:17 +0000</pubDate>
      <link>https://dev.to/anciwasim/blast-radius-cap-what-one-agent-run-can-touch-3moi</link>
      <guid>https://dev.to/anciwasim/blast-radius-cap-what-one-agent-run-can-touch-3moi</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #15 — canonical: &lt;a href="https://sheikhwasim.com/insights/blast-radius-cap-what-one-run-can-touch/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/blast-radius-cap-what-one-run-can-touch/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The agent stayed inside budget. That was not enough.&lt;/p&gt;

&lt;p&gt;It closed 412 tickets in forty minutes, spent almost nothing, and left every dashboard green. Tokens, tool calls, time, and dollars all stayed under the &lt;a href="https://sheikhwasim.com/insights/run-budget-agents-need-a-spend-limit/" rel="noopener noreferrer"&gt;Run Budget&lt;/a&gt; you added last sprint. The damage was elsewhere. One bad classification rule touched every open ticket in the queue.&lt;/p&gt;

&lt;p&gt;Most teams limit how much an agent can &lt;em&gt;spend&lt;/em&gt;. Almost nobody limits how much it can &lt;em&gt;change&lt;/em&gt;. A model with write tools and a wide queue is a blast radius with a prompt on top. The fix is a &lt;strong&gt;Blast Radius&lt;/strong&gt;: every run starts with a hard cap on writes, entities, and systems it can touch, enforced in plain code. When the cap trips, the run stops and the fleet pauses until a person looks.&lt;/p&gt;




&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A B2B SaaS support team runs a triage agent overnight. It reads new tickets, tags them, suggests a priority, and for a short list of "spam / duplicate / out of scope" patterns it can close the ticket and post a short reply. On a normal night it closes about 20 tickets and tags a few hundred. Cost is pennies.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; A new prompt version tightened the "out of scope" pattern. The model started matching anything that mentioned a competitor, a free-tier limit, or a feature request. The agent still called one tool per ticket, stayed well under its token and dollar caps, and finished early. By morning, 412 tickets that needed a human reply were closed with the same canned note. Reopening them took two days and a public apology in the community forum. The Run Budget report said the night was healthy.&lt;/p&gt;

&lt;p&gt;Every write looked cheap. The total change was the bug.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Blast Radius).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Cap change, not just spend.&lt;/strong&gt; Each run may write to at most 25 tickets, touch one product area, and call at most two write tools.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Count mutations in the orchestrator.&lt;/strong&gt; Tag updates, closes, and replies all increment the same write meter. The model never raises its own cap.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Stop at the cap with a named state.&lt;/strong&gt; When writes hit 25, the run ends as &lt;code&gt;blast_radius_exhausted&lt;/code&gt;, with the ticket IDs it already changed attached.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fleet pause on a spike.&lt;/strong&gt; If any night closes more than 2x the 7-day median, the job pauses and pages on-call before the next batch starts.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Undo path for the batch.&lt;/strong&gt; Every close carries an &lt;a href="https://sheikhwasim.com/insights/undo-ledger-every-step-has-a-reverse/" rel="noopener noreferrer"&gt;Undo Ledger&lt;/a&gt; reverse, so a bad night reopens the exact set instead of a hand-built CSV.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same model family, same queue. The next prompt regression stopped at 25 closes, paged a person, and reopened with one reverse.&lt;/p&gt;




&lt;h2&gt;
  
  
  Why a spend limit is not a safety limit
&lt;/h2&gt;

&lt;p&gt;A Run Budget answers "how expensive can this get?" A Blast Radius answers "how much of the world can this rewrite before we notice?" Cheap damage is still damage. An agent that closes tickets, updates CRM fields, or pushes config can ruin a week of customer trust for less than the cost of a coffee.&lt;/p&gt;

&lt;p&gt;Bulk tools and "process the whole queue" prompts make this worse. Each step looks reasonable. The aggregate crosses a line no single tool call can see. Spend alerts will not catch it, because the spend never spiked. You need a limit that counts &lt;em&gt;effects&lt;/em&gt;: records written, entities touched, and systems mutated.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Blast Radius (five layers)
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Three meters on every run
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Writes&lt;/strong&gt; (creates, updates, deletes, sends), &lt;strong&gt;entities&lt;/strong&gt; (distinct ticket / account / order IDs), and &lt;strong&gt;systems&lt;/strong&gt; (which backends may be mutated this run). Set them from real traces: take a normal night's change volume and allow about 2–3x, not 100x. Dollars and tokens stay on the Run Budget; these meters sit beside it.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Enforced outside the model
&lt;/h3&gt;

&lt;p&gt;The orchestrator checks the meters before every mutating tool call. Read-only tools do not count. The model can see remaining room, but it cannot widen the radius. Same rule as the &lt;a href="https://sheikhwasim.com/insights/boundary-contract-tools-fail-boring/" rel="noopener noreferrer"&gt;Boundary Contract&lt;/a&gt;: boring code owns the hard rules.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. A clean stop state
&lt;/h3&gt;

&lt;p&gt;&lt;code&gt;blast_radius_exhausted&lt;/code&gt; is a real outcome, like &lt;code&gt;approved&lt;/code&gt; or &lt;code&gt;budget_exhausted&lt;/code&gt;. It carries which meter tripped, the entity IDs already touched, and a pointer to the undo batch. A run that stops this way is a signal, not an incident you discover on social media.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Fleet pause, not just per-run stop
&lt;/h3&gt;

&lt;p&gt;One run's cap stops one bad loop. A fleet rule stops a thousand small runs that each look fine. Track closes, updates, and sends per job per hour against a rolling baseline. Cross a multiple of that baseline and pause the job, page a person, and leave the queue alone. Stamp every run with the &lt;a href="https://sheikhwasim.com/insights/release-pin-one-version/" rel="noopener noreferrer"&gt;Release Pin&lt;/a&gt; so you can tell whether the spike came from a prompt, a model, or a data shift.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Reverse the batch, not the night
&lt;/h3&gt;

&lt;p&gt;Pair the radius with an Undo Ledger. Every mutating step records its reverse. When the fleet pauses, on-call can roll back the exact entity set instead of reconstructing impact from logs. A radius without a reverse turns every trip into a scavenger hunt.&lt;/p&gt;




&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; Blast Radius lives in &lt;strong&gt;Guardrails&lt;/strong&gt; and is enforced by &lt;strong&gt;Orchestration&lt;/strong&gt;; every trip is recorded in &lt;strong&gt;Traces&lt;/strong&gt;.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Run Budget.&lt;/strong&gt; Keep both. Spend caps stop loops that burn money; radius caps stop loops that burn trust.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Receipt Gate.&lt;/strong&gt; A write that would exceed the radius never gets a receipt, because it never runs.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Permission Envelope.&lt;/strong&gt; The envelope says &lt;em&gt;what&lt;/em&gt; the agent may do; the radius says &lt;em&gt;how much&lt;/em&gt; of it in one run.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; Add one check: no agent with write tools ships without per-run write/entity/system caps and a fleet pause rule.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  A test you can run this week
&lt;/h2&gt;

&lt;p&gt;Pick one production agent that can mutate something (tickets, CRM, config, email). From last week's traces, count max writes, distinct entities, and systems touched in a single run, and the biggest hour for the whole job.&lt;/p&gt;

&lt;p&gt;Then ask two questions: (1) Is there a hard cap below "the whole queue"? (2) If a new prompt closed or updated 10x the usual volume at almost no cost, would anything pause before morning?&lt;/p&gt;

&lt;p&gt;If either answer is no, you need a Blast Radius before you need a better classifier.&lt;/p&gt;




&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;A cheap agent can still make an expensive mess. Cap writes, entities, and systems per run in plain code, make &lt;code&gt;blast_radius_exhausted&lt;/code&gt; a normal outcome with the touched IDs attached, pause the fleet when change volume spikes, and keep a reverse for the batch. The goal isn't a timid agent. It's an agent whose worst night has a known shape, a known stop, and a known undo.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Wasim Sheikh on Substack (practicalainotes.substack.com)&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>devops</category>
    </item>
    <item>
      <title>Run Budget: Every Agent Run Needs a Spend Limit</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Thu, 05 Nov 2026 16:08:12 +0000</pubDate>
      <link>https://dev.to/anciwasim/run-budget-every-agent-run-needs-a-spend-limit-2nom</link>
      <guid>https://dev.to/anciwasim/run-budget-every-agent-run-needs-a-spend-limit-2nom</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #14 — canonical: &lt;a href="https://sheikhwasim.com/insights/run-budget-agents-need-a-spend-limit/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/run-budget-agents-need-a-spend-limit/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The agent didn't crash. That was the problem.&lt;/p&gt;

&lt;p&gt;It ran all night, stayed "healthy" on every dashboard, and spent more in eight hours than the whole project had spent in a month. Nothing threw an error. It just kept trying.&lt;/p&gt;

&lt;p&gt;Most teams put limits on their APIs and none on their agents. A model that can call tools, read the result, and decide to try again is a loop with a credit card attached. The fix isn't a smarter prompt. It's a &lt;strong&gt;Run Budget&lt;/strong&gt;: every run starts with a fixed allowance of tokens, tool calls, wall-clock time, and dollars, and when any one runs out, the run stops cleanly and tells you why.&lt;/p&gt;




&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A logistics company runs an agent that matches carrier invoices to purchase orders. For each invoice it looks up the PO, compares line items, and either approves the match or flags it for a person. On a normal night it handles about 2,000 invoices for a few dollars.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; A carrier changed its invoice PDF layout. The extractor started reading the PO number with one digit missing. The lookup tool returned "not found," and the agent did what its prompt told it to: "If the PO isn't found, try alternate formats and search again." It tried with dashes, without dashes, with leading zeros, with a fuzzy search, then started over with a bigger context window "to be thorough." Each invoice turned into 40 or more tool calls and a growing prompt. By morning, a few hundred invoices had used most of the monthly API budget, the PO system had rate-limited the whole company, and not one of those invoices had been flagged for a person.&lt;/p&gt;

&lt;p&gt;Every single step looked reasonable. The total was the bug.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Run Budget).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Budget per run, set before it starts.&lt;/strong&gt; Each invoice gets at most 8 tool calls, 30k tokens, 90 seconds, and $0.10.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Count in the orchestrator, not the prompt.&lt;/strong&gt; The model doesn't get to decide whether it's over budget. Plain code counts and enforces.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Stop with a report, not a crash.&lt;/strong&gt; When a limit hits, the run ends in a named state, "budget_exhausted," with what it tried and where it got stuck.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Exhausted runs go to a person.&lt;/strong&gt; The invoice lands in the review queue with the attempts attached, which is the outcome it should have had after the second failed lookup.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A ceiling for the whole fleet.&lt;/strong&gt; A nightly cap pauses the job and pages someone if total spend crosses 3x the normal night.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same model, same prompt. The next layout change cost $11 and produced 140 flagged invoices with clear notes instead of a surprise bill.&lt;/p&gt;




&lt;h2&gt;
  
  
  Why "it'll stop when it's done" isn't a plan
&lt;/h2&gt;

&lt;p&gt;Agents are built to keep going. Retry instructions, self-reflection, and "try another approach" are exactly what make them useful on hard tasks, and exactly what turns a bad input into an endless one. Bad inputs are guaranteed in production: a changed format, a down service, a tool that returns an empty result instead of an error.&lt;/p&gt;

&lt;p&gt;Rate limits on the provider side don't save you. They protect the provider, not your budget, and they kick in long after the money is spent. Per-month spending alerts arrive after the fact. You need a limit that's checked on every step of every run.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Run Budget (five layers)
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Four meters, every run
&lt;/h3&gt;

&lt;p&gt;Tool calls, tokens, wall-clock time, and dollars. Each one catches a different failure. Tool calls catch retry loops, tokens catch prompts that keep growing, time catches hung tools, and dollars catch everything the other three miss. Set them from real traces: take a normal run's usage and allow about 3x.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Enforced outside the model
&lt;/h3&gt;

&lt;p&gt;The orchestrator checks the meters before each step. The model can see how much budget is left, which helps it plan, but it can't raise its own limit. This is the same rule as the &lt;a href="https://sheikhwasim.com/insights/boundary-contract-tools-fail-boring/" rel="noopener noreferrer"&gt;Boundary Contract&lt;/a&gt;: the boring code owns the hard rules.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. A clean stop state
&lt;/h3&gt;

&lt;p&gt;"budget_exhausted" is a real outcome, like "approved" or "flagged." It carries the attempts, the last error, and which meter ran out. A run that stops this way is a useful signal, not an incident.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. A human path for every stop
&lt;/h3&gt;

&lt;p&gt;An exhausted run never just disappears. It goes to the same review queue as a low-confidence answer. If your system has no place for "I tried and couldn't," the agent will keep trying.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Fleet ceiling and alerts
&lt;/h3&gt;

&lt;p&gt;Per-run budgets stop one bad run. A fleet ceiling stops a thousand of them at once. Track spend per job per hour against a normal baseline, pause at a multiple of it, and alert a person. Stamp every run with the &lt;a href="https://sheikhwasim.com/insights/release-pin-one-version/" rel="noopener noreferrer"&gt;Release Pin&lt;/a&gt; so you can tell whether a spike came from a new prompt, a new model, or new data.&lt;/p&gt;




&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; Budgets live in &lt;strong&gt;Orchestration&lt;/strong&gt;, and their meters are recorded in &lt;strong&gt;Traces&lt;/strong&gt;.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cheap Twin.&lt;/strong&gt; Route to the bigger model only while there's budget left for it.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Golden Trace.&lt;/strong&gt; Add a golden run with a bad input and assert that it ends in "budget_exhausted," not in 40 retries.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; Add one check: no agent job ships without per-run limits and a fleet ceiling.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  A test you can run this week
&lt;/h2&gt;

&lt;p&gt;Pick one agent you run in production. Feed it an input that can't succeed, like an ID that doesn't exist or a tool stubbed to return empty results. Then watch three numbers: how many tool calls it makes, how long it runs, and what it costs.&lt;/p&gt;

&lt;p&gt;If the answer to any of them is "until something else stops it," you need a Run Budget before you need a better prompt.&lt;/p&gt;




&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;An agent that never gives up sounds like a feature until the bill arrives. Give every run four meters, enforce them in plain code, make "I ran out of budget" a normal outcome with a person on the other end, and put a ceiling over the whole fleet. The goal isn't a cheaper agent. It's an agent whose worst night you already know the price of.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Wasim Sheikh on Substack (practicalainotes.substack.com)&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>devops</category>
    </item>
    <item>
      <title>Handoff Note: Multi-Agent Systems Fail at the Seams</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Wed, 04 Nov 2026 16:19:05 +0000</pubDate>
      <link>https://dev.to/anciwasim/handoff-note-multi-agent-systems-fail-at-the-seams-22if</link>
      <guid>https://dev.to/anciwasim/handoff-note-multi-agent-systems-fail-at-the-seams-22if</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #12 — canonical: &lt;a href="https://sheikhwasim.com/insights/handoff-note-agents-fail-at-the-seams/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/handoff-note-agents-fail-at-the-seams/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Every agent in the pipeline passed its own evals. The claim still came out wrong.&lt;/p&gt;

&lt;p&gt;When you split work across agents (a planner, an extractor, a reviewer), you add something no single-agent eval covers: the handoff. Each agent does its part well, and the system still loses the one fact that mattered, because nobody owned the space between them.&lt;/p&gt;

&lt;p&gt;Most multi-agent bugs I review aren't model bugs. They're seam bugs. The fix is boring and it works: every agent passes a &lt;strong&gt;Handoff Note&lt;/strong&gt;, a small typed record of what it knows, what it was told not to do, what's still open, and where each fact came from. The next agent reads the note first, and the system checks the note at every seam.&lt;/p&gt;




&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A regional insurer's claims intake team runs three agents. An intake agent reads the customer's email and attachments. An extractor pulls policy number, loss date, amount, and coverage type into the claims system. A reviewer agent checks the result and either approves it for an adjuster or kicks it back. Each agent has its own eval set, and each one scores well.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; A customer wrote, "the water damage started before I renewed, but the agent on the phone said the old policy covers it." The intake agent caught it and summarized the case in a free-text paragraph. The extractor only took structured fields from the attachments, so it filed the claim under the new policy's dates. The reviewer re-read the attachments from scratch, saw consistent fields, and approved. The phone-call exception never reached the adjuster, and the claim was denied on a date technicality that took two weeks and an escalation to unwind.&lt;/p&gt;

&lt;p&gt;No agent was "wrong" on its own test. The fact died in a paragraph that the next agent never had to read.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Handoff Note).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Typed note, not prose.&lt;/strong&gt; Each agent writes four lists: facts, constraints, open questions, and sources.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Read the note before the raw input.&lt;/strong&gt; The extractor starts from the intake note, so "possible prior-policy coverage" arrives as an open question it has to resolve or carry forward.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open questions can't disappear.&lt;/strong&gt; A question is either answered with a source or passed on. The reviewer can't approve while one is still open.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Check the seam.&lt;/strong&gt; A cheap validator compares the note going in with the note coming out and flags any fact or question that vanished.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Log the notes with the trace.&lt;/strong&gt; When a claim goes wrong, you can see exactly which seam dropped what.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same agents, same models. The exception now shows up on the adjuster's screen as an open question with the customer's own words attached.&lt;/p&gt;




&lt;h2&gt;
  
  
  Why per-agent evals aren't enough
&lt;/h2&gt;

&lt;p&gt;Per-agent evals test each agent on its own input. In production, an agent's real input is the previous agent's output, and that output drifts as prompts, models, and upstream agents change. An extractor that's 98% accurate on clean attachments tells you nothing about whether it respects a caveat the intake agent raised.&lt;/p&gt;

&lt;p&gt;Free-text summaries make this worse. They read well to humans and pass vibe checks, but they let the next agent pick what it pays attention to. Anything without a slot is optional, and optional facts get dropped under pressure.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Handoff Note (five layers)
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Four slots, always
&lt;/h3&gt;

&lt;p&gt;Facts (with values), constraints ("don't file under the new policy until coverage is confirmed"), open questions, and sources (document, line, message ID). Keep it short. If a slot is empty, it says so on purpose.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Note first, raw input second
&lt;/h3&gt;

&lt;p&gt;The receiving agent's prompt starts with the note and treats it as the brief. It can still read the raw documents, but it has to reconcile anything that conflicts with the note instead of quietly overwriting it.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Questions are conserved
&lt;/h3&gt;

&lt;p&gt;An open question leaves a seam in one of two states: answered, with a source, or still open. "Gone" isn't a state. This one rule catches most dropped-exception bugs.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. A boring validator at every seam
&lt;/h3&gt;

&lt;p&gt;Not another LLM judge, just code. Diff the incoming and outgoing notes. Missing facts, missing questions, or new facts with no source fail the handoff and route to a human or a retry. This is the &lt;a href="https://sheikhwasim.com/insights/boundary-contract-tools-fail-boring/" rel="noopener noreferrer"&gt;Boundary Contract&lt;/a&gt; idea applied between agents instead of between an agent and a tool.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Notes live in the trace
&lt;/h3&gt;

&lt;p&gt;Store every note with the run, stamped with the &lt;a href="https://sheikhwasim.com/insights/release-pin-one-version/" rel="noopener noreferrer"&gt;Release Pin&lt;/a&gt;. When something goes wrong, you can replay the seams instead of guessing which agent "probably" missed it, and you can turn the bad run into a &lt;a href="https://sheikhwasim.com/insights/golden-trace-eval-anchor/" rel="noopener noreferrer"&gt;Golden Trace&lt;/a&gt; for the whole pipeline.&lt;/p&gt;




&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; The note is the contract between &lt;strong&gt;Orchestration&lt;/strong&gt; and each agent's &lt;strong&gt;Memory&lt;/strong&gt;, and it's recorded in &lt;strong&gt;Traces&lt;/strong&gt;.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Golden Trace.&lt;/strong&gt; Add pipeline-level golden runs that assert which facts and questions survive end to end.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Shadow Path.&lt;/strong&gt; When you swap one agent in the chain, shadow it and compare its outgoing notes, not just its final labels.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; Add one check: no seam in the pipeline accepts free-text-only handoffs.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  A test you can run this week
&lt;/h2&gt;

&lt;p&gt;Take ten recent runs of any multi-agent flow. For each one, list every caveat, exception, or "but" in the original input. Then check whether each one is visible in the final output or explicitly resolved somewhere along the way.&lt;/p&gt;

&lt;p&gt;If even one disappeared without a trace, you have a seam bug. Add the four-slot note at that seam before you touch a prompt or a model.&lt;/p&gt;




&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;Agents don't usually fail alone. They fail at the handoff, where a fact one agent knew never became something the next agent had to deal with. Give every seam a typed note, conserve open questions, check the diff with plain code, and keep the notes in the trace. Make the handoff the part you can audit.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Wasim Sheikh on Substack (practicalainotes.substack.com)&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>llm</category>
    </item>
    <item>
      <title>I Had a Perfect Sprint Board. 18 AI Subagents Still Wrecked the Repo.</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Mon, 02 Nov 2026 16:20:52 +0000</pubDate>
      <link>https://dev.to/anciwasim/i-had-a-perfect-sprint-board-18-ai-subagents-still-wrecked-the-repo-59e7</link>
      <guid>https://dev.to/anciwasim/i-had-a-perfect-sprint-board-18-ai-subagents-still-wrecked-the-repo-59e7</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #13. Canonical: &lt;a href="https://sheikhwasim.com/insights/perfect-sprint-board-ai-subagents/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/perfect-sprint-board-ai-subagents/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;I lost most of two days this week, and I did it with a plan.&lt;/p&gt;

&lt;p&gt;This wasn't a vibe-coding accident. I sat down and wrote a proper sprint plan for a multi-tenant SaaS product. I broke it into tickets in a GitHub Project with clean columns: &lt;strong&gt;Todo, In Progress, Ready for QA, Done.&lt;/strong&gt; Every task had a clear description.&lt;/p&gt;

&lt;p&gt;Then I asked Claude to run it like a team. Create the subagents. Each one pulls the next ticket from the board, in order, does the work and moves it to Ready for QA. A QA agent verifies it and marks it Done.&lt;/p&gt;

&lt;p&gt;It looked like the perfect setup. It went very wrong.&lt;/p&gt;

&lt;h2&gt;
  
  
  What actually happened
&lt;/h2&gt;

&lt;p&gt;The instruction was "pull tickets in order." What I got was 18 subagents starting on the story at the same time.&lt;/p&gt;

&lt;p&gt;Each one created its own branch. Each one started from the same snapshot of the repo. None of them knew what the other 17 were doing.&lt;/p&gt;

&lt;p&gt;A lot of the tickets looked separate on the board but shared code underneath. A brand refresh that moved the login page from a dark navy gradient to a clean, light design. Authentication bug fixes. A rebuild of the navigation shell. Different cards. Same files.&lt;/p&gt;

&lt;p&gt;So every time one agent finished a shared piece of work and committed, the next agent's commit put the previous version back. The brand agent shipped the new login page. The auth agent, working from its older copy, overwrote half of it. The nav agent hit a merge conflict and settled it the easy way: keep its own version. That deleted the logo work entirely. Then the brand agent, still running, looked at the login page, decided it was "wrong," and restored the old navy gradient. The exact thing its ticket said to remove.&lt;/p&gt;

&lt;p&gt;That pattern repeated across the board. Finish, commit, get reverted by the next agent to land. Tests passed on one branch and failed on another, because they were testing different versions of the same logic. QA was being asked to verify work that kept changing under it.&lt;/p&gt;

&lt;p&gt;Meanwhile the board kept moving. Cards slid from In Progress to Ready for QA like everything was fine.&lt;/p&gt;

&lt;p&gt;When I finally stopped everything and read the git log, I had a pile of branches with conflicting changes, agents still running and still billing, and a codebase in worse shape than when I started. Then came the part nobody puts in the demo: sitting down and merging it all back together by hand.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the agents never understood
&lt;/h2&gt;

&lt;p&gt;Two things, mostly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Merge, don't replace.&lt;/strong&gt; When an agent found a file that didn't match its picture of the code, it treated the difference as a mistake to fix, not as someone else's finished work to keep. It never asked "who changed this, and why?" It just put its version back.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Leave a footprint.&lt;/strong&gt; No agent left anything behind for the next one to pick up. No note saying "I changed the login layout, here's why, build on top of this." Every agent showed up with no history and no handoff, so it had no way to know that the thing it was about to undo was already done.&lt;/p&gt;

&lt;p&gt;And the sequence I asked for never happened. "Pull tickets in order" turned into everything at once.&lt;/p&gt;

&lt;h2&gt;
  
  
  The board wasn't the problem. It just wasn't enough.
&lt;/h2&gt;

&lt;p&gt;A GitHub Project tracks &lt;strong&gt;status&lt;/strong&gt;. It tells you which ticket is where. It says nothing about which &lt;strong&gt;files&lt;/strong&gt; each agent is allowed to touch, what the code looks like right now, or who changed what last.&lt;/p&gt;

&lt;p&gt;That's the gap the whole thing fell into:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Tickets were split by feature. Code isn't.&lt;/strong&gt; Separate cards all landed in the same files. The board had no idea.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;"In order" wasn't enforced.&lt;/strong&gt; Agents pulling their own tickets is fine. Eighteen of them pulling at once is not a queue.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One branch per agent, no merge discipline.&lt;/strong&gt; Every branch was a private copy of the truth, and the last one in won.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No handoff.&lt;/strong&gt; Nothing carried context from one agent to the next.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;QA verified a moving target.&lt;/strong&gt; Checking a branch means nothing if the next merge undoes it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;"Done" meant the card moved,&lt;/strong&gt; not that the work was still in main.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I'd built the process for a human team, where people talk in standup and say "hey, I'm in that file." Subagents don't do that unless you make them.&lt;/p&gt;

&lt;h2&gt;
  
  
  What fixed it
&lt;/h2&gt;

&lt;p&gt;The immediate fix was boring: &lt;strong&gt;go serial.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Same board, same columns. But only one ticket moves at a time. One agent pulls it, works from the latest main, does the work and runs the tests. QA verifies it against main. Only when QA passes and the work is merged does the next ticket open.&lt;/p&gt;

&lt;p&gt;On paper it's slower. In practice it was much faster, because nothing got undone.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to manage subagents so this doesn't happen
&lt;/h2&gt;

&lt;p&gt;Going serial stopped the bleeding. Beyond that, these are the rules I think every multi-agent setup needs:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Enforce the queue.&lt;/strong&gt; If tickets should go in order, something has to lock the next ticket until the current one is merged. An instruction alone isn't enough.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan by files, not just features.&lt;/strong&gt; Map which files each ticket touches. If two tickets share files, they never run at the same time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One writer per area.&lt;/strong&gt; Only one agent writes to a given file, module or table at a time. Others can read.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Start from main and pull fresh before every commit.&lt;/strong&gt; Never from a stale snapshot.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Merge, never overwrite.&lt;/strong&gt; An agent that finds unexpected changes stops and asks, or merges them. It doesn't restore its own version.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Leave a footprint.&lt;/strong&gt; Every agent writes a short handoff on the ticket: what changed, which files, and what the next agent should build on.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;QA checks main, and Done means merged.&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Stop idle agents.&lt;/strong&gt; When an agent finishes or stalls, shut it down. Running agents cost money even when they're doing nothing useful.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Parallel only for read-only work.&lt;/strong&gt; Research, reading docs and analyzing data can fan out. Writing code to shared files can't.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  The lesson
&lt;/h2&gt;

&lt;p&gt;A perfect sprint board doesn't make agents a team. It makes them a list.&lt;/p&gt;

&lt;p&gt;Parallel agents are great when the work is truly independent. The moment they write to the same files, the same database or the same API, parallelism stops saving time and starts costing it, and you pay twice to fix the same bug.&lt;/p&gt;

&lt;p&gt;More agents doesn't mean more done. A clear lane for each agent, a real queue, and a handoff the next one can pick up does.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>github</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Shadow Path: Prove a New AI Agent Before It Writes Anything</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Wed, 28 Oct 2026 15:33:26 +0000</pubDate>
      <link>https://dev.to/anciwasim/shadow-path-prove-a-new-ai-agent-before-it-writes-anything-1ck</link>
      <guid>https://dev.to/anciwasim/shadow-path-prove-a-new-ai-agent-before-it-writes-anything-1ck</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #11 — canonical: &lt;a href="https://sheikhwasim.com/insights/shadow-path-prove-before-it-writes/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/shadow-path-prove-before-it-writes/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Your new agent passed every offline check. Then you gave it the write path, and live traffic taught you what the eval set never saw.&lt;/p&gt;

&lt;p&gt;Smoke Evals and Golden Traces are necessary. They are not a substitute for watching the candidate disagree with the live path on real requests before anything mutates.&lt;/p&gt;

&lt;p&gt;Most teams flip traffic because the scorecard looked green. Production agents need a quieter step first: run the new version beside the old one, block every write, and promote only when the disagreement that matters is small enough to live with.&lt;/p&gt;

&lt;p&gt;I call that a &lt;strong&gt;Shadow Path&lt;/strong&gt;: same live inputs, no side effects, a scored compare against what actually happened, and a promote gate stamped with the &lt;a href="https://sheikhwasim.com/insights/release-pin-one-version/" rel="noopener noreferrer"&gt;Release Pin&lt;/a&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A mid-size SaaS support team's intake desk runs an agent that routes tickets: refund, billing, bug, or VIP escalate. The current setup is a rules-plus-LLM hybrid. It is imperfect, but finance gets refund tickets and VIP issues leave the queue fast. The team builds a replacement agent. Offline &lt;a href="https://sheikhwasim.com/insights/smoke-evals-before-you-ship/" rel="noopener noreferrer"&gt;Smoke Evals&lt;/a&gt; and &lt;a href="https://sheikhwasim.com/insights/golden-trace-eval-anchor/" rel="noopener noreferrer"&gt;Golden Traces&lt;/a&gt; look strong.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; They flipped 100% of traffic overnight. Within a week, refund tickets that used to go to finance started landing in general support. VIP escalations sat longer because the new agent asked one more clarifying question before escalating. Those patterns were not in the offline set — and "helpful" burned SLA and money lanes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Shadow Path).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Same inputs, no writes.&lt;/strong&gt; The candidate sees live tickets. Mutating tools are stubbed or recorded as proposals only.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Score disagreement, not just accuracy.&lt;/strong&gt; Compare the proposed label or tool call to what the live path did. Track rate and severity: harmless vs money, access, or SLA-critical.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Promote by lane.&lt;/strong&gt; Shadow-only first, then canary writes on low-risk classes, then full cutover. Never big-bang because evals passed.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Stamp every shadow run with the Release Pin.&lt;/strong&gt; You always know which manifest disagreed.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Close the shadow window with a receipt.&lt;/strong&gt; Proposed N, agreed M, disagreed K by severity, and a decision: hold, canary, or promote.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same traffic. Same team. The difference was that the disagreement showed up before any write path changed.&lt;/p&gt;




&lt;h2&gt;
  
  
  Why "evals passed" isn't enough
&lt;/h2&gt;

&lt;p&gt;Offline cases are frozen. Live traffic moves. New phrasings, seasonal refund spikes, and VIP patterns that never made the golden set all show up after you ship.&lt;/p&gt;

&lt;p&gt;Accuracy against a fixed set also hides the wrong kind of error. An agent can look "right" on a rubric and still route money to the wrong queue, or delay an escalation by one polite question. You need a disagreement score against the path already carrying production risk — and a rule that writes stay off until that score is acceptable.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Shadow Path (five layers)
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Same inputs, no writes
&lt;/h3&gt;

&lt;p&gt;Feed the candidate the same live requests the production agent sees. Stub every mutating tool, or record the would-be call as a proposal. Traces still run. Receipts still exist — for &lt;em&gt;proposed&lt;/em&gt; actions, not executed ones. The shadow agent can think and plan. It cannot change the world.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Score disagreement, not just accuracy
&lt;/h3&gt;

&lt;p&gt;For each request, compare the shadow's proposed action, label, or tool call to what the live agent (or human) actually did. Bucket severity: cosmetic vs money, access, or SLA-critical. A 4% overall disagreement rate with a spike on refunds is not "almost fine." It is a hold.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Promote by lane
&lt;/h3&gt;

&lt;p&gt;Start shadow-only. When disagreement on low-risk classes is quiet, open canary writes on those classes only. Keep money and VIP lanes in shadow longer. Full cutover is the last move, not the first.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Stamp every shadow run with the Release Pin
&lt;/h3&gt;

&lt;p&gt;Every shadow trace carries the candidate manifest: model snapshot, prompt hash, tools, eval set. When refund disagreement jumps, you know which release caused it. Hold or promote is a decision about a version, not a vibe.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Close the shadow window with a receipt
&lt;/h3&gt;

&lt;p&gt;End with a short receipt: proposed N, agreed M, disagreed K by severity, and the decision — hold, canary, or promote. If the counts don't support the decision, the window isn't closed. Treat the promote call like a &lt;a href="https://sheikhwasim.com/insights/receipt-gate-no-second-write/" rel="noopener noreferrer"&gt;Receipt Gate&lt;/a&gt;: one write into the release record, not a Slack shrug.&lt;/p&gt;




&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Release Pin.&lt;/strong&gt; Shadow runs a candidate manifest beside the live pin. Promote means pointing production at that manifest.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Golden Trace.&lt;/strong&gt; Offline anchors stay. Shadow adds a live disagreement layer those frozen paths can't see.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Smoke Evals.&lt;/strong&gt; Still the pre-deploy bar. Shadow is the post-deploy-but-pre-write bar.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Receipt Gate.&lt;/strong&gt; Proposed actions get proposal receipts; promote gets a release receipt.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; Add one check: shadow window closed with an acceptable disagreement receipt before the write path opens.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; Shadow sits across &lt;strong&gt;Tools&lt;/strong&gt; (writes stubbed) and &lt;strong&gt;Traces&lt;/strong&gt; (proposals and compares logged).&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  A test you can run this week
&lt;/h2&gt;

&lt;p&gt;Pick one agent write path. For 48 hours, log what a candidate agent &lt;em&gt;would&lt;/em&gt; have done on the last N live requests without executing. Count disagreements on money, access, or SLA-critical actions.&lt;/p&gt;

&lt;p&gt;If that count isn't near zero — or each case isn't explained and accepted — do not flip traffic. Fix the candidate, widen the golden set, or keep the lane in shadow.&lt;/p&gt;




&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;Evals tell you the agent can pass the cases you already know. A Shadow Path tells you how it disagrees with production before it can hurt production. Same inputs, no writes, score the gap, promote by lane, stamp the pin, close with a receipt. Prove it before it writes.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Wasim Sheikh on Substack (practicalainotes.substack.com)&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>devops</category>
      <category>testing</category>
    </item>
    <item>
      <title>Undo Ledger: Every Agent Step Ships With Its Reverse</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Tue, 13 Oct 2026 18:56:47 +0000</pubDate>
      <link>https://dev.to/anciwasim/undo-ledger-every-agent-step-ships-with-its-reverse-1dh1</link>
      <guid>https://dev.to/anciwasim/undo-ledger-every-agent-step-ships-with-its-reverse-1dh1</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #10 — canonical: &lt;a href="https://sheikhwasim.com/insights/undo-ledger-every-step-has-a-reverse/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/undo-ledger-every-step-has-a-reverse/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Stopping an agent is easy. Stopping it cleanly is the hard part.&lt;/p&gt;

&lt;p&gt;A multi-step agent doesn't fail in one place. It fails after step three of six, with three real changes already made in three real systems. Hitting "cancel" stops step four. It doesn't take back steps one through three.&lt;/p&gt;

&lt;p&gt;Most agent stacks treat cancel like closing a browser tab. In production, it should work like a database rollback: every change that went out comes back, in reverse order, and you can prove it did.&lt;/p&gt;

&lt;p&gt;I call the fix an &lt;strong&gt;Undo Ledger&lt;/strong&gt;: every step the agent takes is written down together with the step that reverses it, before it runs. Cancel, failure, or a human "no" all mean the same thing: walk the ledger backward.&lt;/p&gt;

&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A mid-size company's IT team runs an onboarding agent. When HR marks a hire as confirmed, the agent creates the identity account, assigns software licenses, orders a laptop, adds the person to team channels and groups, and creates the payroll profile. It cut onboarding from days of tickets to about an hour of review.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; An offer was rescinded the same afternoon the agent started. HR cancelled the run while it was on step four. The agent stopped, as designed. But the identity account was already active, two paid licenses were assigned, and a laptop order had gone to the vendor. Nobody knew exactly which steps had finished. IT found the live account eleven days later during an access review. The licenses had been billed for the month, and the laptop showed up at the front desk.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Undo Ledger).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;No step without a reverse.&lt;/strong&gt; Each tool the agent can call declares its undo: create account pairs with disable account, assign license with release license, place order with cancel order.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write the entry first.&lt;/strong&gt; Before a step runs, the ledger records what's about to happen and how to undo it. After it runs, it records the result and the IDs it created.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cancel walks backward.&lt;/strong&gt; Cancel, a failed step, or a rejected approval triggers the undo for each completed step, newest first.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Undo gets checked too.&lt;/strong&gt; Each reverse step reports success or failure. Anything that can't be undone automatically (a shipped laptop) becomes a named task for a person, not a silent leftover.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The run closes with a receipt.&lt;/strong&gt; "Created 3, reversed 2, 1 handed to IT" is the last line of every cancelled run.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same agent. Same tools. The difference was that "cancelled" finally meant "back to where we started."&lt;/p&gt;

&lt;h2&gt;
  
  
  Why "just stop it" isn't enough
&lt;/h2&gt;

&lt;p&gt;Agents act through tools, and tools change real systems: accounts, money, orders, records. Those systems don't know the run was cancelled. They only know what they were told to do.&lt;/p&gt;

&lt;p&gt;So a stop button without a reverse path leaves half-done work. It looks fine in the agent's log and sits there in everyone else's systems. The longer the chain of steps, the bigger the mess a mid-run failure leaves.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Undo Ledger (five layers)
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Pair every action with its reverse
&lt;/h3&gt;

&lt;p&gt;When you register a tool, register its undo. If a step has no clean undo, say so up front and mark it as one that needs a human to confirm before it runs. That one decision changes which steps you let an agent take on its own.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Order steps so the risky ones go last
&lt;/h3&gt;

&lt;p&gt;Do the easy-to-reverse steps first (draft, reserve, stage) and the hard-to-reverse ones last (send, pay, ship). If the run dies early, there's less to unwind. Ordering is the cheapest undo you'll ever build.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Write before you act
&lt;/h3&gt;

&lt;p&gt;The ledger entry exists before the tool call. If the process crashes mid-step, you still know what was in flight. Pair this with a &lt;a href="https://sheikhwasim.com/insights/receipt-gate-no-second-write/" rel="noopener noreferrer"&gt;Receipt Gate&lt;/a&gt; so a retried undo never reverses something twice.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Make undo results boring
&lt;/h3&gt;

&lt;p&gt;Undo steps return the same plain outcomes as any tool under a &lt;a href="https://sheikhwasim.com/insights/boundary-contract-tools-fail-boring/" rel="noopener noreferrer"&gt;Boundary Contract&lt;/a&gt;: reversed, already reversed, or can't reverse plus a reason. "Can't reverse" goes to a named person with the IDs attached.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Close every run with a receipt
&lt;/h3&gt;

&lt;p&gt;Every run ends with a count of what it created, what it reversed, and what it handed off. If the counts don't line up, the run isn't closed.&lt;/p&gt;

&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; The ledger sits in the &lt;strong&gt;Tools&lt;/strong&gt; layer and writes into &lt;strong&gt;Traces&lt;/strong&gt;, so every reverse step is visible next to the step it undid.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Permission Envelope.&lt;/strong&gt; When consent expires or a human says no, the envelope closes and the ledger unwinds what ran under it.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Receipt Gate.&lt;/strong&gt; Receipts stop duplicate writes. The ledger stops orphaned ones.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Release Pin.&lt;/strong&gt; The tool versions in the manifest include their undo, so changing a reverse step is a release.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; Add one check before deploy: cancel a run halfway in staging and confirm the ledger puts everything back.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The test
&lt;/h2&gt;

&lt;p&gt;Pick your longest-running agent and ask:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;If you cancelled it right after its third step, could you list every change it made and reverse all of them without opening a single admin console by hand?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Then do it in staging. Start a run, cancel it mid-way, and check each system it touched. Anything still sitting there is a step without a reverse.&lt;/p&gt;

&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;Agents will fail mid-run. Offers get rescinded, approvals get denied, APIs time out. That's normal. What isn't acceptable is not knowing what got left behind. Write the reverse before you write the action, and cancel stops being the scariest button in your product.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Practical AI Notes&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>devops</category>
      <category>sre</category>
    </item>
    <item>
      <title>Release Pin: Ship the Model, Prompt, and Tools as One Version</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Sat, 10 Oct 2026 01:53:54 +0000</pubDate>
      <link>https://dev.to/anciwasim/release-pin-ship-the-model-prompt-and-tools-as-one-version-4beh</link>
      <guid>https://dev.to/anciwasim/release-pin-ship-the-model-prompt-and-tools-as-one-version-4beh</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #9 — canonical: &lt;a href="https://sheikhwasim.com/insights/release-pin-one-version/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/release-pin-one-version/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Your agent passed every check on Tuesday. On Thursday it was a different agent, and nobody shipped anything.&lt;/p&gt;

&lt;p&gt;The model alias you call quietly moved to a newer snapshot. Someone tightened a line of the prompt in a dashboard. A tool started returning one more field. Each change was small and reasonable. Together they changed what the agent does.&lt;/p&gt;

&lt;p&gt;Code teams solved this years ago: you don't deploy "whatever's on main right now." You deploy a version. Most agent stacks still don't.&lt;/p&gt;

&lt;p&gt;I call the fix a &lt;strong&gt;Release Pin&lt;/strong&gt;: the model snapshot, the prompt, the tool schemas, the retrieval index, and the eval set ship together as one versioned manifest. If any part changes, it's a new release, and it goes through the gate.&lt;/p&gt;

&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A general contractor's preconstruction team runs an agent that reviews subcontractor submittals against the project spec. It reads the spec section, reads the submittal, and flags anything that doesn't comply before a human reviewer signs off. It saved reviewers hours a week, and it had a clean eval record.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; Over one week, three things changed. The provider's "latest" model alias rolled forward to a new snapshot. A reviewer edited the prompt in the admin console to "make summaries shorter." And the document tool began splitting long spec sections into chunks. The agent started dropping the fine print, including the "or approved equal" conditions and the required test reports. Two non-compliant submittals were marked clean. A superintendent caught one on site. When the team tried to roll back, they couldn't say which prompt had been live, which model answered, or what "back" even meant.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Release Pin).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;One manifest per release.&lt;/strong&gt; Model snapshot ID (never a floating alias), prompt hash, tool schema versions, retrieval index version, and eval set version, all in one file with one release number.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No edits in production.&lt;/strong&gt; The admin console can propose a prompt change. It can't make one live. Changes land as a new manifest.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every change goes through the Ship Gate.&lt;/strong&gt; A new model snapshot is a release, same as new code. Smoke Evals and Golden Traces run against the full manifest.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every trace is stamped.&lt;/strong&gt; Each run logs the release number, so "which version flagged this submittal" is a lookup, not an argument.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Rollback is one move.&lt;/strong&gt; Point production at the previous manifest. Everything goes back together.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same model family. Same team. The difference was that "what's running" became a fact you can read.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why "we didn't change anything" isn't true
&lt;/h2&gt;

&lt;p&gt;Agent behavior is the product of everything around the model: the weights behind the alias, the prompt, the tools, the data it retrieves. If any one of those moves, the agent moves.&lt;/p&gt;

&lt;p&gt;Most teams version the code and float the rest. That's how you get a regression with no diff, an incident with no cause, and a rollback that rolls back the wrong thing.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Release Pin (five layers)
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Pin the model snapshot
&lt;/h3&gt;

&lt;p&gt;Call a dated snapshot, not "latest." Treat a provider upgrade as an incoming release you test on purpose, on your schedule, not something that happens to you overnight.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Version the prompt like code
&lt;/h3&gt;

&lt;p&gt;Prompts live in the repo, get reviewed, and carry a hash. A dashboard can stage a change, but only the release process makes it live. "Shorter summaries" is a behavior change, and it deserves a test.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Version tools and retrieval
&lt;/h3&gt;

&lt;p&gt;Tool schemas, the &lt;a href="https://sheikhwasim.com/insights/boundary-contract-tools-fail-boring/" rel="noopener noreferrer"&gt;Boundary Contract&lt;/a&gt; outcomes, and the retrieval index each carry a version in the manifest. A re-chunked index can change answers as much as a new model.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Gate the whole manifest
&lt;/h3&gt;

&lt;p&gt;Run &lt;a href="https://sheikhwasim.com/insights/smoke-evals-before-you-ship/" rel="noopener noreferrer"&gt;Smoke Evals&lt;/a&gt; and your &lt;a href="https://sheikhwasim.com/insights/golden-trace-eval-anchor/" rel="noopener noreferrer"&gt;Golden Traces&lt;/a&gt; against the manifest, not just the code. If the eval set itself changes, that's in the manifest too, so you know what "passed" meant.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Stamp, then roll back as a unit
&lt;/h3&gt;

&lt;p&gt;Every trace records the release number. Rollback means pointing production at the last good manifest, with all five parts moving together. If you can't roll back in one step, you don't have a release. You have a pile of settings.&lt;/p&gt;

&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; Release Pin wraps all five layers in one version, and &lt;strong&gt;Traces&lt;/strong&gt; carry the stamp.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; The gate checks a release. Release Pin defines what a release is.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Golden Trace.&lt;/strong&gt; A frozen trace is only useful if you know which manifest produced it.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cheap Twin.&lt;/strong&gt; The small model and the flagship are both pinned. Escalation routes between known versions, not moving targets.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Boundary Contract.&lt;/strong&gt; Tool outcome types are part of the tool's version. Changing them is a release.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The test
&lt;/h2&gt;

&lt;p&gt;Pick your most important agent and ask:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;If it did something wrong an hour ago, could you name the exact model snapshot, prompt, and tool versions that ran, and put all of them back in one step?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Then try it for real in staging. If the answer takes a Slack thread and three people's memory, it isn't pinned yet.&lt;/p&gt;

&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;Agents don't drift by themselves. They drift because the parts around them move without a release. Pin the parts, gate the release, stamp the trace, and "what changed?" finally has an answer.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Practical AI Notes&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>devops</category>
      <category>mlops</category>
    </item>
    <item>
      <title>Boundary Contract: Make Every Agent Tool Fail Boring</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Tue, 06 Oct 2026 22:12:34 +0000</pubDate>
      <link>https://dev.to/anciwasim/boundary-contract-make-every-agent-tool-fail-boring-15bm</link>
      <guid>https://dev.to/anciwasim/boundary-contract-make-every-agent-tool-fail-boring-15bm</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #8 — canonical: &lt;a href="https://sheikhwasim.com/insights/boundary-contract-tools-fail-boring/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/boundary-contract-tools-fail-boring/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Most agent failures I see in production don't start in the model. They start at the edge of a tool.&lt;/p&gt;

&lt;p&gt;A call times out. An API returns an empty list. A search gives back three results out of thirty. The model gets something shaped like data, so it does what models do: it writes a fluent, confident answer on top of it.&lt;/p&gt;

&lt;p&gt;The transcript reads fine. The customer gets the wrong answer. Nobody notices until a human asks why.&lt;/p&gt;

&lt;p&gt;I call the missing control a &lt;strong&gt;Boundary Contract&lt;/strong&gt;: every tool the agent can call returns a typed outcome, not just a payload. &lt;em&gt;Ok&lt;/em&gt;, &lt;em&gt;empty&lt;/em&gt;, &lt;em&gt;partial&lt;/em&gt;, &lt;em&gt;timeout&lt;/em&gt;, &lt;em&gt;rejected&lt;/em&gt;. The agent has to handle each one by name. It can't turn a broken call into the truth.&lt;/p&gt;

&lt;p&gt;Clever prose can wait. The boundary has to be boring first.&lt;/p&gt;

&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A field-service company shipped a scheduling agent. A customer asks for a repair visit. The agent checks the technician calendar, offers the next open slot, and books it. Staging looked sharp.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; On a busy Monday the calendar service started timing out under load. The tool wrapper caught the timeout and returned an empty list, because that's what the original developer thought "safe" meant. The agent read "no slots" and told customers the next opening was three weeks out. Some cancelled. Some called a competitor. The logs showed a successful tool call, a polite reply, and no error anywhere. The dashboard stayed green all morning.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Boundary Contract).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Typed outcomes on every tool.&lt;/strong&gt; The calendar tool now returns &lt;code&gt;ok&lt;/code&gt;, &lt;code&gt;empty&lt;/code&gt;, &lt;code&gt;partial&lt;/code&gt;, &lt;code&gt;timeout&lt;/code&gt;, or &lt;code&gt;rejected&lt;/code&gt;, plus the payload. "Empty" and "timed out" stopped looking the same.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Input checked before the call.&lt;/strong&gt; A bad zip code or a missing service type gets &lt;code&gt;rejected&lt;/code&gt; with a reason, before it reaches the calendar API and comes back as a mystery.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A named policy per outcome.&lt;/strong&gt; &lt;code&gt;timeout&lt;/code&gt; means retry once, then tell the customer "I can't see the calendar right now" and offer a callback. Never "no slots."
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Partial results are surfaced.&lt;/strong&gt; If one region's calendar answered and another didn't, the agent says so instead of quietly offering only what came back.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The outcome goes in the trace.&lt;/strong&gt; Every run logs which outcome each tool returned, so "how many timeouts did we hide this week" has a real answer.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same model. Same prompt. The difference was that a broken call could no longer pass as an answer.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why "it returned something" isn't enough
&lt;/h2&gt;

&lt;p&gt;A tool payload answers: &lt;em&gt;What came back?&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;A Boundary Contract answers: &lt;em&gt;What actually happened at the edge, and what is the agent allowed to say about it?&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Most stacks only fund the first question. They wrap errors into empty results to "keep the agent from crashing," and the model fills the gap with confidence. That isn't resilience. It's a lie with good grammar.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Boundary Contract (five layers)
&lt;/h2&gt;

&lt;p&gt;Build it into the tool layer, not into a line of the system prompt that says "be careful with errors."&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Input contract
&lt;/h3&gt;

&lt;p&gt;Each tool declares what valid input looks like: required fields, allowed values, sane ranges. Invalid input is rejected &lt;em&gt;before&lt;/em&gt; the call, with a reason the agent can repeat or fix. A tool that accepts anything will eventually do anything.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Outcome types, not just payloads
&lt;/h3&gt;

&lt;p&gt;Every response carries one of a small, fixed set of outcomes. Five is enough for most tools: &lt;code&gt;ok&lt;/code&gt;, &lt;code&gt;empty&lt;/code&gt;, &lt;code&gt;partial&lt;/code&gt;, &lt;code&gt;timeout&lt;/code&gt;, &lt;code&gt;rejected&lt;/code&gt;. The important part is that &lt;em&gt;empty&lt;/em&gt; and &lt;em&gt;failed&lt;/em&gt; are never the same value.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Time budget, named
&lt;/h3&gt;

&lt;p&gt;Each tool has an explicit timeout and retry rule written down next to it. When the budget runs out, the outcome says &lt;code&gt;timeout&lt;/code&gt;. It doesn't silently become &lt;code&gt;empty&lt;/code&gt;, and it doesn't hang until the whole run dies.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Outcome policy in the orchestrator
&lt;/h3&gt;

&lt;p&gt;For each outcome, decide what the agent may do and say. &lt;code&gt;partial&lt;/code&gt; means disclose the gap. &lt;code&gt;timeout&lt;/code&gt; means fall back or hand off to a human. &lt;code&gt;rejected&lt;/code&gt; means ask a clarifying question. Write these as rules the orchestrator enforces, so the model doesn't improvise them per ticket.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Outcome in the trace
&lt;/h3&gt;

&lt;p&gt;Log the outcome for every tool call, not only the payload. Freeze one happy path and one timeout path as &lt;a href="https://sheikhwasim.com/insights/golden-trace-eval-anchor/" rel="noopener noreferrer"&gt;Golden Traces&lt;/a&gt;, and add "timeout must never produce a confident answer" to your &lt;a href="https://sheikhwasim.com/insights/smoke-evals-before-you-ship/" rel="noopener noreferrer"&gt;Smoke Evals&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;5-layer agent stack.&lt;/strong&gt; Boundary Contract lives in &lt;strong&gt;Tools&lt;/strong&gt;, enforced by &lt;strong&gt;Guardrails&lt;/strong&gt;, recorded in &lt;strong&gt;Traces&lt;/strong&gt;.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Receipt Gate.&lt;/strong&gt; Receipt Gate checks a write landed before the next one fires. Boundary Contract makes sure the agent knows when a read &lt;em&gt;didn't&lt;/em&gt; land.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Permission Envelope.&lt;/strong&gt; The envelope decides whether a tool may run. The contract decides what its result means.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cheap Twin.&lt;/strong&gt; A &lt;code&gt;partial&lt;/code&gt; or &lt;code&gt;timeout&lt;/code&gt; outcome is a good escalate line on the checklist.
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship Gate.&lt;/strong&gt; Inject a timeout in canary and prove the agent says "I can't see that right now" instead of making something up.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The test
&lt;/h2&gt;

&lt;p&gt;Pick the tool your agent calls most. Then ask:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;If this tool timed out right now, would the agent tell the user something true, and would the trace show it was a timeout?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Run it for real: block the endpoint in staging and read the reply. If the agent still answers confidently, the boundary isn't a contract yet. It's a hope.&lt;/p&gt;

&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;Agents don't need to be clever at the edges. They need to be honest there. Every tool should fail in a way that's boring, typed, and visible, so the clever parts of the system are built on something true.&lt;/p&gt;

&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept, production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Practical AI Notes&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>devops</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Clean Exit, Wrong Record: Grade the Agent on the Database, Not the Last Line</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Sun, 04 Oct 2026 21:16:50 +0000</pubDate>
      <link>https://dev.to/anciwasim/clean-exit-wrong-record-grade-the-agent-on-the-database-not-the-last-line-2a4c</link>
      <guid>https://dev.to/anciwasim/clean-exit-wrong-record-grade-the-agent-on-the-database-not-the-last-line-2a4c</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of an Insights piece. Canonical: &lt;a href="https://sheikhwasim.com/insights/clean-exit-wrong-record/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/clean-exit-wrong-record/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;An agent can do the careful work, close the ticket, and still be wrong.&lt;/p&gt;

&lt;p&gt;On October 3, Microsoft and Hugging Face published ThinkingBox. It grades agents on the records they leave behind, not the sentences they generate. Their walkthrough is an ordinary support case: a delayed kitchen appliance, nine tool calls, the policy read correctly, the ticket closed as resolved, and a polite closer. The required end state was on hold. The customer never got a real answer. A grader watching tool calls would pass it. The database wouldn't.&lt;/p&gt;

&lt;p&gt;That's not a leaderboard story. It's the bug already sitting in production agents that treat a clean exit as proof of work.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://sheikhwasim.com/insights/receipt-gate-no-second-write/" rel="noopener noreferrer"&gt;Receipt Gate&lt;/a&gt; says the last write has to leave a skim-worthy receipt before the next one fires. ThinkingBox is the colder half of the same rule: the receipt has to match the record. The model's last line doesn't get a vote.&lt;/p&gt;

&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A support team shipped a delivery-exception agent. A stuck shipment comes in. The agent can read the order, check the carrier, open or update a ticket, and reply to the customer. The eval was a golden transcript: the right tools fired, the reply was polite, and the last line said the case was resolved. Staging looked done.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; Put that published retail task on their stack. Tools return success. The ticket lands in solved. The customer gets the closer. The carrier exception is still open, so the required end state is hold, not solved. Nothing in the eval looks at that field. The run is green because the trajectory is tidy. The record isn't.&lt;/p&gt;

&lt;p&gt;The ThinkingBox writeup is blunt about how often that tidy exit is a costume. In a common-set ablation (121,680 valid trials across 12 models), 79,853 attempts failed the executable checks. Of those failures, 67.24% still terminated cleanly, invoked a state-changing tool, and reported no final tool error. The checks still found wrong field values in 77.61% of them, unintended extra effects in 43.30%, and missing required effects in 25.36%. Those findings overlap. A green trace is not a passed state.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix.&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Name the end state in fields&lt;/strong&gt;: status, required effects, forbidden extras. Not "the reply sounds resolved."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Read the record back&lt;/strong&gt; after the last mutating tool, from the system of record, not from the model's summary.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Latch the customer-visible step&lt;/strong&gt; on that readback. No send until the fields match.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Receipt the diff&lt;/strong&gt;: what the record shows, what it was supposed to show, pass or fail in one skim.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Repeat the golden task&lt;/strong&gt; from a clean start until a one-off pass stops counting as a ship.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same tools. Same model. Different definition of done. To be fair, they haven't measured the lift from checking terminal state before you commit. You still have to run it on your own records.&lt;/p&gt;

&lt;h2&gt;
  
  
  A trajectory is a claim
&lt;/h2&gt;

&lt;p&gt;The line worth keeping: a trajectory is a claim. Database state is the evidence. Repetition is the trust test.&lt;/p&gt;

&lt;p&gt;Pass@1 says how a model usually does. "Solved at least once in 20 tries" says whether it can ever do the task. Neither answers "will it do this every time." On their 507 workflows, each run 20 times from a clean backend, Claude Opus 5.5 led the overall pass@1 they report, at 67.16%. It passed the same number of tasks on all 20 attempts as Claude Opus 5: 241. A small bump in the headline score bought no extra dependability. Kimi-K3 solved 476 of 507 tasks at least once and only 68 of them every time.&lt;/p&gt;

&lt;p&gt;If you're picking a model for work that touches real records off the "solved at least once" column, you're buying a demo.&lt;/p&gt;

&lt;p&gt;Where the failures sit matters for how you spend your week. They label roughly four in five as tool handling, not reasoning: tool usage at 79.9% in an unweighted average of per-model shares, not a unique cause and not a law. Agents usually get far enough to try the workflow, then fail to recover from tool errors, failed preconditions, or empty lookups. That's a retry policy and a smaller tool surface before it's a shopping trip for a newer model.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://sheikhwasim.com/insights/cheap-twin-escalate-when-needed/" rel="noopener noreferrer"&gt;Cheap Twin&lt;/a&gt; still applies: don't send every ticket to the flagship, and don't route on a single-pass score. In their list-rate estimate (not an invoice), the cheapest single success wasn't the cheapest task that passed every repeat.&lt;/p&gt;

&lt;h2&gt;
  
  
  Five lines before the next closer ships
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Required end state is a field diff, written down before the run&lt;/li&gt;
&lt;li&gt;Post-write readback from the system of record, not the assistant message&lt;/li&gt;
&lt;li&gt;Customer-visible send stays closed on mismatch&lt;/li&gt;
&lt;li&gt;Receipt names the fields that matched, the fields that didn't, and any extra writes&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://sheikhwasim.com/insights/ship-gate-pre-deploy-checklist/" rel="noopener noreferrer"&gt;Ship Gate&lt;/a&gt; uses a repeat count you can defend, and you say whether you mean best-of-k or every-of-k&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Twenty is their number, not a religion. A refund that moves money may need a stricter every-time bar than a draft note. Name k. Say which one you mean. Grade the sentence only when the requirement has no field.&lt;/p&gt;

&lt;h2&gt;
  
  
  How this sits with the rest of the stack
&lt;/h2&gt;

&lt;p&gt;Receipt Gate already refuses the next write when the last step left mush. This tightens the receipt: it has to agree with a readback. &lt;a href="https://sheikhwasim.com/insights/golden-trace-eval-anchor/" rel="noopener noreferrer"&gt;Golden Trace&lt;/a&gt; should freeze the end state, not only the happy transcript, otherwise a prompt bump that still "sounds resolved" sails right through. &lt;a href="https://sheikhwasim.com/insights/smoke-evals-before-you-ship/" rel="noopener noreferrer"&gt;Smoke evals&lt;/a&gt; need one trap where every tool returns ok and a required field is wrong.&lt;br&gt;
 &lt;a href="https://sheikhwasim.com/insights/permission-envelope-consent-that-expires/" rel="noopener noreferrer"&gt;Permission Envelope&lt;/a&gt; still wraps the irreversible send; a correct record doesn't grant a standing right to email the customer. Cheap Twin can pick the brain. It can't pick the definition of done.&lt;/p&gt;

&lt;h2&gt;
  
  
  The test
&lt;/h2&gt;

&lt;p&gt;Take one workflow that writes a record and then tells a human it's finished. Run it five times from the same starting state. After each run, ignore the last message. Read the fields you claimed were the goal.&lt;/p&gt;

&lt;p&gt;If any run says resolved while a required field is wrong, your eval is grading the claim.&lt;/p&gt;

&lt;p&gt;Curious how others handle this: do you read the record back before the agent talks to the customer, or are you still trusting the closer?&lt;/p&gt;




&lt;p&gt;I'm Wasim Sheikh, AI Architect. I build systems teams trust and organizations depend on: production, not demos.&lt;/p&gt;

&lt;p&gt;Full piece and the rest of the series: &lt;a href="https://sheikhwasim.com/insights/clean-exit-wrong-record/" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;LinkedIn&lt;/a&gt; · &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Practical AI Notes&lt;/a&gt; · &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;X @anciwasim&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;p&gt;Numbers and the retail walkthrough are from the October 3, 2026 joint post. I didn't re-run the benchmark. Cost remarks there are the authors' list-rate estimates (OpenRouter snapshot noted as September 20, 2026), not production invoices. They say they haven't measured the lift from terminal-state checks, a smaller tool surface, or human approval on this benchmark.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Microsoft and Hugging Face, "The Agent Said It Was Done. The Database Disagreed." Tuhin Kundu, October 3, 2026. &lt;a href="https://huggingface.co/blog/microsoft/thinkingbox" rel="noopener noreferrer"&gt;https://huggingface.co/blog/microsoft/thinkingbox&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Benchmark data repo cited in that post (release tag &lt;code&gt;thinkingbox-bench-v1.0&lt;/code&gt;): &lt;a href="https://github.com/microsoft/thinkingbox-data" rel="noopener noreferrer"&gt;https://github.com/microsoft/thinkingbox-data&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>testing</category>
      <category>devops</category>
    </item>
    <item>
      <title>Cheap Twin: Escalate Only When the Small Model Needs Help</title>
      <dc:creator>Wasim Sheikh</dc:creator>
      <pubDate>Sun, 04 Oct 2026 17:02:19 +0000</pubDate>
      <link>https://dev.to/anciwasim/cheap-twin-escalate-only-when-the-small-model-needs-help-1e9i</link>
      <guid>https://dev.to/anciwasim/cheap-twin-escalate-only-when-the-small-model-needs-help-1e9i</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Cross-post of Insights #7 — canonical: &lt;a href="https://sheikhwasim.com/insights/cheap-twin-escalate-when-needed/" rel="noopener noreferrer"&gt;https://sheikhwasim.com/insights/cheap-twin-escalate-when-needed/&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Most agent stacks send every request to the flagship model "just in case."&lt;/p&gt;

&lt;p&gt;That looks careful. It is usually waste — and it hides when the cheap path was already good enough. Latency climbs. The bill spikes. Nobody can answer: &lt;em&gt;which tickets actually needed the heavyweight brain?&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;I call the missing control a &lt;strong&gt;Cheap Twin&lt;/strong&gt;: run the same input through a small model first. Escalate to the expensive brain only when the twin disagrees with a short checklist, or fails a smoke assert. Everything else ships on the twin — with a receipt that names which model answered.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://sheikhwasim.com/insights/receipt-gate-no-second-write/" rel="noopener noreferrer"&gt;Receipt Gate&lt;/a&gt; makes each write legible. Cheap Twin makes each &lt;em&gt;brain choice&lt;/em&gt; legible — and defaults the happy path to the model you can afford to run all day.&lt;/p&gt;

&lt;h2&gt;
  
  
  Quick use case
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Situation.&lt;/strong&gt; A commercial construction ops team shipped an "RFI triage agent." It scored inbound requests for information: trade, urgency, and suggested owner. Leadership wanted accuracy, so every ticket went to the flagship model. Staging looked sharp.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What broke.&lt;/strong&gt; Volume hit production. Latency climbed into the awkward zone where PMs refreshed and re-submitted. The model bill jumped without a matching jump in "hard" tickets. Nobody could say which RFIs needed the heavyweight path. Logs showed tokens and a model name — not &lt;em&gt;why&lt;/em&gt; that model was chosen. There was no choice. There was a default.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The fix (Cheap Twin).&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Run the twin first&lt;/strong&gt; — small model proposes trade / urgency / owner on every RFI&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Gate escalate on a short checklist&lt;/strong&gt; — missing deadline, multi-trade conflict, owner-facing language, dollar threshold, unknown vendor&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fail closed on smoke asserts&lt;/strong&gt; — if the twin output fails a cheap structural check, escalate (or hold) instead of shipping mush&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escalate with the twin's draft&lt;/strong&gt; — flagship gets the same input &lt;em&gt;plus&lt;/em&gt; the twin proposal and which checklist line fired&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Receipt the brain&lt;/strong&gt;  every ticket logs twin vs flagship, checklist hits, and cost — skim-worthy, not a token dump&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Same tools. Same schema. Most traffic never left the twin. When it did, the receipt said why.&lt;/p&gt;

&lt;p&gt;Cheap Twins aren't about starving the agent of intelligence. They're about refusing the expensive path when you have no signal you need it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Flagship-by-default is a missing control
&lt;/h2&gt;

&lt;p&gt;A flagship call answers: &lt;em&gt;What would the best model say?&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;A Cheap Twin answers: &lt;em&gt;Did we need the best model for this ticket — and can we prove it?&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Those are different questions. Most stacks fund the first and call the bill "the cost of quality." Quality without a routing receipt is hope with a larger context window: you cannot tune the checklist, Golden-Trace the cheap path, or tell finance which spike was complexity vs lazy routing.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Cheap Twin stack (five layers)
&lt;/h2&gt;

&lt;p&gt;Build it like a control on the model path, not a discount coupon in the prompt.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Twin-first contract
&lt;/h3&gt;

&lt;p&gt;Every eligible request hits the small model before the flagship. The twin returns a structured proposal in the same schema the flagship would use — not a chatty essay the orchestrator reinterprets.&lt;/p&gt;

&lt;p&gt;If the twin cannot speak the production schema, it is not a twin. It is a different product.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Escalate checklist (five lines, not fifty)
&lt;/h3&gt;

&lt;p&gt;Name the concrete reasons the cheap path is not enough. Keep the list short enough to argue in standup:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Missing or ambiguous deadline&lt;/li&gt;
&lt;li&gt;Multi-trade / multi-system conflict&lt;/li&gt;
&lt;li&gt;Owner-facing or customer-facing language&lt;/li&gt;
&lt;li&gt;Dollar / risk threshold crossed&lt;/li&gt;
&lt;li&gt;Unknown vendor, SKU, or entity&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Vague scores ("confidence &amp;lt; 0.7") belong behind a named line — or they become a knob nobody trusts.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Smoke assert before ship
&lt;/h3&gt;

&lt;p&gt;Even on the twin path, run a cheap structural assert before anything leaves: required fields present, enums valid, no empty owner, no "see above" mush. Fail → escalate or hold. Do not ship a polite brick because the small model was fast.&lt;/p&gt;

&lt;p&gt;Pair with your &lt;a href="https://sheikhwasim.com/insights/smoke-evals-before-you-ship/" rel="noopener noreferrer"&gt;Smoke Evals&lt;/a&gt; pack so the same traps block CI and live routing.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Escalate with context, not from scratch
&lt;/h3&gt;

&lt;p&gt;When a checklist line fires, the flagship should see the twin's proposal and &lt;em&gt;which line&lt;/em&gt; triggered the escalate. That keeps the expensive call short and disagreement inspectable. Blind re-runs that ignore the twin waste the money you just decided to spend.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Brain receipt in the run record
&lt;/h3&gt;

&lt;p&gt;Every ticket leaves a skim-worthy receipt: twin model id, flagship model id (or "not called"), checklist hits, assert pass/fail, latency, and cost. Mushy "used GPT" fails the gate — same rule as &lt;a href="https://sheikhwasim.com/insights/receipt-gate-no-second-write/" rel="noopener noreferrer"&gt;Receipt Gate&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Freeze a twin-happy path and a forced-escalate path as &lt;a href="https://sheikhwasim.com/insights/golden-trace-eval-anchor/" rel="noopener noreferrer"&gt;Golden Traces&lt;/a&gt;. Prompt and model bumps must not silently flip the routing mix.&lt;/p&gt;

&lt;h2&gt;
  
  
  How this maps to what you already have
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://sheikhwasim.com/insights/agent-architecture-five-layer-stack/" rel="noopener noreferrer"&gt;5-layer agent stack&lt;/a&gt;&lt;/strong&gt; — Cheap Twin lives in &lt;strong&gt;Models&lt;/strong&gt; + &lt;strong&gt;Guardrails&lt;/strong&gt;; &lt;strong&gt;Traces&lt;/strong&gt; carry the brain receipt&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://sheikhwasim.com/insights/smoke-evals-before-you-ship/" rel="noopener noreferrer"&gt;Smoke evals&lt;/a&gt;&lt;/strong&gt; — "twin ships when checklist clear" and "checklist hit → escalate"&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://sheikhwasim.com/insights/golden-trace-eval-anchor/" rel="noopener noreferrer"&gt;Golden Trace&lt;/a&gt;&lt;/strong&gt; — freeze one twin-only success and one escalate success; regress both&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://sheikhwasim.com/insights/receipt-gate-no-second-write/" rel="noopener noreferrer"&gt;Receipt Gate&lt;/a&gt;&lt;/strong&gt; — model choice deserves a plain-language receipt before the next write&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://sheikhwasim.com/insights/permission-envelope-consent-that-expires/" rel="noopener noreferrer"&gt;Permission Envelope&lt;/a&gt;&lt;/strong&gt; — escalate widens &lt;em&gt;which brain&lt;/em&gt; may propose, not which tools&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://sheikhwasim.com/insights/ship-gate-pre-deploy-checklist/" rel="noopener noreferrer"&gt;Ship Gate&lt;/a&gt;&lt;/strong&gt; — prove routing + receipts in canary, not that the demo always hits flagship&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Architecture without a twin is just a flagship with a louder invoice.&lt;/p&gt;

&lt;h2&gt;
  
  
  The test
&lt;/h2&gt;

&lt;p&gt;Ask one question before the next "always use the best model" ship:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;For a normal ticket, does a small model propose first — and can a teammate skim a receipt that says whether you escalated, which checklist line fired, and what it cost?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If the answer is no, you are still buying flagship by default.&lt;/p&gt;

&lt;h2&gt;
  
  
  Closing
&lt;/h2&gt;

&lt;p&gt;I'm Wasim Sheikh — AI Architect. I build systems teams trust and organizations depend on: not demos, not proofs of concept — production.&lt;/p&gt;

&lt;p&gt;Follow for practical AI architecture that ships.&lt;br&gt;&lt;br&gt;
&lt;strong&gt;Connect on LinkedIn:&lt;/strong&gt; &lt;a href="https://www.linkedin.com/in/wasim-sheikh/" rel="noopener noreferrer"&gt;Wasim Sheikh&lt;/a&gt; · &lt;strong&gt;Site:&lt;/strong&gt; &lt;a href="https://sheikhwasim.com" rel="noopener noreferrer"&gt;sheikhwasim.com&lt;/a&gt; · &lt;strong&gt;Notes:&lt;/strong&gt; &lt;a href="https://practicalainotes.substack.com/" rel="noopener noreferrer"&gt;Practical AI Notes&lt;/a&gt; · &lt;strong&gt;X:&lt;/strong&gt; &lt;a href="https://x.com/anciwasim" rel="noopener noreferrer"&gt;@anciwasim&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>devops</category>
      <category>productivity</category>
    </item>
  </channel>
</rss>
