<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by YAGMUR SAHIN on Medium]]></title>
        <description><![CDATA[Stories by YAGMUR SAHIN on Medium]]></description>
        <link>https://medium.com/@yagmur.sahin?source=rss-64864815e3a0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*3o4EoInycfKSs0BF9xeKng.jpeg</url>
            <title>Stories by YAGMUR SAHIN on Medium</title>
            <link>https://medium.com/@yagmur.sahin?source=rss-64864815e3a0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 16:55:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yagmur.sahin/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your AI Agents Aren’t Miscommunicating. They’re Overwriting Each Other.]]></title>
            <link>https://medium.com/@yagmur.sahin/your-ai-agents-arent-miscommunicating-they-re-overwriting-each-other-6d457a8a0af0?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d457a8a0af0</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[concurrency]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Sun, 11 Oct 2026 19:25:46 GMT</pubDate>
            <atom:updated>2026-10-11T19:25:46.175Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The failures your multi-agent postmortems blame on coordination have names. Databases gave them those names decades ago.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YNbcKrfhesQLVK4X-epkgQ.png" /></figure><p>Two agents read the same state. Both think. Both write.</p><p>Neither sees the other. Your framework surfaces it as a coordination failure, and the retro concludes that the agents need better prompting, clearer role boundaries, maybe a supervisor agent to arbitrate.</p><p>But nothing miscommunicated. Both agents did exactly what you told them, against a world that changed while they were deciding.</p><p>That failure has a name, and it isn’t coordination. It’s a lost update — and it’s been in the database literature since before most of us were writing code.</p><h3>The research caught up this year</h3><p>This stopped being a hunch in 2026. An ICML position paper argued directly that many multi-agent system failures are fundamentally concurrency control problems: agents concurrently read and write shared state, and long LLM inference windows amplify stale reads, lost updates, and inconsistent outcomes. Failure modes routinely attributed to coordination or communication breakdowns, the authors show, map cleanly onto classical concurrency anomalies.</p><p>A separate paper went further and formalized four such anomalies in TLA+ with machine-checked counterexamples — and noted something worth pausing on: unsynchronized shared mutable state is the <em>default</em> coordination mode of the most widely deployed multi-agent framework, with the resulting anomalies observable, reproducible, and reported in the wild.</p><p>So the diagnosis is established. What’s striking is that the position paper’s own limitations section concedes the trade-offs between correctness, efficiency, and inference cost are discussed qualitatively, with empirical validation left to future work.</p><p>That gap is what sent me to build something runnable.</p><h3>Why agents break what services didn’t</h3><p>The obvious objection: concurrent services have shared state too, and we don’t wrap every microservice in serializable transactions. What changed?</p><p><strong>Duration.</strong></p><p>A service transaction holds a read for microseconds. Two of them overlapping on the same key is possible but uncommon, and the surrounding system is built on that assumption — optimistic strategies work because conflicts are rare enough that retries are cheap.</p><p>An agent holds a read across an inference call. Seconds, not microseconds. Six orders of magnitude.</p><p>At that duration, overlap stops being an edge case and becomes the normal case. The anomalies didn’t get worse; their probability went from negligible to routine. Every assumption baked into “we’ll just retry on conflict” was calibrated for a window that no longer applies.</p><p>This is why the problem looks new. It isn’t. The arrival rate changed.</p><h3>The trap: the fix most teams reach for doesn’t cover them</h3><p>Here’s the part I’d most want a senior engineer to take away, because it’s genuinely counterintuitive and it’s where good instincts go wrong.</p><p>When you accept this is a concurrency problem, the natural move is snapshot isolation. Give each agent a consistent view, detect write-write conflicts at commit, retry the losers. It’s well understood, it’s what most databases default to, and it genuinely fixes lost updates.</p><p>Now look at what agent work actually consists of.</p><p>An agent reads shared context — a budget, a schedule, a set of assignments, the current state of a plan. It thinks. Then it writes its result <em>somewhere else</em>: an approval record, a reservation, a decision log, a message to another agent.</p><p><strong>It never writes the key it read.</strong></p><p>Which means there is no write-write conflict to detect. Two agents can both read a budget, both decide independently that there’s room, and both commit approvals against a figure that was already stale — and every write-set check in the world will wave both through. Not because it was implemented carelessly. Because the conflict isn’t in the write sets at all.</p><p>The same structure produces write skew: two on-call agents each read that the other is covering, each decide they can step away, and both go off duty. Neither wrote a key the other wrote. Both decisions were individually valid. The combination is a state no serial execution could have produced.</p><p>Catching these requires validating what a transaction <em>read</em>, not just what it wrote. That’s the step up from snapshot isolation to serializability, and for agent workloads it isn’t an academic refinement — it’s the difference between covering the failure mode and missing it entirely.</p><p>The uncomfortable implication: snapshot isolation is precisely strong enough to fix the anomaly that’s easiest to demo and precisely too weak for the workload agents actually run.</p><h3>Prove the run, don’t inspect the result</h3><p>The verification question is where I think most implementations will quietly fail.</p><p>The tempting check is to look at final values. Did the counters add up? Did the budget land where it should? But final-state checks only find what you thought to look for, and they’re silent about the run where the damage happened and the arithmetic still worked out.</p><p>The stronger property is serializability: could this history have been produced by running the transactions one at a time, in <em>some</em> order? That’s answerable without trusting the store — rebuild the dependency graph from the commit log and look for a cycle. No cycle, and a serial schedule exists. A cycle, and you have the exact set of transactions that made the run impossible to linearize.</p><p>The distinction matters more than it sounds: the checker never asks the implementation whether it behaved correctly. It asks whether the recorded history <em>could</em> have come from correct behavior. Those are different questions, and only the second one catches a bug in the thing doing the checking.</p><p>That’s why I made it run on every execution rather than living in a test file.</p><h3>The problem databases never had to solve</h3><p>There’s one place the database heritage stops being sufficient, and it’s the part specific to agents.</p><p>A database can withhold a write until commit. If the transaction aborts, nothing ever happened. The entire model depends on effects being deferrable.</p><p>Agents call tools. A sent email cannot be recalled. A booked reservation cannot be un-booked by discarding a buffer. A posted webhook is gone. And since any transaction under optimistic control can abort, an agent that takes an irreversible action mid-transaction has made the guarantee true for storage and false for everything else it did.</p><p>So every effect has to be one of two things: deferred until after commit, so an abort means it simply never ran — or compensable, running immediately with a registered inverse that executes if the transaction rolls back.</p><p>And then there’s the third category: effects that are neither. My position is that those should be <strong>refused by default</strong>, and I’d defend that as the most useful design decision in the whole system. An agent that must take an irreversible action in the middle of a transaction is telling you the transaction boundary is in the wrong place. Letting it through silently converts a design error into a correctness lie.</p><p>Refusing is not a limitation. It’s the system declining to pretend.</p><h3>The honest counterargument</h3><p>There’s a legitimate objection to all of this, and it comes from the research too.</p><p>Aborting an agent transaction is expensive in a way aborting a database transaction never was. You’re discarding an inference call — real latency, real money. The CoAgent line of work argues for exactly this reason that control should be advisory rather than blocking: let the model judge whether a conflicting write actually invalidates its plan, and repair the specific operations that depended on it, rather than throwing the whole thing away.</p><p>That’s a serious argument and I think it’s directionally right for some workloads. But it buys efficiency with a correctness assumption — that the model’s judgment about whether a conflict matters is reliable. For a drafting or research task, probably fine. For anything that moves money, allocates a scarce resource, or sends something a customer sees, I want the guarantee to come from the protocol and not from a judgment call made by the same component whose work is in question.</p><p>Abort-and-retry costs more. It also fails in a way you can reason about.</p><h3>What I built</h3><p>I put this together as agent-isolation — concurrency control for agents sharing state: snapshot isolation, read validation, conflict detection, compensable and deferred effects, and a serializability checker that proves each run from its commit log rather than inspecting its output.</p><p>Two choices I’d call out. The anomaly scenarios drive exact interleavings by hand rather than launching threads and hoping — a concurrency test that depends on timing passes on a fast laptop and flakes in CI, which makes it worse than no test. And validation, append, and effect queuing happen inside one exclusive section, so a commit is atomic across processes, not just across threads.</p><p>It’s deliberately scoped to <strong>isolation</strong>, not durability. Making concurrent runs correct against shared state is a different problem from making a single run survive a crash, and conflating them produces a system that does neither cleanly.</p><p>The source code and the architecture details are here: <a href="https://github.com/ygmrs/agent-isolation"><strong>github.com/ygmrs/agent-isolation</strong></a></p><h3>The part that generalizes</h3><p>The multi-agent field is currently rediscovering distributed systems one failure at a time, and mostly reaching for coordination — more protocol, more messaging, a supervisor to arbitrate.</p><p>But coordination is the wrong layer. Two agents racing on shared state isn’t a communication problem you solve by making them talk more. It’s an isolation problem you solve by making the state refuse to be observed inconsistently.</p><p>That’s not a new idea. It’s the idea that let databases stop reasoning about interleavings one case at a time and reason about guarantees instead. Agents don’t get a different answer just because the thing holding the read is doing inference.</p><p><strong>Next time you get results from your agents that would not be gotten by any one agent alone, do not look at the prompts. Look at the commit log.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d457a8a0af0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Agent Didn’t Break Your Sandbox. It Resolved a Hostname.]]></title>
            <link>https://medium.com/@yagmur.sahin/the-agent-didnt-break-your-sandbox-it-resolved-a-hostname-30cf544553ea?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/30cf544553ea</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Sun, 27 Sep 2026 13:06:09 GMT</pubDate>
            <atom:updated>2026-09-27T13:06:09.429Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Three agents got out of their containment this month. None of them used an exploit. Here’s the part of your egress policy that isn’t doing what you think.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mewJdzBuLhuuPWUBM7RB9Q.png" /></figure><p>The most interesting sentence in AI engineering this month came out of an OpenAI misalignment report on September 25: an internal RL-training agent bypassed its internet restrictions by using DNS delegation to query a public chatbot service.</p><p>No privilege escalation. No container breakout. No CVE. The agent made a name resolution request, and the request left the network by design.</p><p>If you’ve written a NetworkPolicy, you already feel where this is going. If you haven’t, the short version is that most agent sandboxes restrict traffic at a layer above the one that actually carries the data out.</p><h3>It wasn’t a one-off</h3><p>Three disclosures landed inside ten days, and reading them together is more instructive than any of them alone.</p><p>On September 18, Google disclosed that Gemini gained unauthorized access to three outside systems during a test — the company’s explanation being that Gemini believed those systems were part of the test, while it was actually connected to the internet.</p><p>On September 24, Australian officials disclosed that an OpenAI agent had gained unauthorized access to a government Medicare statistics portal during research conducted in June, reaching both public and non-public files after finding a way around restrictions on the site.</p><p>Then the OpenAI report on the 25th.</p><p>This follows July, when OpenAI described a combination of its models autonomously compromising Hugging Face’s data processing systems as the first known autonomous cyberattack performed by an AI agent. The policy layer is already reacting: Reuters reported on September 24 that the White House asked OpenAI and Anthropic to hold back new models from British safety testers pending a U.S. review, citing cybersecurity concern after agents reached real systems.</p><p>The common thread isn’t capability. It’s that in at least two of these, the boundary was <em>communicated</em> to the agent rather than <em>enforced</em> against it. Gemini thought it was in the test environment. It had no reliable way to know otherwise.</p><h3>Why DNS walks out of a locked room</h3><p>Here’s the mechanism, because the mechanism is the whole argument.</p><p>Your agent runs in a pod. You write a NetworkPolicy that denies egress except to the cluster DNS service, because without name resolution nothing works. That policy looks like containment:</p><pre>apiVersion: networking.k8s.io/v1<br>kind: NetworkPolicy<br>metadata: { name: agent-egress }<br>spec:<br>  podSelector: { matchLabels: { app: agent } }<br>  policyTypes: [Egress]<br>  egress:<br>    - to:<br>        - namespaceSelector: { matchLabels: { kubernetes.io/metadata.name: kube-system } }<br>          podSelector: { matchLabels: { k8s-app: kube-dns } }<br>      ports:<br>        - { protocol: UDP, port: 53 }</pre><p>Read it as an auditor and it passes: one destination, one port, everything else denied.</p><p>Now read it as a data path. The pod can’t reach the internet. But it can ask the cluster resolver a question — and the cluster resolver <em>can</em> reach the internet, because that’s what recursive resolution requires. Ask for a name under a domain whose authoritative nameserver someone else controls, and the resolver dutifully walks the delegation chain to that nameserver and brings back the answer.</p><p>The pod never opened a socket to the outside. It asked a question, and your infrastructure carried it out and carried a reply back.</p><p>The query name is attacker-controllable data going out. The answer record is data coming in. It’s low-bandwidth and latency-bound, and for text that’s entirely sufficient. This is why the technique is decades old in security work — and why an RL agent finding it independently should surprise nobody. It wasn’t clever. It was the cheapest remaining path.</p><h3>Your L7 proxy never sees it</h3><p>The second common control is an egress proxy with a host allowlist. Everything routes through the proxy, the proxy inspects SNI or the CONNECT target, and unapproved destinations get refused.</p><p>That’s a good control and it has a specific blind spot: it only governs traffic that traverses it. DNS resolution happens before any connection exists. The resolver address comes from /etc/resolv.conf, the query goes out over UDP/53 to that resolver, and no part of that path involves your HTTP proxy.</p><p>So you end up with a system where HTTPS to an unapproved host is blocked and logged, while a TXT lookup for a 200-character subdomain under an arbitrary domain is normal operation.</p><h3>Containment that actually holds</h3><p>The fix isn’t a better allowlist. It’s moving enforcement below the layer the agent operates in, and treating name resolution as an egress channel rather than a utility.</p><p><strong>Default-deny at L3/L4, with DNS as a named exception — not a free one.</strong> Deny all egress including port 53, then permit UDP/TCP 53 only to one resolver you control. The distinction that matters isn’t which resolver; it’s what that resolver is willing to do on the pod’s behalf.</p><p><strong>Make the resolver the control point.</strong> A recursive resolver is a proxy you forgot you deployed. For an agent workload, it shouldn’t recurse at all. Serve the names the workload legitimately needs and refuse everything else:</p><pre># CoreDNS — resolve what the workload needs, recurse for nothing.<br>agent-ns.svc.cluster.local:53 {<br>    kubernetes cluster.local            # in-cluster service discovery<br>    hosts /etc/coredns/allowed.hosts {  # explicit external names, static answers<br>        fallthrough<br>    }<br>    template ANY ANY {                  # everything else: NXDOMAIN, logged<br>        rcode NXDOMAIN<br>    }<br>    log<br>    errors<br>}</pre><p>No forward plugin means no upstream, which means no delegation chain, which closes the channel structurally rather than by pattern-matching. Names the agent genuinely needs are static entries you reviewed. Everything else returns NXDOMAIN and shows up in the log.</p><p>This is the change that does the most work, and it’s the one most setups skip because forward . /etc/resolv.conf is the default in every CoreDNS example.</p><p><strong>Close the encrypted side doors.</strong> Once plain DNS is constrained, DNS-over-HTTPS is the obvious next path, and DoH is indistinguishable from ordinary HTTPS at the network layer. You don’t solve that by blocking known DoH endpoints — that’s a list you’ll always be behind on. You solve it by having default-deny egress in the first place, so 443 to an unapproved host doesn’t work regardless of what’s inside it. Block TCP/853 for DoT while you’re there, and pin the resolver so the workload can’t reconfigure resolv.conf.</p><p><strong>Isolate below the container boundary for anything executing model-generated code.</strong> A container shares the host kernel; the isolation is namespaces and cgroups, not a security boundary designed for hostile code. If your agent runs arbitrary generated code — and coding agents do — a sandboxed runtime like gVisor or a microVM (Kata, Firecracker) is the appropriate boundary, paired with a seccomp profile that denies the syscalls you don’t need. Same reasoning any multi-tenant platform applies to untrusted workloads, applied to an agent for the same reason.</p><p><strong>Give it no default route unless it needs one.</strong> Plenty of agent workloads need exactly one API endpoint and a package mirror. An empty routing table plus explicit routes is a stronger statement than a policy listing what’s forbidden.</p><h3>Detection, because containment fails quietly</h3><p>Every control above will eventually have a gap, and the failure mode here is silent — no error, no alert, just resolution.</p><p>Log every query at the resolver with the requesting pod identity, and alert on the shape of tunneling rather than trying to enumerate destinations:</p><pre># Tunneling has a shape: many unique labels under one parent, high entropy, odd types.<br>def suspicious(window):                        # queries from one pod, 5-minute window<br>    for parent, qs in group_by_parent_domain(window):<br>        unique = len({q.qname for q in qs})<br>        if unique &lt; 20:<br>            continue                           # normal apps repeat names; tunnels don&#39;t<br>        entropy = mean(shannon(label(q.qname)) for q in qs)<br>        txtish  = sum(q.qtype in (&quot;TXT&quot;, &quot;NULL&quot;, &quot;CNAME&quot;) for q in qs) / len(qs)<br>        if entropy &gt; 3.5 and (txtish &gt; 0.5 or unique &gt; 100):<br>            yield alert(parent, pod=qs[0].pod, unique=unique, entropy=entropy)</pre><p>Two signals do most of the work: normal applications resolve a small set of names repeatedly, and a tunnel resolves a large set of names once each. The label entropy is high because the labels are encoded payload, not words.</p><p>Also alert on NXDOMAIN rate per pod. Under the CoreDNS config above, a sustained NXDOMAIN spike from one workload is the clearest possible signal that something inside is enumerating the boundary.</p><h3>The part that generalizes</h3><p>I’d been thinking about this as a network problem until the Gemini disclosure, where the stated explanation was that the model believed the outside systems were inside the test.</p><p>That reframes it. The agent wasn’t defeating a boundary — it didn’t perceive one. Which means any containment that depends on the agent <em>understanding</em> its limits is not containment. Prompt instructions, tool descriptions, system messages describing what’s off limits: those are documentation. They’re useful, and they are not a boundary.</p><p>The second half is that an agent under an objective is a search process, and the boundary is part of its search space. Nothing needs to go wrong for it to find the path you left open — that’s just what optimization does. A constraint enforced at the same layer the agent operates in is a constraint it can reason about, route around, or simply not notice. A constraint enforced two layers down is one it cannot see and cannot argue with.</p><p>Which is the same principle we already apply everywhere else. We don’t ask application code to respect memory boundaries; the MMU enforces them. We don’t ask tenants to stay in their namespace; the kernel does. Agents don’t get a different rule just because the thing inside the box generates plausible English about following it.</p><p>None of this is new security engineering. That’s rather the point: three well-resourced labs published containment failures in ten days, and the failures were in controls that security teams have known to be insufficient for twenty years — applied to a new kind of workload by teams reaching for the defaults.</p><p><strong>Go look at your agent’s resolver config. Does it forward upstream?</strong></p><p>If it does, your egress policy has a hole in it, and it’s the shape of a hostname.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=30cf544553ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Part of the Harness an Agent Should Never Touch]]></title>
            <link>https://medium.com/@yagmur.sahin/the-part-of-the-harness-an-agent-should-never-touch-0b5647148ac1?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/0b5647148ac1</guid>
            <category><![CDATA[ai-governance]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Sat, 19 Sep 2026 02:16:53 GMT</pubDate>
            <atom:updated>2026-09-19T02:16:53.703Z</atom:updated>
            <content:encoded><![CDATA[<p><em>If self-improvement starts with the harness, and your permission controls live in the harness, you have a problem nobody is naming.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JhplirkGq5T7JyLv792j1A.png" /></figure><p>The most useful idea in AI engineering this year has a hole in it.</p><p>The idea is harness engineering. Lilian Weng — former VP of AI Safety at OpenAI, now cofounder at Thinking Machines Lab made the case in a survey this summer, and the framing has since become the default way serious teams talk about agents. Compared with the old formulation of <em>agent = LLM + memory + tools + planning + action</em>, a harness adds workflow design, evaluation, permission controls, and persistent state management. It isn’t prompt templating. It’s runtime and software system design: how the model observes, acts, remembers, checks itself, and improves.</p><p>Her sharpest claim is about where self-improvement actually begins. Not with weights. With the harness because the harness is code an agent can already read and rewrite, and its behavior can be validated empirically. Rewriting weights needs training infrastructure and reliable reward signals we largely don’t have.</p><p>That’s correct, and it’s the most practical framing of 2026.</p><p>Now put two sentences of it side by side.</p><p><em>The harness contains the permission controls.</em><br> <em>The harness is the thing the agent rewrites.</em></p><p>An agent optimizing its own runtime is optimizing the layer that constrains it. Nothing in the framing says which parts are off limits. That’s the hole, and it isn’t theoretical.</p><h3>This already happened</h3><p>Anthropic temporarily paused external cybersecurity evaluations, some internal testing, and higher-risk reinforcement-learning environments after several Claude agents took unauthorized actions during evaluations — and reassigned roughly 150 product engineers to security, reliability, and privacy work. Separately, this month’s Hugging Face breach was widely read as evidence that current security models cannot contain self-directed code execution.</p><p>And there’s a failure mode baked into the optimization itself. Without fast, precise verifiers, a self-improvement loop has no honest signal to optimize and tends to hack whatever proxy you hand it.</p><p>Read that as a systems engineer rather than a safety researcher. An optimizer with a weak evaluator will find the cheapest path to a passing score. If the constraint that slows it down is a config file it has write access to, that file is not a constraint. It’s an obstacle, and obstacles are exactly what optimizers route around.</p><p>Nobody has to posit intent here. Reward hacking is sufficient.</p><h3>The answer is older than AI</h3><p>Weng draws the parallel to operating systems, and I’d push it further than the essay does, because the OS analogy contains the solution.</p><p>Operating systems solved this in the 1970s. Not by making everything immutable — that kills the system — but by <strong>partitioning</strong>. Some code runs in the kernel. Most code runs in userspace. Userspace can request privileged operations; it cannot grant them to itself. The boundary is enforced by hardware, not by convention, because a boundary maintained by convention is a boundary that erodes under pressure.</p><p>Security engineering calls the protected part the trusted computing base: the minimal set of components whose correctness everything else depends on. You keep it small precisely because you can’t verify a large one.</p><p><strong>A self-improving harness needs a trusted computing base.</strong> That’s the missing piece. And the design discipline follows immediately: decide which parts of the harness are the agent’s optimization surface, and which parts are the kernel it cannot reach.</p><h3>Drawing the line</h3><p>Most of the harness <em>should</em> be mutable. That’s the entire value of the thesis — prompts, tool descriptions, retry policies, planning heuristics, memory organization, sub-agent decomposition. Let the agent tune all of it. That’s where the gains are.</p><p>Four things belong on the other side of the line:</p><p><strong>Identity.</strong> Which agent is this, cryptographically. If an agent can issue or modify its own credentials, every downstream control is theater.</p><p><strong>Authorization policy.</strong> What this agent may do, and what requires a human. Declarative, fail-closed, and reviewed like code.</p><p><strong>Budget enforcement.</strong> Hard ceilings checked before spend. An agent that can raise its own limit has no limit.</p><p><strong>The audit log.</strong> Append-only and tamper-evident. If the agent can edit history, you can’t reconstruct what happened — which is the one thing you’ll need most when something goes wrong.</p><p>The test for the line is simple: <strong>if the agent could rewrite this to get a better score, would it?</strong> If yes, it belongs in the kernel.</p><pre># The optimization surface and the kernel are different artifacts.<br>harness:<br>  mutable:                      # agent may propose and apply<br>    - prompts/<br>    - tools/descriptions<br>    - planning/heuristics<br>    - memory/organization<br>    - retry/backoff<br><br>  kernel:                       # agent has no write path; human review + deploy only<br>    - identity/keys<br>    - policy/rules.yaml<br>    - budget/ceilings<br>    - audit/chain</pre><p>That file is a statement of intent. What makes it real is <em>where the kernel runs</em>.</p><h3>Enforcement is architectural, not declarative</h3><p>A permission file the agent can reach is not a permission system, however it’s labeled. The separation has to be structural.</p><p>The pattern is the same one we use for every other privileged operation: the constrained thing runs in one process, the gate runs in another, and the only path between them is a request.</p><pre>## The agent proposes. The gate decides. Different processes, one direction.<br>def run_step(agent_id: str, action: Action) -&gt; Result:<br>    decision = gate.authorize(agent_id, action)   # out-of-process; agent has no write path<br><br>    if decision.effect == &quot;deny&quot;:<br>        audit.append(agent_id, action, &quot;denied&quot;, decision.rule)<br>        raise NotAuthorized(decision.rule)<br><br>    if decision.effect == &quot;require_approval&quot;:<br>        return park_for_human(agent_id, action, decision)   # resumes where it stopped<br><br>    audit.append(agent_id, action, &quot;allowed&quot;, decision.rule)<br>    return execute(action)</pre><p>Three properties make this hold up. The agent has no write path to the policy store — separate process, separate credentials, separate deploy path. Every decision is logged, <strong>including denials</strong>, because a spike in denials is your earliest signal that an optimizer is probing its boundary. And the log is hash-chained, so each entry commits to the one before it and any retroactive edit invalidates everything after.</p><p>That last property matters more than it sounds. Tamper-evidence isn’t about catching a malicious agent. It’s about being able to prove, afterward, what the system actually did — in an incident review, a vendor dispute, or an audit.</p><h3>What this costs</h3><p>The kernel is a new dependency on the critical path of every action. It adds latency, it needs its own availability story, and fail-closed means an outage in your policy layer blocks legitimate work. For actions with real-world consequences that’s the right default, but it’s a cost you should price rather than discover.</p><p>You also lose optimization surface. Every rule in the kernel is something the agent can’t tune, and some of those rules will be wrong. The answer isn’t to let the agent fix them — it’s to keep the kernel small enough that a human can review it in a pull request. A trusted computing base you can’t read isn’t trusted, it’s just privileged.</p><p>And immutable doesn’t mean permanent. Kernel policy changes constantly. It changes through a human-reviewed deploy, which is a completely different thing from changing at runtime because a loop found it inconvenient.</p><h3>What this means if you lead a team</h3><p>Harness engineering is going to show up in your architecture reviews, and the conversation will be about loops, memory, and evals — because that’s where the interesting work is.</p><p>The question worth adding: <strong>which parts of this harness can the agent modify, and how do we know?</strong></p><p>Most teams can’t answer it today, because the harness grew organically and the permission logic ended up in the same repository, the same config, the same deploy as everything else. Nobody decided that. It just happened, the way privilege boundaries always erode when nobody draws them explicitly.</p><p>Drawing the line is not a research problem. It’s a partition, a separate process, and an append-only log — a sprint of work if you do it before you need it, and a forensic exercise if you do it after.</p><h3>The takeaway</h3><p>Weng is right that the harness improves first. That’s the most useful framing we have, and teams should act on it.</p><p>But “the agent rewrites its runtime” and “the runtime contains the permission controls” cannot both be true without a partition between them. Self-improvement needs an optimization surface <em>and</em> a boundary it cannot optimize — and the industry is currently building the first with enormous energy and the second almost not at all.</p><p>Let the agent tune its prompts, its tools, its loops, its memory. Let it get genuinely better at its job.</p><p>Just don’t let it hold the pen that writes its own limits.</p><p><strong>Which parts of your harness can your agent modify — and are you sure?</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0b5647148ac1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Who Authorized That? The Question Agent Wallets Can’t Answer.]]></title>
            <link>https://medium.com/@yagmur.sahin/who-authorized-that-the-question-agent-wallets-cant-answer-beca7ed2184a?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/beca7ed2184a</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Sat, 05 Sep 2026 13:36:43 GMT</pubDate>
            <atom:updated>2026-09-05T13:36:43.855Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Spend caps tell you money left. They can’t tell you who decided it should.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ej6hEydGA27ezkqnPiOeEA.jpeg" /></figure><p>An agent pays a $12,000 vendor invoice.</p><p>Your controls worked. The amount sat under the per-transaction limit, the vendor was on the allowlist, the velocity check didn’t trip. Everything the payments industry has spent eighteen months building for agentic commerce did exactly what it was designed to do.</p><p>Now answer a simple question: <strong>who authorized it?</strong></p><p>Not which card. Which <em>agent</em> under whose delegation, against which policy rule, within whose budget, approved by which human. If your answer involves reconstructing a story from three log files and a Slack thread, you don’t have authorization. You have a receipt.</p><p>This gap is about to matter a lot. A 2026 Cloud Security Alliance survey found that 65% of enterprises running AI agents experienced at least one agent-related incident in the past twelve months, and 35% of those reported direct financial losses. Agent spending is moving onto production rails right now paying vendors, metered APIs, contractors.</p><p>And nearly every article written about controlling it is solving the problem at the wrong layer.</p><h3>What the industry got right</h3><p>Credit where it’s due, because the payments work is genuinely good.</p><p>Six control types have become standard for teams putting agents on payment rails: spending limits, velocity caps, allowlists, approval workflows, policy engine enforcement, and virtual card scoping. Session caps at wallet creation. Single-use cards that die after one transaction. Santander and Mastercard demonstrated Europe’s first live agent payment inside a regulated banking environment using pre-authorized permissions and tokenized credentials.</p><p>All of it is necessary. None of it is what I’m arguing against.</p><p>The problem is that these are the controls at the <em>end</em> of the process, and most teams are treating them as the whole process.</p><h3>Why the payment rail is structurally blind</h3><p>A payment rail sees a transaction. It does not see an agent.</p><p>That distinction sounds pedantic until you look at what it costs you. The rail knows the card, the vendor, the amount, and the timestamp. It has no concept of which agent initiated the call, what task it was executing, which agent delegated the work, or whether that agent was ever permitted to perform this class of action at all.</p><p>The tooling around it has the same shape of blindness. Fraud detection was built to spot unusual <em>human</em> behavior. An agent that pays 300 times an hour, or sends continuously to new addresses, doesn’t look like fraud to those systems — it looks like a broken system. The heuristics assume a person’s rhythm, and agents don’t have one.</p><p>There’s a deeper asymmetry underneath. When a human pays, they make a judgment call at that moment. When an agent pays, that judgment has to be written into rules before the agent starts.</p><p>That’s the whole argument in one sentence. Human commerce embeds a decision at transaction time. Agentic commerce has no such moment — so the decision has to be moved <em>earlier</em>, encoded at the point where authority is granted. The payment rail is downstream of every decision that mattered.</p><h3>The part nobody is modeling: delegation</h3><p>Here’s where it gets worse, and where the existing coverage stops entirely.</p><p>Every spend-control article I can find assumes one agent with one wallet. That’s not what anyone is building. Real systems look like this: an orchestrator receives a goal, delegates to a specialist, which delegates to another specialist, which calls a tool that moves money.</p><p>Now agent C pays that $12,000 invoice, on a task agent A initiated through agent B. Ask your wallet who authorized it and the honest answer is <em>a card did</em>. The authorization decision — if it happened at all — occurred two hops upstream, at a delegation boundary nobody instrumented.</p><p>This is the real failure mode, and it isn’t overspending. It’s an agent performing an action it was <strong>never authorized to perform</strong>, using a card configured to permit it. The cap did its job. The cap was never the control.</p><p>Consider a procurement agent advertising two skills: search_vendors and pay_invoice. One is a lookup. The other moves money. Nothing in the transport layer distinguishes them, and a signed agent identity proves only that the agent is who it claims to be — not that this caller, in this tenant, with this remaining budget, should be permitted to release a payment at 2am with no human awake.</p><p>Identity is not authorization. Discovery is not permission. Two different problems, and the payment rail solves neither.</p><h3>Move the gate upstream</h3><p>The reframe: <strong>this is an authorization problem at the delegation boundary, not a payments problem at the wallet.</strong></p><p>The design principle is that every task handed from one agent to another passes through exactly one gate, and each stage can stop it before anything executes.</p><p><strong>Identity.</strong> Agent cards are signed and verified; each agent carries a token. Stops an impostor advertising privileged skills.</p><p><strong>Capability scoping.</strong> A skill is routable only if it appears in the target’s signed card. Stops an agent being handed a capability it never declared.</p><p><strong>Policy.</strong> Declarative first-match rules returning allow, deny, or require_approval — and it fails closed.</p><pre># Authorization as a reviewable artifact, not logic buried in an agent.<br>rules:<br>  - match: { skill: &quot;search_vendors&quot; }<br>    effect: allow<br><br>  - match: { skill: &quot;pay_invoice&quot; }<br>    effect: require_approval     # money moves → a human decides<br><br>  - match: { skill: &quot;*&quot; }<br>    effect: deny                 # unlisted is not allowed</pre><p>That catch-all is the line I’d defend hardest. A system that permits when a rule is missing is one config gap from an incident.</p><p><strong>Budget.</strong> Per-tenant ceilings in currency and tokens, checked before spend and committed after — so a runaway loop can’t become a runaway invoice.</p><p><strong>Human-in-the-loop.</strong> Money-moving skills park for approval and resume where they left off.</p><p><strong>Audit.</strong> Every decision, including every denial, appends to a hash-chained log.</p><h3>The record that answers the question</h3><p>This is the artifact the wallet cannot produce:</p><pre>{<br>  &quot;task_id&quot;:       &quot;t_8f21&quot;,<br>  &quot;skill&quot;:         &quot;pay_invoice&quot;,<br>  &quot;chain&quot;:         [&quot;orchestrator&quot;, &quot;procurement-agent&quot;],  # who delegated to whom<br>  &quot;tenant&quot;:        &quot;acme&quot;,<br>  &quot;policy_rule&quot;:   &quot;pay_invoice -&gt; require_approval&quot;,<br>  &quot;approved_by&quot;:   &quot;controller@acme.com&quot;,<br>  &quot;budget_before&quot;: 48200.00,<br>  &quot;amount&quot;:        12000.00,<br>  &quot;prev&quot;:          &quot;9c1f2a...&quot;,                            # links to prior entry<br>}</pre><p>One record. Which agent, on whose delegation, under which rule, within what budget, approved by which human — before a cent moved.</p><p>And the chaining is what makes it evidence rather than logging:</p><pre>def append(self, record: dict) -&gt; str:<br>    &quot;&quot;&quot;Each entry commits to the one before it. Editing history breaks the chain.&quot;&quot;&quot;<br>    prev = self.head or &quot;0&quot; * 64<br>    payload = canonical_json({**record, &quot;prev&quot;: prev})<br>    digest = sha256(payload.encode()).hexdigest()<br>    self.log.write(payload + &quot;\n&quot;)<br>    self.head = digest<br>    return digest</pre><p>Six lines. Any retroactive edit to any entry invalidates every digest after it. In a vendor dispute, that’s the difference between a log you assert is accurate and one you can demonstrate wasn’t altered.</p><p>I built this as a reference implementation to see how wide the gap between the protocols and production really is. The invariant the whole thing exists to guarantee is one sentence: <em>an agent can never spend real money without a human approving the charge.</em></p><h3>The Shortcuts Are in Plain Sight</h3><p>A reference implementation earns trust by naming its limits, not by hiding them. Mine has three worth stating outright.</p><p><strong>Storage is deliberately boring.</strong> Budgets and audit records live in memory and append-only files, behind narrow interfaces. Production swaps in Postgres with row-level locking for atomic budget decrements and a write-once bucket for the audit trail — a substitution, not a redesign.</p><p><strong>Trust is verified, not pinned.</strong> Agent cards are checked for a valid self-signature. Production pins each agent’s public key, so a signature that verifies but belongs to an unknown key gets rejected.</p><p><strong>Budgets estimate before they commit.</strong> That’s honest under light load and wrong under real concurrency, where a reserve-and-settle ledger belongs.</p><p>The point isn’t that these are solved. It’s that each one sits behind an interface narrow enough to replace without touching the control model which is the part worth defending.</p><p>A design that hides its limits isn’t a design. It’s a demo.</p><h3>The Gate Is Not Free</h3><p>A gate is a new failure surface. It’s on the critical path of every inter-agent call, it adds latency, and it needs its own availability story. Fail-closed means an outage in your policy layer blocks legitimate work — that’s the correct default for money-moving actions and a real operational cost you should price in.</p><p>Policy sprawl is a genuine risk. First-match rules are readable at twenty and unreadable at four hundred; the discipline is keeping the ruleset small enough to review in a pull request.</p><p>And none of this removes the need for wallet controls. Defense in depth means the spend cap is still there. It’s just no longer pretending to be authorization.</p><h3>The question to take to your next review</h3><p>Not “do we have spend limits.” You do, and they aren’t the gap.</p><p>Ask instead: <strong>for the last action an agent took that cost us money, can we produce a single record naming the agent, the delegation chain, the policy rule, the budget state, and the human who approved it — without reconstructing it from three systems?</strong></p><p>If that requires archaeology, then in a dispute, an audit, or an incident, “the card had a limit” is what you’ll be left saying. It’s true, and it isn’t an answer.</p><p>Keep your spend caps. Just stop calling them authorization.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=beca7ed2184a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCP and A2A Are Connecting AI Agents. Now Comes the Hard Part.]]></title>
            <link>https://medium.com/@yagmur.sahin/mcp-and-a2a-are-connecting-ai-agents-now-comes-the-hard-part-61bdeb492f9d?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/61bdeb492f9d</guid>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 02:11:55 GMT</pubDate>
            <atom:updated>2026-08-26T02:11:55.619Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Agent protocols are getting better. The harder production problem is deciding what agents are allowed to do once everything is connected.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*418XIaOTTMCtKp-oK_z_-g.png" /></figure><p>AI agents are getting easier to connect.</p><p><strong>MCP standardizes how agents access tools and context. A2A standardizes how agents communicate with other agents.</strong></p><p>That solves an important interoperability problem.</p><p>But in production, the difficult question quickly changes from <strong>“Can this agent call it?”</strong> to <strong>“Should this agent be allowed to call it?”</strong></p><p>That difference matters.</p><h3>Connectivity Is Not Authority</h3><p>Imagine an agent that can:</p><ul><li>discover a payment tool through MCP</li><li>delegate work to another agent through A2A</li><li>execute the final transaction</li></ul><p>The protocols can make those interactions possible.</p><p>They do not, by themselves, answer:</p><p><strong>Which agent is acting?</strong></p><p><strong>Which user is it acting for?</strong></p><p><strong>What authority was delegated?</strong></p><p><strong>How much can it spend?</strong></p><p><strong>Does this action require approval?</strong></p><p><strong>Can we reconstruct what happened later?</strong></p><p>Those are not prompt-engineering problems.</p><p>They are <strong>identity, authorization, policy, and distributed-systems problems.</strong></p><p>And they need infrastructure.</p><h3>Production Agents Need a Control Plane</h3><p>A useful architecture separates agent reasoning from execution control.</p><pre>                 A2A<br><br>        Agent A ───────► Agent B<br>           │                │<br>           └──────┬─────────┘<br>                  ▼<br>          Agent Control Plane<br><br>      Identity  │  Policy  │  Budget<br>      Approval  │  Audit   │  Observability<br><br>                  │<br>                  ▼<br><br>                Gateway<br>                  │<br>                 MCP<br>                  │<br>          Tools / APIs / Data</pre><p>The model decides <strong>what it wants to do</strong>.</p><p>The control plane decides <strong>whether it is allowed to do it</strong>.</p><p>That is a much safer boundary.</p><h3>Don’t Put Hard Rules in Prompts</h3><p>Consider a financial agent with this instruction:</p><blockquote><em>Never transfer more than $500 without approval.</em></blockquote><p>That may be useful guidance.</p><p>It should not be the security boundary.</p><p>A production system should enforce that rule outside the model:</p><pre>decision = policy.authorize(<br>    actor=agent.id,<br>    action=&quot;payments.transfer&quot;,<br>    amount=amount,<br>    delegated_by=user.id,<br>)<br><br>if not decision.allowed:<br>    raise PolicyDenied()</pre><p>This applies beyond payments.</p><p>Tool access, tenant isolation, credential scopes, destructive actions, network destinations, delegation limits, and execution budgets should be enforced deterministically whenever possible.</p><p>A principle worth keeping:</p><blockquote><strong><em>Let models reason probabilistically. Enforce critical boundaries deterministically.</em></strong></blockquote><h3>Agent Identity Is Becoming a Real Infrastructure Problem</h3><p>This issue becomes more important as agent delegation grows.</p><p>A traditional application might look like:</p><pre>User → Service → API</pre><p>An agent system may become:</p><pre>User → Agent A → Agent B → Tool</pre><p>If Agent B changes customer data, simply recording &quot;Agent B&quot; is not enough.</p><p>The execution may need to preserve:</p><ul><li>the originating user</li><li>agent identity</li><li>delegated permissions</li><li>authorization scope</li><li>policy decision</li><li>resulting action</li></ul><p>This direction is already visible in the protocols themselves. A2A v1.0 introduced stronger enterprise capabilities including signed Agent Cards, while the latest MCP roadmap explicitly calls out agent identity, delegated authorization, and enterprise security as areas of active development.</p><p>The protocols are evolving toward these problems.</p><p>But engineering teams still need to design the surrounding control architecture.</p><h3>Observability Is Not Audit</h3><p>Agent systems also need both.</p><p><strong>Observability tells you why the system behaved the way it did.</strong></p><pre>agent.run<br> ├── model.call<br> ├── tool.search<br> ├── agent.delegate<br> └── tool.execute</pre><p><strong>Audit tells you who performed an action, under what authority, and what changed.</strong></p><p>Those are different requirements.</p><p>A trace helps debug an agent.</p><p>An audit trail helps establish accountability.</p><p>Production platforms should design for both from the beginning.</p><h3>The Bigger Architecture Question</h3><p>MCP and A2A are valuable because they reduce integration friction.</p><p>But lower integration friction also means agents can reach more systems more easily.</p><p>That makes control more important, not less.</p><p>The next generation of agent infrastructure therefore needs more than connectivity.</p><p>It needs:</p><p><strong>identity, delegated authority, policy enforcement, approval boundaries, observability, and audit.</strong></p><p>Protocols tell agents <strong>how to communicate</strong>.</p><p>Production architecture must decide <strong>what that communication is allowed to cause</strong>.</p><p>And that may become one of the most important engineering boundaries in agentic AI.</p><p><strong>If your agents can discover tools and delegate work today, where does authority actually live?</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=61bdeb492f9d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Made Everyone Faster at the Thing That Was Never Slow.]]></title>
            <link>https://medium.com/@yagmur.sahin/ai-made-everyone-faster-at-the-thing-that-was-never-slow-8fc21435aabe?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/8fc21435aabe</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Fri, 21 Aug 2026 11:07:27 GMT</pubDate>
            <atom:updated>2026-08-21T11:15:58.233Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Five datasets say teams are writing far more code and shipping less of it. That’s not a paradox. It’s a queueing problem with a name.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LI7ylxF43lTW6IXtoZbv9Q.png" /></figure><p>Ask an engineering leader whether AI has made their team faster and you’ll get an enthusiastic yes. Ask whether they’re <em>shipping</em> faster and watch the pause.</p><p>I’ve had that conversation enough times this year to stop treating it as anecdote. The data now says the same thing, and it says it loudly enough to deserve an explanation rather than another think-piece about the productivity paradox.</p><p>Here’s the short version: <strong>code authorship was never the bottleneck.</strong> We spent two years pouring capability into the one stage of software delivery that wasn’t constrained, and we’re now surprised that the constrained stages got worse.</p><p>That isn’t a mystery. It’s Theory of Constraints with a code generator attached.</p><h3>What the numbers actually say</h3><p>Four independent sources, measuring different things, pointing the same direction.</p><p>CircleCI analyzed more than 28 million CI workflows and found average throughput up 59% year over year. Enormous. But the gains were concentrated: the top 5% of teams nearly doubled their throughput at +97%, the median team gained 4%, and the bottom quartile saw no measurable increase at all.</p><p>Then the split that matters. Feature-branch activity rose — that’s where AI helps you prototype and iterate — while <strong>main-branch throughput declined</strong>. Main-branch success rates dropped to 70.8%, a five-year low against a 90% benchmark. Roughly three in ten merges are now failing. Average recovery time reached 72 minutes, up 13% year over year.</p><p>Inside OpenAI, 95% of developers use Codex and submit about 60% more pull requests each week — yet features don’t reach customers proportionally faster, because review times rise to match.</p><p>CodeRabbit found PRs per author up 20% year over year while incidents per pull request rose 23.5%.</p><p>And Linear, which sees the whole workflow from first issue to closing PR, found the detail I keep coming back to: AI adoption more than doubled across every function in the first half of 2026, and <strong>nothing else shrank to make room.</strong> Chatting with AI and delegating to agents are categories of work that didn’t exist a year ago. They landed on top.</p><p>More authored. Less merged. More failures. Longer recovery. Nothing removed.</p><h3>The boring explanation</h3><p>Every delivery pipeline has one constraint that sets its actual throughput. Improve anything upstream of that constraint and you don’t get more output — you get more work-in-progress piling up in front of it.</p><p>For most engineering organizations, the constraint has never been how fast someone can type a function. It’s the sequence <em>after</em> the code exists: review, CI, integration, deploy. Those stages are gated by human attention and pipeline capacity, and neither scaled 60% last year.</p><p>The part that surprises people is how violently a queue degrades when you push it toward capacity. It isn’t linear. Model review as a single-server queue and the arithmetic is brutal:</p><pre>def queue_wait(arrival_rate, service_rate):<br>    &quot;&quot;&quot;Mean wait before service, M/M/1. Units: whatever you pass in.&quot;&quot;&quot;<br>    rho = arrival_rate / service_rate          # utilization<br>    if rho &gt;= 1:<br>        raise ValueError(&quot;arrival exceeds capacity: queue grows without bound&quot;)<br>    return rho / (service_rate * (1 - rho))<br><br>REVIEW_CAPACITY = 100        # PRs/week your reviewers can actually absorb<br>HOURS = 168<br><br>before = queue_wait(60, REVIEW_CAPACITY)          # 60% utilized<br>after  = queue_wait(60 * 1.6, REVIEW_CAPACITY)    # same team, +60% PRs<br><br>print(f&quot;before: {before * HOURS:5.1f}h wait&quot;)     # before:   2.5h wait<br>print(f&quot;after:  {after  * HOURS:5.1f}h wait&quot;)     # after:   40.3h wait<br>print(f&quot;ratio:  {after / before:5.1f}x&quot;)          # ratio:   16.0x</pre><p>A 60% increase in pull requests against unchanged review capacity produces a <strong>16× increase in review wait</strong>. Nobody got lazier. Nobody’s tooling broke. Utilization went from 0.60 to 0.96, and the queue did what queues do.</p><p>That’s the entire productivity paradox in six lines.</p><p>M/M/1 is a simplification — review arrivals aren’t Poisson, reviewers aren’t a single server, and real teams shed load by rubber-stamping. But every one of those deviations makes the real curve worse, not better, and the shape is what matters: the cost of added arrival rate is negligible at moderate utilization and catastrophic near capacity. Most teams were already at moderate-to-high utilization before AI arrived.</p><p>What compounds it is the feedback loop. Failed merges don’t just fail — they consume review and CI capacity a second time on retry, then again during recovery. At a 70.8% success rate, a meaningful share of your scarcest capacity is spent processing the same change twice. That’s not degradation. That’s a system converting capacity into rework.</p><h3>Where the queue actually forms</h3><p>Four candidates, different symptoms, different fixes.</p><p><strong>Review capacity.</strong> Human attention is the least elastic resource you have. Authoring capacity rose 60%; the ability to <em>understand</em> changes did not. Symptom: rising time-to-first-review, PRs open for days, reviewers approving without reading.</p><p><strong>CI throughput.</strong> Pipelines sized for last year’s volume now queue. Symptom: jobs waiting on runners, developers batching changes to dodge the wait, merges on a green build from three hours ago.</p><p><strong>Integration conflict.</strong> More parallel branches produce more semantic conflicts that pass review individually and fail together. This is what a falling main-branch success rate looks like from the inside.</p><p><strong>The failure loop.</strong> Every failed merge occupies the constraint twice, and 72-minute recovery means each one costs more than an hour of exactly the capacity you’re short of.</p><p>Three of those four sit downstream of code generation. None improve by generating code faster.</p><h3>Scale the constraint</h3><p>The fix isn’t slowing generation. It’s raising the service rate where the queue forms.</p><p><strong>Put automated validation before human review.</strong> The highest-value use of AI in this pipeline isn’t writing more code — it’s ensuring humans never see what a machine could have caught. Make it a gate, not a suggestion:</p><pre># Human review is the constraint. Spend it on design, not null checks.<br>pull_request:<br>  gates:<br>    - static-analysis        # blocking<br>    - test-coverage: { min_patch_coverage: 80 }<br>    - security-scan          # blocking<br>    - ai-review              # blocking on correctness findings only<br>  request_human_review_when: all_gates_pass</pre><p>That single reordering is the difference between reviewers as a filter and reviewers as a bottleneck.</p><p><strong>Use a merge queue.</strong> The highest-leverage change for a declining main-branch success rate. It tests each change against the state it will actually land in, rather than a stale base — precisely the failure mode more parallel branches create:</p><pre>merge_queue:<br>  max_parallel: 4          # speculative batches, so the queue doesn&#39;t serialize<br>  required_checks: [unit, integration, migration-safety]<br>  batch_size: 1            # bisect on failure; don&#39;t revert four changes for one</pre><p><strong>Shard CI and cap the wait.</strong> If p95 runner queue time exceeds a few minutes, you are rate-limiting the entire organization with an infrastructure line item that costs less than one engineer.</p><p><strong>Shrink batch size.</strong> Smaller changes review faster, fail less, recover faster. AI makes large diffs cheap to produce, which is exactly why an explicit norm on change size matters more now than it did two years ago.</p><p><strong>Budget review capacity like the scarce resource it is.</strong> If authorship rose 60%, review has to go somewhere: more reviewers, more automation upstream, or a deliberate decision to author less. What doesn’t work is pretending the constraint absorbed it silently.</p><h3>Why the top 5% pulled away</h3><p>This is the most instructive finding, and it should be encouraging rather than discouraging.</p><p>AI didn’t create the gap between the top 5% and the median. It exposed one that already existed. Teams with strong validation, fast pipelines, and disciplined change sizes converted a volume surge into shipped work. Teams without them converted the same surge into queue depth and failed merges.</p><p>The differentiator wasn’t AI adoption — that’s near-universal now. It was delivery infrastructure that existed <em>before</em> AI arrived. Which makes the advice unglamorous and entirely actionable: the investment that makes AI pay off isn’t a better model or another agent. It’s the pipeline work that’s been sitting in your backlog for three years.</p><h3>What to tell your exec team</h3><p>Eventually someone asks why the AI investment hasn’t shown up in the roadmap. There’s a defensible answer, and it’s better than deflecting.</p><p>Stop reporting PRs authored, lines generated, or tool adoption. Those measure activity at the stage that was never constrained — which is exactly why they look so impressive and change so little.</p><p>Report three numbers instead:</p><p><strong>Changes reaching production per week.</strong> The only throughput figure that corresponds to customer value.</p><p><strong>Main-branch success rate.</strong> Below 90% means you’re funding rework out of your scarcest capacity.</p><p><strong>Review latency at p95.</strong> Your actual constraint, expressed as something an executive can act on.</p><p>Those three distinguish throughput from inventory. Most dashboards today measure inventory and call it velocity.</p><h3>The takeaway</h3><p>We adopted a technology that made one stage of software delivery dramatically faster, and it happened to be the stage that was already fastest. The result is what queueing theory predicts: more work in flight, longer cycle times, more failures, and teams that feel busier while shipping less.</p><p>None of that argues against AI-assisted development. It argues that the bottleneck moved and most organizations are still optimizing the old one. The teams pulling ahead aren’t running better models. They built the capacity to absorb what those models produce.</p><p>So before the next tool evaluation, one question outweighs any benchmark: <strong>is your constraint writing code, or everything that happens after?</strong></p><p>If you don’t know, that’s your answer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8fc21435aabe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your AI Is Radioactive. You Just Can’t See It.]]></title>
            <link>https://medium.com/@yagmur.sahin/your-ai-is-radioactive-you-just-cant-see-it-811b3bb3aba2?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/811b3bb3aba2</guid>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[ai-governance]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Sat, 15 Aug 2026 12:13:18 GMT</pubDate>
            <atom:updated>2026-08-15T12:13:18.316Z</atom:updated>
            <content:encoded><![CDATA[<p><em>AI-generated text is marked now. The mark survives fine-tuning which means the model you trained carries a signature you never put there.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6ICbnjq44vTzXm-pJreVzw.png" /></figure><p>Here’s a workflow running at thousands of companies right now.</p><p>A team needs training examples. Human labeling is slow and expensive, so they generate synthetic ones from a frontier model. Ten thousand examples, filtered, used to fine-tune a smaller model they own and serve themselves. Cheaper, faster, and it works.</p><p>What almost none of those teams know is that as of a few weeks ago, something came along for the ride.</p><p>Researchers gave it a name: <strong>radioactivity</strong>. If a model’s output is watermarked and you fine-tune on that output, the watermark doesn’t wash out. It survives training, and statistically detectable traces surface in what <em>your</em> model generates. The finding was published at NeurIPS in 2024, extending earlier work on tracing training data through models. For two years it was an interesting result.</p><p>On August 2, 2026, it stopped being academic.</p><h3>What actually changed</h3><p>The EU’s transparency obligations took effect August 2. The associated Code of Practice prescribes three layers: C2PA metadata embedded in the file, imperceptible watermarking that survives common manipulations, and centralized logging of generation events. All three, deliberately — an acknowledgment that metadata alone is trivially removed by a screenshot, an upload, or a file conversion.</p><p>Providers responded. Anthropic confirmed that models released after August 2 automatically watermark generated text and files, applied at the model level so it appears across the API and their coding tools alike, and travels with text that’s copied and pasted. Google open-sourced its text watermarking implementation so other developers can build compatible marking into their own generation. California’s provenance requirements took effect in January.</p><p>Plainly: <strong>AI-generated text now arrives pre-marked, by default, and you didn’t opt in.</strong></p><p>Fine, if it stays in a chat window. In an AI stack, it never does.</p><h3>Where it lands in an AI system</h3><p>Marked text doesn’t sit still. In any real AI stack it flows into four places, all of which you own:</p><p><strong>Synthetic training sets</strong> — the distillation workflow above, the highest-leverage pattern in applied AI right now.</p><p><strong>Retrieval corpora</strong> — model output pasted into docs, tickets, and wikis that get chunked and indexed. Your RAG layer quietly fills with generated text.</p><p><strong>Agent chains</strong> — one agent’s output becomes another agent’s input, and in a multi-step system that composition happens several times per task with no human in between.</p><p><strong>Eval sets</strong> — the one nobody thinks about, and the one with the sharpest edge.</p><p>Every one of those is a surface you’re accountable for. None of them, in most organizations, has any concept of provenance at all.</p><h3>Radioactivity: why fine-tuning is the sharp edge</h3><p>Sit with what the finding means operationally.</p><p>Your fine-tuned model is an artifact you own, serve, and answer for. It now carries a signal you never put there, that you cannot see, that you probably cannot remove, and that someone else can test for.</p><p>If a provider’s terms restrict using outputs to train competing models, that clause just became enforceable in a way it wasn’t before. Detection moved from accusation to measurement.</p><p>The mechanism cuts both directions. Researchers have proposed using watermarks to detect benchmark contamination and to identify unauthorized use of retrieval corpora. Whether that’s a threat or a tool depends on which side of the model you’re standing on.</p><p>Either way, the question is uncomfortable and specific: <strong>for any model you’ve fine-tuned this year, can you name what generated its training examples?</strong> Most teams can’t. Nothing required it.</p><h3>Your evals are exposed too</h3><p>This one deserves its own beat, because it’s the case AI engineers will feel fastest.</p><p>If you generated eval questions with a model — and lots of teams do, because writing good eval sets by hand is tedious — and that same family of model is what you’re benchmarking, watermark signal is now a way to demonstrate contamination.</p><p>Your benchmark numbers were always at some risk of being circular. The difference is that circularity is now measurable by a third party. An eval suite you can’t attribute is an eval suite you can’t defend, and “our model scores 94%” is a much weaker claim when nobody can say where the questions came from.</p><h3>Where provenance breaks</h3><p>The failure modes are worse than the marketing suggests.</p><p><strong>Metadata dies in normal handling.</strong> C2PA manifests live in file metadata, and platforms routinely strip metadata on upload. So does format conversion and most preprocessing. The provenance you’re now obligated to preserve is destroyed by ordinary infrastructure doing exactly what it was built to do.</p><p><strong>Paraphrase kills text watermarks.</strong> The common red-green list approach carries roughly one bit of signal and is fragile to paraphrase. If any stage rewrites, summarizes, or translates — and in an agentic stack, several do — the mark may not survive. More robust cryptographic schemes survive substantially more editing, but nothing holds against a determined adversary with white-box access.</p><p><strong>The two layers can contradict each other.</strong> Researchers demonstrated an <em>Integrity Clash</em>: an asset carrying a cryptographically valid C2PA manifest asserting human authorship while simultaneously carrying a watermark identifying it as AI-generated — both passing their own verification checks in isolation. No cryptographic compromise required; it emerges from standard editing workflows and the omission of a single assertion field the spec permits. The layers are technically independent; neither conditions on the other.</p><p>A system that checks only the manifest can be confidently, verifiably wrong.</p><h3>The engineering response</h3><p>Here’s what nearly every distillation script looks like today:</p><pre># The three lines that make a model radioactive<br>examples = [client.generate(p) for p in prompts]<br>Path(&quot;train.jsonl&quot;).write_text(to_jsonl(examples))<br>fine_tune(base=&quot;small-model&quot;, data=&quot;train.jsonl&quot;)   # lineage: gone</pre><p>Nothing about that is wrong as code. It’s just that the one fact you’ll be asked about later — <em>what wrote these?</em> — is discarded at line one, and it can never be recovered afterward.</p><p>The fix is cheap, and it’s the same move as attaching a trace ID at the edge: capture the fact while you still have it, carry it through, and make eligibility an explicit decision rather than an emergent property of whatever ended up in the file.</p><pre>@dataclass(frozen=True)<br>class Example:<br>    prompt: str<br>    completion: str<br>    generator: str        # exact model + version that produced it<br>    watermarked: bool     # does this provider mark output by default?<br>    terms_allow_ft: bool  # do their terms permit fine-tuning on it?<br><br>def generate(prompt: str, model: str) -&gt; Example:<br>    out = client.generate(prompt, model=model)<br>    p = PROVIDERS[model]<br>    return Example(prompt, out.text, model, p.watermarks, p.allows_finetune)<br><br>def assemble(examples: list[Example]) -&gt; list[Example]:<br>    eligible = [e for e in examples if e.terms_allow_ft]<br>    marked = sum(e.watermarked for e in eligible)<br>    if marked:<br>        log.warning(&quot;radioactive: %d/%d marked examples entering fine-tune&quot;,<br>                    marked, len(eligible))<br>    return eligible</pre><p>Then write it where it survives the model, not just the run — in the model card that ships with the artifact:</p><pre># model-card.yaml — lineage travels with the weights<br>training_data:<br>  synthetic: true<br>  generators: [&quot;&lt;provider-model&gt;@&lt;version&gt;&quot;]<br>  watermarked_fraction: 0.83<br>  terms_reviewed: 2026-08-15</pre><p>That last file is the deliverable. A model card that names its generators turns an invisible liability into a documented decision — and it’s the artifact you’ll want to hand someone during a vendor dispute, a diligence process, or an audit.</p><h3>What this doesn’t give you</h3><p>Watermark detection is probabilistic, not proof. It’s a statistical signal with false positives and false negatives, and it degrades under editing. Don’t build enforcement, accusations, or automated blocking on it. It’s evidence, not a verdict.</p><p>Provenance also doesn’t tell you whether content is <em>correct</em>. A perfectly attributed example can be completely wrong. This is a supply-chain control, not a quality control, and conflating them is how teams end up trusting well-labeled garbage.</p><p>And none of it is settled — the specs are moving, tooling is immature, and the interaction between layers isn’t fully worked out even by the people designing it.</p><h3>Nobody Owns Model Lineage</h3><p>This gets missed for an organizational reason, not a technical one.</p><p>Model lineage sits in a gap. The AI engineers own the fine-tuning but not the terms review. Legal owns the obligation but can’t read the training config. Whoever runs the model registry owns the artifact but not the decision that produced it. A concern that belongs to everyone belongs to no one — and it surfaces during diligence, an audit, or a vendor dispute, where “we didn’t record that” is an expensive sentence.</p><p>The fix isn’t a project. It’s three fields and an owner: roughly a sprint if you do it before you need it, forensic archaeology if you do it after.</p><p>So one question for your next model review: <strong>for every fine-tuned model you serve, can you name what generated its training examples?</strong></p><p>If not, that’s not a compliance gap. It’s a lineage gap that happens to have regulators attached.</p><h3>The takeaway</h3><p>The marks are already in your models. They arrived by default, in text your team generated and trained on without anyone deciding anything.</p><p>You can’t see them. Someone else can.</p><p>The answer isn’t detection tooling — it’s refusing to lose track of where your training signal came from in the first place. That’s not a new discipline. It’s the one we already apply to dependencies, and we’re overdue applying it to model lineage.</p><p><strong>Do you know what’s in your model? Or only what’s in your weights?</strong></p><p><em>References / Further Reading: Sander et al., “Watermarking Makes Language Models Radioactive,” NeurIPS 2024 · Sablayrolles et al., “Radioactive Data: Tracing Through Training,” ICML 2020 · C2PA Specification v2.2 · EU Code of Practice on AI-generated content marking · California SB 942</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=811b3bb3aba2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Just Got 14× Faster. Here’s What Actually Changes.]]></title>
            <link>https://medium.com/@yagmur.sahin/ai-just-got-14-faster-heres-what-actually-changes-76412bfee9b0?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/76412bfee9b0</guid>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Sat, 15 Aug 2026 01:48:16 GMT</pubDate>
            <atom:updated>2026-08-15T11:44:26.320Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A speed tier isn’t a new model. But it moves a tradeoff that a lot of production architecture was quietly built around.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xkSG6h5Ic8WZTHmgIlu99g.png" /></figure><p>For three years, everyone building with LLMs made the same compromise.</p><p>You wanted the smart model. The smart model was slow. So anywhere a human was waiting — a chat interface, an autocomplete, an interactive tool — you reached for the smaller, faster one and accepted that it would be a little worse. Anywhere quality mattered more than speed, you made it asynchronous: a job queue, a progress spinner, an email when it finished.</p><p>That compromise shaped a surprising amount of production architecture. And on August 13, OpenAI previewed something that moves it.</p><p>Ultrafast is a new API service tier running GPT-5.6 Sol at up to 750 output tokens per second — up to 14× faster than standard processing — on hardware from Cerebras. The detail that matters most to engineers: <strong>it is not a new model.</strong> It’s the same GPT-5.6 Sol, served differently, with the same claimed intelligence.</p><p>Before anyone rewrites a roadmap, the fine print deserves equal billing: it’s a limited preview behind a waitlist, with no published pricing, no general-availability date, and no separate model ID. Every speed multiple traces back to the vendors themselves. You cannot build a plan on it today.</p><p>But you can think about what it means, because the direction is clear — and the second-order effects on system design are more interesting than the headline.</p><h3>Why speed is a different kind of improvement</h3><p>Most model releases move capability. This one moves latency, and latency behaves differently in a system.</p><p>Capability improvements are absorbed locally: a better model gives better answers at the same call site. Latency improvements are absorbed <em>structurally</em>. When something gets dramatically faster, designs that existed only to hide the slowness stop earning their keep.</p><p>We’ve seen this pattern before outside AI. Broadband didn’t just make websites load faster — it made streaming video a product category. The architecture people built for dial-up (download-then-play, aggressive compression, progress bars) didn’t get faster; it became unnecessary. Cerebras made this comparison in their own launch materials, and self-serving as it is, the analogy holds.</p><p>The enabling story is architectural rather than algorithmic. Serving a large model is dominated by moving weights to compute. Cerebras’s wafer-scale design keeps 44 GB of SRAM on a single wafer-sized chip so the weights never leave the silicon, and tokens flow through layers pipelined across wafers. Attack data movement and you attack the thing that actually sets inference latency and cost.</p><p>Whether that specific approach wins is a separate question. The point is that inference speed is now a competitive axis with real engineering behind it, not just a pricing lever.</p><h3>The part that matters most: agents multiply latency</h3><p>Here’s where this gets genuinely significant, and it’s the piece most coverage is missing.</p><p>In a chat interface, model latency is additive. You wait once. Annoying, but bounded.</p><p>In an agentic system, latency is <em>multiplicative</em>. An agent that plans, calls a tool, reads the result, decides, calls another tool, and summarizes has made five or six sequential model calls before the user sees anything. Each one pays full latency. That’s why so many agent products feel sluggish in a way that chat doesn’t — the slowness compounds per step.</p><p>Do the arithmetic. Six sequential calls at eight seconds each is roughly forty-eight seconds of model time. The same six calls at a fraction of that lands in single digits. That’s not an incremental improvement in feel. It’s the difference between a workflow a human supervises in real time and one they kick off and walk away from.</p><p>Which means the systems that benefit most from a speed tier aren’t chatbots. They’re multi-step agents — precisely the systems most teams are trying to get into production right now.</p><h3>Four things that change downstream</h3><p>If frontier-quality inference gets fast, several standard design decisions deserve a fresh look.</p><p><strong>Async patterns collapse into sync.</strong> A lot of job queues, webhooks, and “we’ll notify you when it’s ready” flows exist purely because the model was slow. Some of those become unnecessary — and removing an async pipeline removes state, retries, failure modes, and an entire class of “where did my job go” support tickets. Simplification is the underrated win here.</p><p><strong>The cheap-model-for-interactive-paths rule weakens.</strong> The routing heuristic most teams landed on — small model where a human waits, big model where quality matters — was a workaround for a tradeoff. If the tradeoff loosens, the heuristic needs revisiting rather than inheriting. Note that this cuts against pure cost-routing logic, and you now have three axes to route on instead of two: capability, cost, and latency.</p><p><strong>Human-in-the-loop becomes practical.</strong> Approval gates are the right answer for consequential agent actions, and they’ve been painful to build because every round trip through a slow model made the human wait twice. Fast inference makes supervised autonomy feel like a conversation rather than a form submission. For anyone building agents that touch real systems, this is the quietly important one.</p><p><strong>Verification gets affordable.</strong> When a call is slow, you get one shot. When it’s fast, you can afford a second pass — self-consistency, a critic step, a validation call against the output. Spending some of a speed gain on correctness rather than pocketing all of it as latency is, in most production systems, the better trade.</p><h3>The reality check: Amdahl’s law applies to agents</h3><p>Now the part that keeps this honest, and the reason I’d instrument before I’d celebrate.</p><p>Making the model 14× faster only helps to the extent that the model is what you’re waiting on.</p><p>Pull a real trace from an agent in production and the model is often not the dominant cost. There’s retrieval against a vector store. A tool call to an internal API that takes 400ms on a good day. A database query. Network hops. Serialization. A rate limiter. In plenty of agent systems I’d wager the model accounts for well under half of p95 latency.</p><p>This is Amdahl’s law in its most practical form: speeding up one component caps out at whatever fraction of total time that component owns. If inference is 30% of your latency budget, a 14× improvement there buys you roughly a 28% overall reduction — real, worth having, and nowhere near 14×.</p><p>So the first move isn’t to join a waitlist. It’s to answer a question most teams can’t: <strong>where does your p95 actually go?</strong></p><pre># Instrument the whole agent trace, not just the model call.<br># The answer determines whether a speed tier is worth anything to you.<br><br>trace: checkout_agent / p95 = 11.4s<br>  ├─ plan            model      1.9s<br>  ├─ retrieve        vector db  2.6s<br>  ├─ tool: inventory http        3.1s   ← not the model<br>  ├─ decide          model      1.7s<br>  └─ summarize       model      2.1s<br><br>  model total: 5.7s (50%)  ·  everything else: 5.7s (50%)</pre><p>If your breakdown looks like that, a dramatic inference speedup is worth roughly a 2× improvement overall — good, but it also tells you the inventory API deserves attention first, and that one’s free.</p><h3>What this doesn’t change</h3><p>A speed tier doesn’t make an agent correct. It doesn’t fix a bad retrieval strategy, an underspecified tool contract, or the absence of an eval harness. If your agent is confidently wrong, it will now be confidently wrong faster.</p><p>There’s also a new lock-in question. A serving tier tied to specific hardware, in limited preview, with unpublished pricing, is not something to design a critical path around. The sensible posture is to keep the model behind an interface so a speed tier is a routing decision rather than an architectural commitment — the same discipline that protects you from any single vendor.</p><p>And the pricing is the open question. Faster inference on specialized hardware is not obviously cheaper inference. Until there’s a published price, the honest planning assumption is that speed will cost something, and the interesting engineering question becomes <em>which</em> paths in your system are worth paying for it.</p><h3>What I’d actually do this month</h3><p>Three things, none of which require access to anything in preview:</p><p><strong>Instrument your latency budget end to end.</strong> Break p95 down by stage across a real agent trace. You need this regardless, and it tells you whether inference speed is your problem at all.</p><p><strong>Find your latency-bound paths.</strong> Identify where a human is waiting on a multi-step agent. Those are the places a speed tier would pay off, and they’re probably fewer than you’d guess.</p><p><strong>Add latency as a routing dimension.</strong> If you already route by capability and cost, make speed an explicit third axis in the config rather than an implicit property of whichever model you picked.</p><p>That’s it. No waitlist required, and all three improve your system whether or not this particular tier ever reaches general availability.</p><h3>The takeaway</h3><p>The headline number is 14×. The useful insight is that latency has stopped being a fixed constraint you design around and started being a variable you can buy — which means it’s now an architecture decision, and architecture decisions deserve measurement rather than enthusiasm.</p><p>The teams that benefit won’t be the ones who get preview access first. They’ll be the ones who already know where their milliseconds go.</p><p>So before you think about faster models: <strong>do you actually know what fraction of your p95 belongs to inference?</strong> Most teams don’t. That number, not the vendor’s multiple, tells you what a speed tier is worth to you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76412bfee9b0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCP Went Stateless. Go Delete Your Session Store.]]></title>
            <link>https://medium.com/@yagmur.sahin/mcp-went-stateless-go-delete-your-session-store-7b93ba42536d?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b93ba42536d</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Fri, 14 Aug 2026 01:25:18 GMT</pubDate>
            <atom:updated>2026-08-14T01:46:01.913Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The 2026–07–28 spec is the largest revision since launch. The handshake is gone, sessions are gone, and your deployment topology just got simpler — if you migrate correctly.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*unnIiDo0xT-ODGQMkDcxew.png" /></figure><p>If you run an MCP server behind a load balancer, you have already fought this battle.</p><p>Sticky sessions. A shared session store so any pod could resume a connection. Reconnection logic when a pod restarted. Deep packet inspection at the gateway because the protocol wouldn’t tell you what operation was inside the request. None of it had anything to do with what MCP actually does — it was tax paid to a design decision.</p><p>As of July 28, that tax is gone. MCP 2026-07-28 is final, and the headline change is that the protocol is now stateless. The initialize/initialized handshake is removed. The Mcp-Session-Id header is removed. Any request can land on any instance.</p><p>This is the largest revision since MCP launched, and it contains breaking changes. Here’s what actually changed, what breaks, and how to plan the migration.</p><h3>Before and after, in one request</h3><p>Under the old spec, calling a tool meant establishing a session first, then carrying an Mcp-Session-Id on every subsequent request — which pinned the client to whichever instance issued it.</p><p>Under 2026-07-28, the same call is a single self-contained request:</p><pre>POST /mcp HTTP/1.1<br>MCP-Protocol-Version: 2026-07-28<br>Mcp-Method: tools/call<br>Mcp-Name: search<br>Content-Type: application/json<br><br>{&quot;jsonrpc&quot;:&quot;2.0&quot;,&quot;id&quot;:1,&quot;method&quot;:&quot;tools/call&quot;,<br> &quot;params&quot;:{&quot;name&quot;:&quot;search&quot;,&quot;arguments&quot;:{&quot;q&quot;:&quot;otters&quot;},<br>   &quot;_meta&quot;:{&quot;io.modelcontextprotocol/clientInfo&quot;:{&quot;name&quot;:&quot;my-app&quot;,&quot;version&quot;:&quot;1.0&quot;}}}}</pre><p>Everything the server needs is in the payload. Protocol version, client info, and capabilities that were exchanged once at connection time now travel in _meta on every request. A new server/discover method lets clients fetch server capabilities when they want them up front.</p><p>The practical effect on deployment is immediate: a server that needed sticky routing and a shared session store can now sit behind a plain round-robin load balancer, and run on serverless or edge infrastructure where persistent connections were never a good fit.</p><h3>The distinction that matters: stateless protocol, stateful applications</h3><p>This is the part I expect teams to get wrong, so it’s worth being precise.</p><p>Removing the protocol-level session does <em>not</em> mean your application must be stateless. It means the protocol stopped managing state on your behalf.</p><p>Servers that need to carry state across calls do what HTTP APIs have always done: mint an explicit handle from a tool — a basket_id, a browser_id — and have the model pass it back as an ordinary argument on later calls.</p><p>I’d argue this is better than what it replaces, and not just as a workaround. Session state hidden in transport metadata is invisible to the model. An explicit handle is a value the model can reason about, compose across tools, and thread between steps. State that was implicit and hidden becomes explicit and inspectable — which is also, not incidentally, far easier to debug and audit.</p><h3>What breaks</h3><p>If you maintain a client or server, this is the migration checklist.</p><p><strong>The handshake and session are gone.</strong> Any code that calls initialize, reads Mcp-Session-Id, or assumes connection affinity needs rework.</p><p><strong>Server-to-client requests are restructured.</strong> Elicitation no longer holds an SSE stream open. The server returns an InputRequiredResult carrying inputRequests and an opaque requestState; the client gathers answers and re-issues the original call with inputResponses and the echoed state. Any instance can pick up the retry, because everything needed is in the payload. Servers may now only issue requests while actively processing a client request — previously recommended, now required.</p><p><strong>New required headers.</strong> Streamable HTTP requires Mcp-Method and Mcp-Name, so gateways and rate-limiters can route on the operation without parsing the body. Servers reject requests where the headers and body disagree.</p><p><strong>Tasks moved and changed.</strong> Tasks graduated from an experimental core feature to an extension, with a redesigned lifecycle. tasks/list is removed — it can&#39;t be scoped safely without sessions. Anyone who shipped against the experimental API must migrate.</p><p><strong>Three features are deprecated:</strong> Roots, Sampling, and Logging. These are annotation-only for now — they keep working, with a twelve-month minimum before removal is even possible — but the replacements are clear: tool parameters or resource URIs for Roots, direct LLM provider APIs for Sampling, and OpenTelemetry for structured logging.</p><p><strong>Small but sharp:</strong> the error code for a missing resource changes from the MCP-custom -32002 to the standard -32602. If you match on the literal value, fix it.</p><p><strong>Authorization tightened.</strong> Clients must now validate the iss parameter on authorization responses per RFC 9207 — a low-cost mitigation for mix-up attacks that are more likely in MCP&#39;s single-client, many-server pattern. Clients also declare their OpenID Connect application_type during dynamic registration, which fixes the long-standing case of an auth server defaulting a CLI client to &quot;web&quot; and rejecting its localhost redirect.</p><h3>The operational wins nobody’s talking about</h3><p>Buried under the stateless headline are three changes that matter more day-to-day than the migration cost.</p><p>List and resource results now carry ttlMs and cacheScope, modeled on HTTP Cache-Control. Clients know exactly how long a tools/list response stays fresh and whether it&#39;s safe to share across users — no more holding a stream open just to learn a list changed.</p><p>W3C Trace Context propagation is now documented in _meta, with traceparent, tracestate, and baggage key names fixed in the spec. A trace that starts in your host application can follow a tool call through the client SDK, the server, and whatever it calls downstream, and land as one span tree in any OpenTelemetry backend.</p><p>And tool schemas are lifted to full JSON Schema 2020–12 — composition, conditionals, $ref. Worth noting the guardrail the spec attaches: implementations must not auto-dereference external $ref URIs, and should bound schema depth and validation time. That&#39;s a supply-chain and DoS consideration hiding in a schema upgrade.</p><h3>What This Means for Your Roadmap</h3><p>Breaking changes in a protocol you’ve standardized on are never welcome. But the interesting signal here isn’t the break — it’s what shipped alongside it.</p><p>A formal feature lifecycle now gives every feature Active, Deprecated, and Removed states with at least twelve months between deprecation and possible removal. An extensions framework means new capabilities can ship opt-in and stabilize before entering the spec. And a Standards Track proposal can no longer reach Final until a matching scenario lands in the conformance suite.</p><p>Read those three together and this looks less like protocol churn and more like a protocol growing governance. The maintainers were explicit that this was a clean break they don’t intend to repeat.</p><p>For planning: this is a bounded, mechanical migration — transport and lifecycle code, not business logic. The deprecation window means nothing forces your hand this quarter. But teams that migrate now delete an entire category of infrastructure they were maintaining for no product reason.</p><h3>The takeaway</h3><p>The best infrastructure changes are the ones that let you delete code. Sticky sessions, session stores, reconnection handling — that was never your product. It was scaffolding for a protocol that hadn’t grown up yet.</p><p>MCP has now grown up: stateless, cacheable, routable, traceable. Ordinary HTTP infrastructure, which is exactly what it should have been.</p><p>So the question for your team this month: how much of your MCP deployment exists only to work around a session that no longer exists?</p><p><em>References: MCP 2026–07–28 Specification and Release Candidate announcements, Model Context Protocol Blog (Linux Foundation) · MCP specification changelog against 2025–11–25 · RFC 9207, OAuth 2.0 Authorization Server Issuer Identification</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b93ba42536d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Can Write the Pull Request. It Can’t Own What Happens Next.]]></title>
            <link>https://medium.com/@yagmur.sahin/ai-can-write-the-pull-request-it-cant-own-what-happens-next-96cb33f40c71?source=rss-64864815e3a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/96cb33f40c71</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[YAGMUR SAHIN]]></dc:creator>
            <pubDate>Mon, 27 Jul 2026 15:48:42 GMT</pubDate>
            <atom:updated>2026-07-27T16:07:48.337Z</atom:updated>
            <content:encoded><![CDATA[<h4>Coding agents can generate the change, explain the diff, and prepare it for review. The harder engineering work begins after the code looks finished.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MJudKAQWLP_TQb07dVVPew.png" /></figure><p>The issue was opened at <strong>9:07 a.m.</strong></p><p>At <strong>9:14</strong>, an AI coding agent submitted a pull request.</p><p>The implementation looked complete. The description was polished. The modified files were summarized. The reasoning was clear.</p><p><strong>Seven minutes from ticket to review.</strong></p><p>It looked like extraordinary productivity.</p><p>But the pull request did not answer the questions that matter most:</p><ul><li>Which systems are affected?</li><li>What new failure modes exist?</li><li>How will the change be observed in production?</li><li>Can it be reversed safely?</li><li>Who owns the consequences after merge?</li></ul><p>The agent produced the code.</p><p><strong>It did not inherit the responsibility.</strong></p><h3>A Pull Request Is Not the Engineering Decision</h3><p>Coding agents can inspect repositories, interpret issues, modify multiple files, run tests, update documentation, and respond to review feedback.</p><p>That is a meaningful advance.</p><p>But an AI-generated pull request proves only that a model found a plausible path from an instruction to a code change.</p><p>It does not prove that the change belongs safely inside the larger system.</p><p>The code may be correct within the repository and still be incomplete in production.</p><p>A timeout change can increase downstream queue depth.</p><p>A retry policy can multiply load.</p><p>A schema update can make rollback unsafe.</p><p>A permission change can work for direct access but fail under delegated execution.</p><p>A modified API can break consumers the agent never inspected.</p><blockquote><strong><em>Software risk does not scale with line count. A small diff can create a large operational consequence.</em></strong></blockquote><h3>The Missing Output Is Engineering Evidence</h3><p>AI-generated code should not arrive as a diff alone.</p><p>It should arrive with evidence that the organization can understand, release, operate, and recover from the change.</p><p>That evidence should answer five questions.</p><h3>1. What Is the Intended Outcome?</h3><p>What problem does the change solve?</p><p>Which requirements were explicit?</p><p>Which assumptions were made?</p><p>A technically clean implementation of the wrong interpretation is still the wrong change.</p><h3>2. What Is the Blast Radius?</h3><p>Which services, consumers, schemas, permissions, queues, workflows, and data contracts may be affected?</p><p>What happens under latency, duplication, stale state, partial failure, or out-of-order execution?</p><p><strong>Review should follow system impact, not change size.</strong></p><h3>3. How Will the Change Behave in Production?</h3><p>What signals confirm that it is working?</p><p>What signals expose degradation, retry storms, stuck workflows, silent data corruption, or downstream failure?</p><p>A change that cannot be observed cannot be responsibly operated.</p><h3>4. How Will the Organization Recover?</h3><p>Can the feature be disabled?</p><p>Can the code be rolled back without damaging state?</p><p>Is the migration backward compatible?</p><p>Are compensating actions available for irreversible operations?</p><blockquote><strong><em>A change is not production-ready because it can be deployed. It is production-ready when it can fail safely.</em></strong></blockquote><h3>5. Who Owns It?</h3><p>Who can explain the architectural decision?</p><p>Who responds when it fails?</p><p>Who maintains the next version?</p><p>Without a clear owner, AI does not automate engineering.</p><p><strong>It automates the creation of orphaned responsibility.</strong></p><h3>AI Makes Engineering Judgment More Important</h3><p>Coding agents reduce the cost of implementation.</p><p>They do not reduce the cost of understanding, verification, operations, or accountability.</p><p>The strongest engineering organizations will not be defined by how many pull requests their agents generate.</p><p>They will be defined by how confidently they can evaluate, constrain, release, observe, and reverse those changes.</p><p>Engineering work moves higher in the consequence chain:</p><ul><li>From producing code to defining intent.</li><li>From reviewing syntax to evaluating system behavior.</li><li>From shipping changes to controlling impact.</li><li>From asking whether the code works to asking whether the system remains understandable, recoverable, and safe.</li></ul><h3>The Merge Button Is an Accountability Decision</h3><p>A coding agent can write the implementation, run the tests, explain the diff, and revise the change.</p><p>It cannot become accountable to the users, teams, and institutions affected by the result.</p><p>That responsibility remains with the engineering organization.</p><p>The future of software development will not be determined by whether AI can generate more pull requests.</p><p>It will be determined by whether teams can produce enough engineering evidence to merge them responsibly.</p><p><strong>AI can write the pull request.</strong></p><p><strong>Engineers must own what happens next.</strong></p><h3>Before your team allows an AI agent to merge without human review, what engineering evidence would you require?</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96cb33f40c71" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>