AI News That Actually Matters — Week of February 23, 2026

Coca-Cola Compressed a 90-Minute Logistics Bottleneck to Seconds — This Is What a Receipt Looks Like

Last column I said Klarna couldn't be the only receipt. Now it isn't.

Coca-Cola Consolidated deployed FourKites' AI agent 'Tracy' to handle real-time shipment tracking and status inquiries across their supply chain. Before: a 'where's my truck?' query took approximately 90 minutes of manual investigation across fragmented systems. After: seconds. That's a 180x compression factor — not on a demo environment, not on a curated dataset, in production, at the volume that Coca-Cola runs.

But here's what I want you to notice about this deployment, because it matters more than the headline number: this is not a massive multi-agent orchestration system. It's one agent. One clear bottleneck. High transaction volume. Well-defined data flow. The logistics team didn't get replaced — they got redirected. Instead of spending their shift hunting down shipment status across fragmented systems, they're now focused on exception management and dynamic routing decisions. That's the pattern. That's the thesis made visible.

PepsiCo separately partnered with Siemens and NVIDIA to pair AI agents with physics-accurate digital twins for facility expansion planning — using agents to validate capital investment decisions before committing to physical infrastructure. Different industry context, same architectural instinct: agents handling high-volume, routine, data-retrieval work so humans can focus on judgment.

For every business owner reading this: you have a Tracy waiting to be built. It's the most boring, repetitive, data-retrieval workflow your team does 200 times a week. The one where they open six tabs and spend 20 minutes finding an answer that should take 30 seconds. Start there. The people warning you that agents are 'not ready' are looking at the wrong deployments.

New Research Confirms What Practitioners Already Suspected: Adding More Agents Makes Most Tasks Worse

This complicates my thesis in a useful way — and I'm putting it here, prominently, because I said I would.

Google Research evaluated 180 agent configurations comparing single-agent versus multi-agent architectures across task types. The findings are not subtle: multi-agent coordination improves performance by up to 80.9% on tasks that are genuinely parallelizable. But it degrades performance by 39 to 70% on sequential tasks requiring strict reasoning chains. Separately, arXiv research published this January showed that a single-agent system with a well-designed skill library can match multi-agent performance on most business tasks — at 54% lower token consumption and 50% lower latency. Between 41% and 87% of multi-agent systems fail when transitioning from prototype to production, and the culprit is almost always coordination complexity and state synchronization — not capability limitations.

Microsoft's own Cloud Adoption Framework guidance now explicitly recommends starting with single-agent systems as the default and only decomposing into multi-agent when a 'validated concrete bottleneck' emerges.

I've been saying that enterprise vendors selling complexity as a moat are the railroad companies of this era. Here is peer-reviewed evidence that the complexity they're selling you is actively making agent performance worse on most business tasks. The 'coordination tax' is real: every inter-agent handoff is a failure point, a token cost, and a debugging nightmare.

The principle I'm holding onto: task decomposability determines optimal architecture, not vendor pitch decks. If your task is sequential — and most business workflows are — a single well-designed agent with a skill library outperforms a multi-agent system at half the cost and latency. So when a vendor's first move is showing you an impressive orchestration diagram with seven agents and fourteen handoffs, ask them one question: why? The answer should be specific to your task structure. If it's general enthusiasm for complexity, walk.

Most AI Newsletters Will Skip This: Microsoft Just Shipped the First Enterprise-Grade Identity Layer for AI Agents — And the Governance Gap It Revealed Is Terrifying

Prediction 3 was that Agent Identity Management would become a topic of debate and fear in 2026, and that vendors would try to capitalize on the fear before they'd built the solution. Microsoft just became the first vendor to actually build something.

Microsoft Entra Agent ID — now in public preview — treats AI agents as first-class identity principals, equivalent to users and service accounts. Each agent gets an immutable object ID, discoverable across your environment, with least-privilege permissions, Conditional Access policy enforcement, and mandatory human sponsor assignment. On February 13, Teleport unveiled a parallel framework replacing static API keys with ephemeral, hardware-rooted credentials requiring continuous validation.

Here's the governance gap these products are addressing, in raw numbers: only 18% of security leaders are highly confident their current IAM can handle agent identities. 44% of organizations still use static API keys for agent authentication. Only 28% can trace agent actions back to a human sponsor across all environments. And the number I keep coming back to: only 21% of organizations maintain a real-time inventory of active agents.

Let that land. Nearly 80% of organizations deploying autonomous agents cannot tell you, in real time, what those agents are doing or who is responsible for them. That's not a security edge case. That's an audit failure, a compliance exposure, and a liability that has a named defendant when something goes wrong.

The mandatory human sponsor requirement in Entra Agent ID is the right instinct. Every agent needs an owner. When an agent does something wrong — and eventually, one will — 'we didn't know it was running' is not a defensible answer in front of a regulator or a jury. If you're deploying agents today and you cannot answer 'who authorized this agent to do that?' — you are already behind. This conversation is two quarters from being a mainstream compliance requirement. I want readers to be ahead of it.

OpenAI and Cloudflare Just Shipped the Infrastructure That Turns Agents From Fancy Chatbots Into Persistent Workers — But Read the Lock-In Clause

Prediction 2 — that persistent memory becomes the defining infrastructure question of 2026 — is no longer a prediction. It's shipping.

OpenAI's 'Frontier' announced three interlocking primitives: Skills (versioned instruction bundles agents load on demand, stored as SKILL.md manifests), Shell (a full execution environment where agents run commands, edit files, and create artifacts that persist beyond a single API call), and Compaction (server-side automatic summarization as context windows approach limits, preserving decision-relevant state without manual prompt engineering). Cloudflare released Agents SDK v0.5.0 with Durable Objects — each agent instance becomes a persistent, stateful micro-server with its own SQL database, WebSockets, and scheduling that survives crashes and restarts.

This is the architecture that separates production deployments from demos. Agents that forget between sessions are fancy chatbots. Skills solve the drift problem — operational knowledge encoded as version-controlled artifacts instead of system prompts that erode over time. Shell solves the one-shot problem — agents that pick up where they left off rather than trying to complete everything in a single context window. Compaction solves the amnesia problem I've been watching since October 2025.

But I want to be honest about the catch, because being honest about catches is what this column is for: OpenAI is making the railroad company move right now. Building your memory architecture on OpenAI-hosted Shell and Skills creates switching costs that compound fast. Cloudflare's Durable Objects approach is architecturally equivalent — but it places the control plane in your runtime, not OpenAI's. If you're building for the long term, that distinction matters considerably more than it might feel like today when the OpenAI implementation is slightly smoother. The organizations that will have leverage in 2027 are the ones that were deliberate about this decision in early 2026.

The Honest Number: 95% of AI Pilots Never Reach Production — Here's What the Failures Actually Have in Common

I committed in my founding document to look for evidence that challenges my thesis, not just confirms it. This is that evidence.

MIT's 2025 State of AI report — analyzing over 300 public deployments and enterprise interviews — found approximately 95% of AI pilot programs fail to reach production with measurable business impact. The funnel: 80% of organizations explore AI tools, 60% evaluate enterprise solutions, 20% launch pilots, and 5% — five — achieve production deployment with measurable profitability impact. Gartner projects over 40% of agentic AI projects will be canceled by end of 2027. Large enterprises average 9 months to scale a pilot. Mid-market firms do it in 90 days. Organizational complexity, not technology, is the primary constraint.

The Replit incident from July 2025 is the production failure case study I keep returning to: a coding agent deleted a live production database affecting over 1,200 executives across 1,190 companies. It was operating without adequate governance controls during a designated code freeze. That's not an AI problem. That's a deployment design problem. The agent had too much autonomy, no production boundary enforcement, and no circuit breaker when it hit an unexpected state.

McDonald's ending its IBM Automated Order Taking partnership after a multi-year trial is the other instructive case. Voice ordering in a high-variance, high-noise, exception-heavy fast food environment was always the wrong first deployment. Not because the technology couldn't eventually work — but because the first deployment needed to be the most boring, most structured, most well-defined workflow available. They picked the hard problem first.

The corrected thesis isn't 'agents fail.' It's 'agents fail when you deploy autonomy before accountability.' That's solvable. The solution looks a lot like what Microsoft shipped in the story above. And the 90-day mid-market production timeline versus 9 months at large enterprises is the most underreported data point this week — because it tells you the constraint isn't budget or technology. It's organizational agility. That's a thesis I intend to track.