Almost no other company works this way, and most of them have the opposite problem. Their people are using AI constantly, asking ChatGPT to rewrite emails, using Claude to reason through customer issues, running coding agents against repos, quietly building small workflows that save hours. And almost none of it is visible to anyone else.

A good prompt disappears into one person’s chat history. A clever correction stays inside one employee’s browser tab. The workflow your best operator nailed last month gets rebuilt from scratch by a new hire who never knew it existed. A senior person figures out how to load context, challenge the model, and review what comes back, and the junior across the team never gets to watch how any of that judgment works.

The result: individuals get smarter, the company does not.

That is the missing layer in most AI adoption plans. Companies are buying tools, writing acceptable-use policies, measuring logins, running the occasional training session. None of it touches the actual problem, which is that your best AI work is invisible to everyone who could learn from it. So every quarter, the same lessons get rediscovered from nothing. You are paying tuition on the same lesson over and over, across hundreds of people, and the bill never stops arriving.

Shopify’s answer is not surveillance. It is not scraping everyone’s chat history and calling it knowledge management. It is something smaller and far more useful: a deliberate way to make non-sensitive AI work visible enough that the people around it can actually learn. The agent that produced those numbers runs only in public. That single design choice is the whole game, and any team can copy it.

Here’s what’s inside:

• What Shopify actually built. Not the AI mandate everyone argued about, but the design choice underneath River, the agent that runs in public and turns one engineer’s judgment into the whole team’s.

• Why a prompt library will not save you. The most valuable part of AI work is the part a prompt library cannot hold, and what you have to make visible instead.

• Where to draw the line. A workflow-by-workflow boundary for regulated and sensitive work, so you capture the learning without exposing anything that should stay private.

• The room, the rules, and the one constraint that makes it work. A setup any team can run in ninety minutes, the metrics that actually signal learning, and the single binding rule that bends a team toward sharing instead of hoarding.

• How to bring this into your org. A three-part prompt kit: one that turns a messy AI session into a post your team can learn from, one that draws the line between what’s safe to share and what stays private, and one that helps your senior people model real work in public without it feeling staged.

Private AI work helps the person at the keyboard. Public AI work helps the company learn. That difference is small today and decisive in a year.

Read more

In the same conversation, I heard the opposite version of the same story. A user launched a training-data export job and went to sleep. The job hit a blocker. Instead of waiting for a platform engineer to notice a support ping, the agent inspected several internal systems and found a small bug several layers down. By morning, the job was done.

Those two examples belong together. They show both sides of the frontier. Agents are now useful enough to participate in real operational work. They’re also capable enough to create real operational risk.

That’s the next AI bottleneck. Not whether people use agents, or whether agents can code, or whether the next model wins a benchmark. We’re already past those questions. The real question is what happens when the work starts moving faster than the controls around it.

This came into focus in a recent conversation with Emma, who leads data infrastructure engineering at OpenAI. Her team sits near the bottom of a very large stack: the analytics, streaming, and data infrastructure that almost every other team eventually depends on.

That vantage point matters. If you’re on an application team, you mostly see whether agents help you build faster. If you’re on a platform team, you see what happens when everyone above you starts building faster.

Agents make work happen faster. They don’t make it safer at the same rate.

Here’s what’s inside:

• Agents crossed into operations. They’re not writing code for humans to paste anymore. They run release loops and build features end-to-end while a human watches.

• The work lands somewhere. When app teams accelerate, platform teams inherit the operational burden nobody budgeted for.

• Platform agents play by different rules. Same model, very different blast radius, and the tooling most companies have doesn’t know the difference.

• The practical control layer. Four things that let you absorb agent-created work without becoming the permanent bottleneck everyone routes through.

• The eval discipline most companies skip. A cheap way to know when an agent is ready for more autonomy and when to pull it back.

• Two prompts that build the documents. A private eval suite and a tiered action-class policy, both built from your own systems, not a template.

Let me show you where this is headed, and what to do about it.

Read more

The fiscal third-quarter 2026 numbers fill in the picture: Microsoft reported $31.9 billion in capital expenditures for the quarter and guided to more than $40 billion in the next. About two-thirds of that quarterly spend went to short-lived assets, primarily GPUs and CPUs. Even after all of it, the company expects to stay capacity constrained at least through the year.

No classic software company looks like that. A classic software company writes code once and sells it many times, and its biggest worry is talent or distribution, not whether it can physically build enough capacity to meet demand. The cloud was supposed to make infrastructure someone else’s problem.

AI breaks that abstraction.

The most important thing to understand about the current AI buildout is that tokens are not magic. They are manufactured. Every answer from a model is the output of a physical production system that consumes chips, high-bandwidth memory, advanced packaging, substrates, optics, power, cooling, land, data-center construction, networking, and operations talent. When it works, a user sees a paragraph, a line of code, a summarized contract, or an agent completing a task. Behind the screen, a factory is turning electricity and silicon into intelligence.

This is why AI is turning big tech into an industrial business.

Calling AI industrial is not new. Mary Meeker built a 340-slide deck around it. Jensen Huang says a version of it on every NVIDIA earnings call. What is new is what Microsoft’s number does to the contract sitting on your desk. Six months ago, an AI vendor agreement was structured like a software agreement. Now that the hyperscalers are spending at this scale and still rationing capacity, your AI vendor agreement is a supply contract in everything but name. It has allocation. It needs capacity terms. It needs a fallback. None of that was a line item a year ago.

If that sounds like a problem for the CFO and no one else, consider that my own token spend ran close to 500 million tokens last week. Multiply that across a team and the capacity question stops being abstract.

The visible product is still software. ChatGPT, Copilot, Gemini, Claude, Meta AI, and Bedrock all look like applications or APIs, but the constraint underneath them is physical. The strategic question is no longer only, “Who has the best model?” It is, “Who can operate the factory that produces intelligence at scale?”

This briefing covers:

• The bill of materials behind every token. Chips, memory, packaging, power, cooling, construction, and how to tell which one stops your vendor cold before it stops you.

• Why your vendor contract is now a supply contract. What to actually ask for when the cloud you buy from is competing with you for the same chips: allocation, fallback, reserved capacity, written down.

• Your CFO is about to inherit a capital cycle. Why utilization is suddenly the metric that matters, and why a 40% throughput gain beats a new data center.

• Seats are the wrong unit, and almost every plan still uses them. How to forecast in tokens instead, and why an agent that runs for hours belongs in a different budget line than a chatbot that answers questions.

• The one question that decides whether AI helps your margins or wrecks them. It is not whether tokens are expensive. It is something more specific, and most companies have never asked it.

• Three instruments to run before the budget meeting. A vendor audit that maps the supply chain under your contract and hands you the language to demand, a forecasting model that sizes demand in tokens instead of seats, and a routing diagnostic that finds the workflows burning premium inference on cheap work.

Microsoft has already put $190 billion behind this view of the world. Most companies have not put it into their AI plans at all. What follows is what changes once you do.

Read more

The model has been handed a strategy doc, two slightly different versions of the operating plan, a transcript with two meetings in it, and a deck that no longer matches reality. It is asked to write a memo. To do that, it has to do two jobs at once: figure out what the project actually is, then produce the artifact. The first job is the hard one. The second job is the one that shows up in the draft.

A sharper prompt won’t fix this. You need to prepare the room first.

I recently worked on a project where the real work did not live in one place. A strategy doc, meeting transcripts, a budget spreadsheet, trip-planning notes, org-design drafts, old PDFs, follow-up emails, half-finished notes. Some clearly current. Others superseded. A few useful only because they showed how the thinking had changed.

The useful first prompt was much more boring than “write the plan.” It was something like: help me build the room. Find the relevant materials. Preserve the originals. Make an inventory. I needed to know which files were authoritative, which were duplicates, which were old, which were missing. I asked it to summarize each source before synthesizing across them, and explicitly told it not to write the final deliverable yet.

Only after that did the writing prompt become simple. Use the current operating plan for the numbers, the transcript for decision context, the older PDF only as background, and flag unsupported claims rather than smoothing them over. The room made those distinctions visible before the writing started.

This kind of workflow was not really available a year ago. Agents could draft, summarize, and answer questions, but they were uneven at walking a folder tree, opening files in sequence, comparing dates across documents, and inspecting metadata without losing the thread. In the last few months that has changed. The current generation of agents is good at the small, boring, file-level operations the work actually requires. Which means the bottleneck has moved. It is no longer “can the model produce the artifact.” It is “is the source set in shape for the model to do anything useful with it.”

Here’s what’s inside:

• What is an AI project room. What a bounded workspace looks like for one serious job, and which tools to use for which source types.

• Why AI fails with messy source files. Why serious work fails when you skip the preparation step and jump straight to generation.

• How to build an AI source inventory. How to build the artifact that makes everything downstream inspectable.

• Summaries, duplicates, and missing context. The three preparation layers that prevent bad synthesis before it starts.

• The writing prompt, once the room exists. What changes when you draft from a clean work surface instead of a raw file dump.

• Grab the four prompts. A room-builder for file-system tools, an inventory-and-audit for uploaded docs, a grounded-draft prompt that cites every claim back to a source, and a refresh prompt for when new files arrive.

Let’s build the room.

Read more

Most people are still prompting like it’s November, and the model on the other end stopped being the same machine months ago.

Opus 4.7 and GPT-5.5 landed in the last two months. The agents built on top of them now run for hours on a single request — they edit files, search archives, write code and test it, and come back with something close to a finished artifact. That capability jump is the largest single move I have watched in two years of doing this work. Our prompting has not moved with it.

When I look over people’s shoulders, I see the same kinds of requests I saw last September going into a system that is a hundred times more capable. The output comes back polished and mostly useless, and the person at the keyboard concludes the model is mediocre. That is almost never what is actually happening. The assignment is mediocre, and the model is just being honest about it.

The shift is from prompting to briefing. Last year, the best advice was to talk to AI like a careful junior employee who needed every step spelled out, every format specified, every structural decision made for them. That advice was right for the models we had, and those models needed it. The models we have now do not. A senior partner needs the goal, the context, the constraints, and the quality bar, and then they need room to push back. An agent running on 4.7 or 5.5 works the same way, and most of the leverage in the new models lives in that gap between what you tell a junior and what you tell a senior.

A prompt is something you type into a box. A useful question is the same thing done seriously — work made legible enough that another intelligence can act on it.

Here’s what’s inside:

• The senior-partner shift. What actually changes about your request when you stop prompting and start briefing.

• The generic output trap. Why polished, useless AI work is almost always a mirror of the assignment, not the model.

• The six-field brief. The template that turns a vague ask into something an agent can run with for hours without drifting.

• The same brief, for humans. Why this makes you a clearer manager, a sharper colleague, and easier to work with than most of your team.

• Three prompts that earn their keep. The brief builder for when you do not know how to start, the thin-ask detector for the request you suspect is too vague to send, and the finish line for work that keeps almost being done.

The brief and the prompts are below. So is the part most people miss: get good at this with the agent and you get better with the humans too.

Read more

The model is one piece of the agent economy. The control layer is the other.

The control layer is the set of infrastructure decisions that determine whether a model’s output is allowed to act in the world. Where does the agent live. What state does it remember. Who is it acting for. When does it need approval. What can it spend. Who can stop it. None of those questions get answered by a model. They get answered by the companies sitting between the model and your production system, and the last six weeks have made it obvious who they are. Cloudflare ran Agents Week. Stripe expanded its Agentic Commerce Suite. Okta launched Okta for AI Agents and expanded it again this month. Auth0 has been publishing AI Agents docs. Datadog has been turning LLM observability into something that looks a lot more like an agent control plane than a logging product.

I’ve covered the protocol stack already — the six protocols that emerged and the three that decide which agents survive. This piece is about the operators sitting above the protocols. The companies turning agentic behavior into controlled, permissioned, auditable infrastructure. The companies your security review is about to discover the hard way.

Here’s what’s inside:

• The seven-row control map I would put in front of any agent proposal before it touches a production system, and the one question per row that flushes out the gap.

• Why Cloudflare, Auth0, Snowflake, Stripe, and Datadog are becoming the operating system of the agent economy, and what each one is actually trying to own.

• The kill switch most teams do not actually have, even though they think they do — and the five layers it has to be implemented at to be real.

• A real data leader’s failure mode, live this quarter: her agents are routing around the human permission structure, and she now owns three questions she did not yet know how to answer.

• The three prompts paid subscribers get this week. A control-map fill-in for the agent your team is most likely to ship this quarter, a pressure-test for the next vendor pitch on your desk, and a five-layer kill-switch audit for the agent that actually scared you.

The boring layer is where the power is moving. Let me walk you through the map.

Read more

The instinct is to ignore the acronyms and wait for the big platforms to absorb everything behind product surfaces. The platforms will absorb a lot of it. But the protocols are not all trying to solve the same problem, and the substrate an agent is built on shapes the customer experience more than the model choice does. Read as a pile of competing standards, the picture stays blurry. Read as layers, three of them snap into focus as the foundation most builders will actually depend on.

Three protocols are forming the core agent stack: MCP for the tools and data an agent can reach, A2A for the other agents it can delegate to, and AG-UI for the controls a human needs to stay in the loop while long-running work is happening. Those three answer the only three questions every real agent system hits within its first week of existence. What can the agent use. Who else can the agent work with. How does the human stay in control. A2UI, AP2, and x402 matter, but they sit in layers where product requirements, trust boundaries, payment rails, and platform incentives are still being negotiated. Treating those three as equal bets with the first three is the most common mistake I see in agent strategy decks right now.

Builders who try to bet on all the layers at once end up paralyzed. Builders who ignore the layer map ship agents that fail at the boundaries that actually matter, like security on tool access, approval on long-running work, and supervision when the agent crosses company lines. Buyers who cannot read the layer map cannot evaluate what they are actually purchasing when a vendor says the word “agent.” The map is the closest thing the industry has to a shared vocabulary, and the next twelve months of agent product strategy will run through it.

Here’s what’s inside:

• The protocol map. A single table that places all six protocols in the layer they actually occupy, so the acronyms stop blurring together.

• The core stack: MCP, A2A, AG-UI. Why these three are converging into the universal foundation, what each one is really for, and where each one fails if treated as a feature toggle instead of a boundary.

• Why payments are not one protocol. AP2 and x402 solve different problems, the payment space carries hidden assumptions about geography and authorization, and “agent can pay” is not a button — it is an audit problem.

• Map, draft, audit, brief. Map any real workflow to the layers that matter, draft the Agent Card boundary another team will integrate against, audit a workflow for the human controls it’s missing, and produce the strategy brief for the leader making the platform bet — four prompts, one per job, with renewal prep as the worked example threaded through.

The acronym pile will keep growing. The layer map will not.

Read more

The content workflow is not where I would start. Neither is the lifecycle automation stack, and I would not waste an early conversation asking whether the team is on ChatGPT, Claude, Jasper, Canva, Midjourney, Clay, HubSpot Breeze, Salesforce Agentforce, or some agentic Frankenstein the growth team duct-taped together over a long weekend. Those questions answer themselves once you know what the team is responsible for.

I would start with a more basic question, the kind that determines whether everything downstream is sane:

Does this company understand that marketing now has two audiences?

Most leadership teams think they already know the answer. Almost none of them have internalized what it means. Marketing now serves two audiences at once. It serves the humans it has always served, and the agents that increasingly read, summarize, compare, and recommend on behalf of those humans before any human decision gets made. Companies that miss the split lose on both sides.

The losses are already showing up in the data. In a March 2026 survey of 1,076 B2B software buyers, sixty-nine percent reported choosing a different vendor than they originally planned because of guidance from an AI chatbot, and roughly a third bought from a vendor they had never heard of before the assistant surfaced it. That is not the work of better marketing. It is the work of a comparison system that read the public surfaces, weighed them against each other, and produced a shortlist — one that often did not include the buyer’s original preferred vendor.

I’m starting a series on what I would do walking into a job today across the functions AI is reshaping. Marketing first, because I spent a long stretch of my career in and around it. Most of the AI-marketing conversation right now is about tools and adoption curves. This piece is about what the job has to become.

Here’s what’s inside:

• The two audiences, and why most companies serve only one. What agents need is not a better tagline. It’s legibility, and legibility is a different job than persuasion.

• The “make more stuff” trap. Why an AI strategy built around content velocity puts your career on the most commoditized layer of the role.

• The truth layer. Why marketing has to become the steward of the company’s claims, proof, and product reality, not the decorator of decisions made elsewhere.

• Why AI-washing is a trust-debt loan. What happens when companies (and candidates) stretch their AI story past what they can defend, and why the agents catch it first.

• What to look for in a marketing role in 2026. The questions to ask before you take the job, and the surfaces marketing has to be allowed to touch.

• The AI-washing audit. A skill pack for Claude Desktop, Claude Code, ChatGPT, and Codex that builds your company’s truth layer from the ground up — diagnosis, claims-and-evidence map, AI-washing risk register, and a prioritized fix list.

Let me show you what the split looks like, why most companies are sitting on the wrong side of it, and what the marketers who win the next decade will be doing differently.

Read more

Most teams treat this as an AI question. That ends up costing time, money, and the work itself. It is a work-shape question. The right answer depends less on how impressive the model demo looked and more on the structure of the work in front of you: how often it repeats, how costly a mistake is, how much judgment it needs, and whether near-term model improvement is about to collapse what you are about to build.

Shopify gave the market one version of this question when Tobi Lütke told teams they had to show why they could not get something done with AI before asking for more headcount. It stopped hiring from being the default answer to every capacity problem. But “can AI do this?” is the wrong question to stop at.

Executives are running a capital allocation problem, not a technology question. How you allocate capital has always defined what a firm can accomplish, and the upside variance on AI investment right now is wider than most leaders have ever priced for. Pick the wrong motion for a workflow and the cost is not only the wasted spend. It is also the upside you never captured because the capital landed in the wrong place.

The wrong answer is expensive in both directions. If you hire against work that AI can already handle, you build a cost structure around disappearing scarcity. If you automate work that depends on trust and judgment, you break the business process at the point where the human mattered most. If you buy a generic tool for company-specific work, you spend months fighting the product. If you custom-build something the market has already solved, you burn scarce builders on infrastructure that should have been a line item. If you wait on a workflow that is already stable and costly, you let delay masquerade as prudence.

Gartner has put a number on it: more than 40% of agentic AI projects are forecast to be canceled by the end of 2027 because of cost, unclear business value, or inadequate risk controls. Classify the work before the spending starts.

This briefing covers:

• The decision starts with the work. A six-dimension scoring framework that routes each workflow to the right investment motion.

• When to automate, build, buy, hire, or wait. Real company examples (IBM, Klarna, Stripe) showing how the shape of the work determines the answer.

• The matrix. A two-axis visual that maps market maturity against company specificity, with named examples in every cell.

• The executive job is changing. Why routing logic is the new leadership skill, and what happens when executives and builders have the conversation together.

• Four prompts that route AI investment. A decomposer that turns a function into scoreable workflows, a scorer that writes the budget memo, a pressure test that forces three counter-arguments before capital commits, and a describability gate that holds automation projects until eight fields are filled.

Classify the work first. The investment motion follows.

Read more

I sat down with Tibo, who leads Codex at OpenAI, to ask what changes for companies now that the model can do the work. I’ve written about this a few times since GPT-5.5 and Codex dropped in late April: the bottleneck has moved twice. The first move was from “the model can’t do the work” to “the model can’t do the work the way our team would do the work” — the workflow-packaging problem, which I covered last week. The second move does not land in a workflow file at all. It lands in five different leadership chairs across the company, and each of those chairs has to develop a new instinct that almost nobody is teaching. Our conversation kept circling back to a single organizing point: the model is good now, and the question that matters has shifted to where you put the human judgment around it. What follows is my attempt to write down the takeaways from that conversation and push the framing further than we got to in the room.

I’ve been thinking about what happens to companies that skip this layer. Some will over-restrict to the point that the agents are useless and the team works around them. A smaller number will under-restrict and end up with an incident that turns into a board-level event. The companies that do the quiet work of building the five layers will look unremarkable for two quarters and then will be impossible to catch. Watching who joins that last group is going to be one of the more interesting things to track over the next year.

I’m going to walk through a practitioner template that’s already running this way, the five chairs, and the work each one has to do this quarter. Let’s go.

Read more

That model just cracked.

Salesforce booked $800 million in agent revenue last quarter, up from $540 million the quarter before. Its CRO Miguel Milano told analysts, “We have found the formula to monetize AI.” Microsoft added a separate $15-per-user license for agent governance, sitting alongside the $30 Copilot seat. SAP put hard limits on which agents are even allowed to call its APIs. ServiceNow, Workday, Zendesk, HubSpot, and Atlassian each added their own meter under their own name.

Your next SaaS renewal will price two things: who logs in, and what work moves through the system. If you walk in counting seats, you’ll sign for the headcount you already have and pay for the agent work on top. Once usage is embedded in customer workflows, support deflection numbers, and the finance close, the negotiating position flips. The vendor knows the work has moved. You know turning it off would hurt.

Here’s what’s inside:

• The eight-vendor pattern. What each one calls its agent meter, and which one your renewal will hit first.

• The hybrid model most companies will land on. Why Microsoft’s three-layer stack is probably the template.

• Fair license vs. rent-seeking. Nine traits that separate a defensible meter from a vendor capturing the AI efficiency.

• The negotiation list. What to ask at renewal, and the one question most vendors will try to dodge.

• Two prompts to run before you renew. A system touch map for builders before procurement reviews it for them, and a vendor-specific question sequence for CFOs walking into renewal.

But first, the seat stays — even as the meter changes. Then we’ll look at how each vendor is pricing the work, and what to ask before you sign.

Read more

That target tells you something. The hard part of enterprise AI is no longer buying access to a powerful model. Any company can approve ChatGPT Enterprise, Claude, or Gemini, buy seats, call an API, and produce impressive internal demos. None of that proves the company has actually changed how support tickets move, how invoices close, how compliance reviews happen, or how customers get served. Value shows up when the model has a specific role in a specific workflow, with the right data, permissions, review process, and success metric. That work is what most companies haven’t built. In the last few months, agents have gotten reliable enough at running entire workflows that the distance between companies that have built it and companies that haven’t is starting to compound.

That’s why Anthropic, OpenAI, Blackstone, Hellman & Friedman, and Goldman Sachs are all making moves right now. The implementation layer has become the strategic layer in enterprise AI. There are trillions of dollars in workflow value waiting on whoever figures this out first, and the companies that already understand this are about to pull further ahead.

Here’s what’s inside:

• What’s actually new about the Anthropic deployment company. Why the mid-market target and PE backing signal a shift from model sales to deployment capacity — and what private equity sees that the market doesn’t.

• What “implementation architecture” actually means. The technical and operational work that separates AI experiments from production workflows.

• The risk: services that don’t turn into product. When field work compounds into reusable assets versus when it stays bespoke.

• What this means for startups, buyers, and builders. Where narrow, deep ownership beats generic AI productivity plays — and the specific move each one should make next.

• The implementation architecture audit. A prompt that scores your AI product against the six components, tells you whether you own a workflow or decorate a model, and surfaces the two questions that will end your next enterprise deal.

Let me show you how the pieces connect, and what the next phase of enterprise AI actually requires.

Read more

A vector database can find text semantically related to a question. Useful, but nowhere near enough. Agents need the current account record, the user’s permissions, the controlling policy, the right section of a long document, the table behind a metric, the prior decision from a meeting, and the source trail that lets a human reviewer reconstruct why the agent did what it did. When the system doesn’t prepare that context, the model improvises — and the cost shows up everywhere except the place you’re looking. Wrong refunds get issued. Stale policies get cited. Outdated metrics make it into board decks. The agent burns tokens and wall-clock time rebuilding context every run, and when the answer finally lands, it lands confidently — which is the most expensive way to be wrong. That’s the new RAG problem — not a retrieval problem, an assembly problem.

So the next move isn’t “vectors versus something else.” It’s that vector search is quietly getting demoted from the whole architecture to one component inside a broader knowledge layer for agents — a layer that includes retrieval, but also document structure, semantic data models, access control, provenance, memory, and write-back. I want to be careful not to overstate this: vector search isn’t going anywhere. But the conversation about where the real work happens has moved.

Here’s what’s inside:

• Why classic RAG worked — and where it stops working. How to spot the moment your retrieval architecture became the bottleneck instead of the solution.

• What Pinecone, PageIndex, SAP, and Dremio are all saying. Four different companies, one shared shift in what “retrieval” actually means for agents.

• The practical architecture. Seven questions to test whether your knowledge layer can support a production agent.

• What could go wrong. Where this new architecture quietly breaks, and how to tell if you’re overbuilding.

• How to put this to work. A Retrieval Contract Spec, a Failure Triage, and a Stack ADR: paste-ready artifacts for the three states a builder hits when working on retrieval.

Let’s walk through how this shift is playing out across the stack, and what it means for how you build.

Read more

Agentic commerce breaks that structure.

Software is starting to hold wallets, sign authorizations, and pay merchants directly. Some of those agents are spending your money. Some are spending your company’s. Some are spending your customers’. When one of them sends money to the wrong place — and one of them will — someone is going to be left holding the bag. Protocol camps are fighting over who that someone is.

The question stops being “can the customer pay?” and becomes “how does everyone know the agent was allowed to do what it just did?” That question reaches well past checkout. It touches identity, authorization, fraud, payment credentials, settlement, refunds, liability, data rights, and the merchant’s relationship with the customer. The old purchase bundle comes apart, and the market isn’t converging on a single replacement. It’s splitting into protocol camps, each owning a different piece of what used to live behind one click.

That’s the split. A fight over where commercial trust lives, not over a single button. And it will shape who keeps the customer, who carries the loss, and who gets to write the rules of online buying for the next decade.

Here’s what’s inside:

• The first round of the fight is already over. OpenAI and Stripe shipped Instant Checkout in September. Five months later it was scaled back, while Shopify and Google’s counter-protocol gained ground.

• Authorization is not payment. The evidence layer agentic commerce needs, why it has to outlive the transaction, and the two routes Google and Stripe are taking to build it.

• The stablecoin case that holds up. Software paying software is a different business problem than a person buying shoes, and the rails should be different too.

• Where this lands and who owns which layer. Why AWS quietly matters most, and what every kind of builder, merchant, and operator should do now.

• Two prompts to expose your own gaps. A responsibility-layer audit that forces you to name who owns each piece of an agentic purchase in your product, and an authorization spec that finance and legal will actually accept.

The split started a year ago. Start with Instant Checkout: how OpenAI and Stripe launched it, and why OpenAI walked it back.

Read more

A chat demo lives in suggestion space. The model drafts, summarizes, answers, proposes, and if it’s wrong, the user rejects it. The cost is local. A production agent lives closer to consequence: it can notify someone, expose private information, change a shared record, trigger a workflow, or spend money. That moves a question to the center of the product demos never had to answer: who decides whether the agent should be allowed to act?

A better prompt doesn’t really answer it. Telling the model to “be careful” doesn’t either. Approval modals technically reduce risk but ruin the workflow. Users either click through out of habit or stop using the system. The answer that’s actually working is architectural: a separate judge wrapped around the actor, deciding whether each proposed action should move forward. If you’re building agents that act, this is the layer of the product you cannot bolt on later.

Here’s what’s inside:

• The Lindy example. How a multi-channel agent product hit the failure mode every production system eventually faces, and the architectural fix that worked.

• Why prompting and approval modals both fail. The structural reasons a single prompt can’t pursue a task and police it at the same time.

• Orchestration is not judgment. Why coordinating agents and judging their actions are different problems with different homes in the stack.

• The builder toolkit. Action classification, proposals, specialist judges, eval, memory governance, and what to build first.

• The OpenBrain Judge Extender guide + the prompt kit that builds your first judge. Five prompts that take you from “my agent acts” to a working judge at your highest-risk boundary, plus the full implementation spec for wiring that judge to durable memory, provenance, and structured write-back so it doesn’t start every session from zero.

Start with the team that hit this wall publicly and figured out what to do about it.

Read more

Anthropic announced a new enterprise AI services company with Blackstone, Hellman & Friedman, and Goldman Sachs; press reports put the venture at roughly $1.5 billion. Bloomberg reported that OpenAI had raised more than $4 billion for a similar enterprise deployment venture backed by firms including TPG, Brookfield, Advent, and Bain. SAP said it would acquire Dremio and Prior Labs. Pinecone launched Nexus, a “compilation-stage knowledge engine” with the claim that 85 percent of agent compute is wasted on rediscovery. ServiceNow shipped Action Fabric at Knowledge 2026, opening its workflow engine to any external agent through MCP, with Anthropic as launch partner.

These were reported as separate stories. They are the same bet, and the bet is roughly $5.5 billion that capital is moving from buying the model to buying the build. What is being repriced is not intelligence. Intelligence is cheap and getting cheaper. What is being repriced is the surrounding infrastructure that lets an agent reach real data, act through real permissions, run real workflows, and stay inside audit boundaries at a cost the company can plan around. The frontier labs call it forward-deployed engineering. The platform vendors call it governed action. Whatever the label, it is what enterprise AI value depends on, and the people writing the checks have noticed it is more decisive than the model line item ever was.

If that sounds abstract, the concrete version already happened. In February, an autonomous agent built by CodeWall reached full read-write access on McKinsey’s internal AI platform, Lilli, in under two hours, through one of 22 unauthenticated API endpoints, on a system used by roughly 70 percent of the firm’s 43,000 consultants. The exploit was SQL injection, a vulnerability class from 1998. The story everyone told was about security. The story underneath was about procurement: a platform shipped without the technical voices in the room who would have caught what was on the wire. That is the build room. That is what the $5.5 billion bet is trying to fix.

This briefing covers:

• Why most enterprise AI plans are running on the old buying sequence. Strategy upstream, implementation downstream — agents reverse that order, and the budget allocation is still pointed at the wrong layer.

• What the $5.5 billion concession means. The labs putting capital behind forward-deployed engineering is not a marketing posture. It is the bottleneck they are admitting they cannot solve from the model side.

• Why context, not tokens, is the line item ruining agent economics. And why capping usage kills the use case without fixing the cause.

• The new buying sequence, and where the next quarter’s capital should flow. Three changes that do most of the work — and the test that exposes whether a vendor’s roadmap can survive the build room.

The next year of enterprise AI will not be won by the most ambitious roadmap. It will be won in the room where the roadmap meets the build.

Read more

You explain the repo. You paste the standard. You point at the docs. You list the tools. You list the failure modes you do not want the agent to repeat. By the time it is ready to act, you have done a real chunk of the work yourself, just to get the work started.

That part did not get better with GPT-5.5. The model did. Codex is now at 82.7% on Terminal-Bench 2.0, up from 75.1%, and the lift you actually feel is bigger than the number reads, because the model can now stay inside long, multi-tool tasks without losing the thread. It reviews pull requests against your standards, builds screens from Figma comps, runs tests in a browser, pulls context across Slack, Drive, GitHub, and Linear, and drafts release notes from the diff. The model is good now.

The work around it is not.

That is the bottleneck. The workflow lives in your head, and you reload it every thread. From here, the work has to meet the model halfway.

That is what plugins are for. A skill says how the work should be done. A plugin packages that skill with tool access, live integrations, deterministic checks, the team’s failure modes, and the parts of the standard nobody has written down. Once installed, the agent stops needing you to be the OS.

The stakes are not subtle. A stronger model with a vague environment does not give you more help. It gives you faster, more confident wrongness. Reviews that miss the team’s review standard. Release notes that drift into engineering language. Customer summaries that mix admin material into the team-facing recap. Each looks fine alone. Together they make a company that runs faster and means less.

The career version is sharper. The next competitive skill is not writing the longest prompt. It is knowing which parts of your work should become reusable infrastructure. Two years from now, the people who learned to package will be compounding. Everyone else will be explaining the workflow on Tuesday morning.

Here’s what’s inside:

• The bottleneck that GPT-5.5 made visible. Why a stronger model with a vague environment gives you faster wrongness, not more help.

• The decision ladder. When to stay with a prompt, when to build a skill, when to package a plugin, and when not to bother.

• Which workflows to package first. Five categories worth the investment, and a test for whether yours qualifies.

• Grab The Ultimate Codex Plugin Guide + prompts. The full step-by-step build guide from skill file through plugin manifest and debugging checklist, plus seven prompts that take you from workflow audit to installed, tested plugin.

Let me show you how the bottleneck moved, and what to do about it.

Read more

The 271 is striking. The story underneath it is bigger, and it is not really about cybersecurity at all. Software has always rested on a quiet assumption that human-written code is the trust anchor and machines are there to check it. Mythos is the first serious sign that the assumption is about to flip. Serious software in the next era may be generated, attacked, repaired, and verified by machines, while humans hold a different role entirely: defining what the system is allowed to mean.

If that flip is real, the standard of trust rises faster than most teams are ready for. Hand-written code without adversarial machine review starts to look incomplete. Codebases that were merely messy start to look structurally unsafe, because the tools that could make them safer cannot operate on a system nobody can read. There is a window to get ahead of this — short, uneven, and closing.

Here’s what’s inside:

• The inversion of authorship. Humans wrote, machines checked. Mythos starts to flip that. What it means when generated code becomes the more trusted version, not the less.

• When trust becomes scarce. Code is about to get cheap to produce and expensive to trust. The teams that win the next year are the ones that build for that gap on purpose.

• Comprehensibility as a security property. Why the next four to five months are a refactor window — and why teams that wait will discover their codebases are too tangled for the new tools to help.

• Where the timing lands. What this means if you are an individual contributor versus a team lead versus a CTO — and why the budget conversation is already late at the top of the org.

• Audit your readiness now. Two prompts that tell you whether your codebase is legible enough for the next generation of adversarial review tools, and whether your evals for AI-generated code are catching the right things.

Read more

A month ago, the easy descriptions still fit. Chatbot wrapper, Claude launcher, viral terminal toy. By the end of April, none of them held. OpenClaw became an action layer for agents — a place where tasks, tools, memory, channels, permissions, subagents, and model choices come together into durable workflows. The model is no longer the product. The runtime is.

That shift matters because the model layer underneath it became more contested at exactly the same time. Anthropic pulled subscription-backed third-party usage back toward its own products. OpenAI moved the other way, opening ChatGPT and Codex subscription usage to OpenClaw users. Google shipped Gemma 4, built explicitly for agentic and on-device work. Local models got good enough for more background tasks. Claude is still valuable, but increasingly as a metered premium component rather than the default flat-rate engine for everything.

The mistake is to let the runtime fight swallow the product story.

A month ago, the builder ambition was to make an agent do something useful. Now it is to build a durable workflow once and swap the model underneath it. That is a much bigger idea, and it changes the builder opportunity completely.

Here’s what’s inside:

• Why April was the threshold month. TaskFlows, channels, memory, and routing all matured at once, and the combination is what crossed the runtime line.

• The Anthropic move, in context. What changed, why it was rational, why the developer community reacted the way it did, and what it tells you about the next twelve months.

• The seven workflows you can now actually build. Repo operations, code review memory, incident response, customer feedback, meetings to execution, model-aware routing, and team memory across agents.

• Why memory has to live outside the model. If the brain is swappable, memory cannot live inside any one brain — and that has implications for how you architect anything you build on top of OpenClaw.

• The Open Brain Agent Memory launch. A live ClawHub skill, a plugin package, and four recipes — code review memory, TaskFlow work logs, the OpenClaw Agent Memory recipe, and a Safe Agent Memory contract that draws the line between evidence and instruction.

The labs will keep fighting over the brain. The interesting question is what builders should do while they fight.

Read more

Every AI product announcement in the next year will look like progress. Most will be progress on access — the agent can now reach one more thing. A smaller share will be progress on meaning — the system actually understands what it is doing. Demos make the two look identical. Six months into a real deployment they feel completely different: access-only products are still demanding constant supervision, and meaning-rich ones are quietly compounding. If you are building, buying, or betting on AI tools right now, the difference between those two categories is the most important call you will make this year.

Computer use exists because most software was designed for human interpretation — and a person knows that moving a calendar invite is not just changing a row in a database. It may notify attendees, alter someone’s preparation, break a commitment, or reschedule a meeting that took three weeks to set. The agent can infer some of that. Inference over a human interface is not the same as software exposing the meaning of the work directly. That distinction is the next platform fight.

Computer use gives agents reach. Semantic control gives them judgment. The long-term moat is not the ability to click the button. It is ownership of the layer that tells the agent what the button means.

Here’s what’s inside:

• Why coding agents arrived first. The structural reason software development became the wedge — and what it tells you about which kinds of work agents will conquer next.

• The Stripe move most people misread. Why a structured payment token is strategically deeper than any agent that clicks checkout buttons.

• The trap Perplexity is trying to escape. Why moving from answering to operating is necessary but not sufficient.

• The Salesforce vs. SAP wager. Two opposite bets on agent-readability, and the buyer behavior that decides which one survives.

• The better product test. A single question to ask of every AI product announcement that cuts through the demo theater.

• Three diagnostic prompts. One to evaluate any AI product announcement against a ten-dimension semantic depth test, one to audit a tool already in your stack and decide whether to extend, wrap, replace, or wait, and one to run a structured post-mortem after an agent’s action succeeded but the outcome was wrong.

What follows is how the divergence is unfolding — and what to look for in the products you are evaluating, building, or betting on.

Read more