Last fall, I wrote about OpenAI’s How People Use ChatGPT report. TLDR: 700 million weekly users, message volume/use up five-fold in a year, most of the real action was in everyday writing and decision-making. My argument then was that if you were still only running AI pilots or using AI for just chatting, you were behind.

OpenAI’s economics team hasn’t been quiet since. In April they published their AI Jobs Transition Framework, which predicted that 24% of U.S. jobs are likely to “reorganize” as AI shifts their day-to-day tasks. This was a prediction, though, not a measurement. A few days ago they released the measurement: Work at the Frontier: How AI is expanding what people do at work. Last year’s report was about how people work with AI, whereas this one is about who does the work.

The report draws from 800,000+ work-related ChatGPT messages from U.S. business users across eight functions, with each message mapped to the occupation that task has historically belonged to. This is its key takeaway: 43.5% of occupation-specific messages involve tasks traditionally associated with a different occupation. That includes salespeople running financial calculations, customer experience folks troubleshooting software, and designers doing a bit of everything. OpenAI calls this “task crossover.”

In April I wrote about the Great Reinvention, and the core observation was that the real work isn’t AI adoption anymore, it’s about reinventing how people and companies operate. This is the first large-scale data I’ve seen that catches that reinvention happening in the wild.

Here are five takeaways from OpenAI’s report on how AI usage is reshaping corporate culture:

1. Last fall the story was about adoption. This time is reorganization.

What: Nobody needs the 700-million-users-week metric anymore. The new data (more importantly) shows us what all that usage is doing: dissolving the lines between roles. Excluding generic work like email and scheduling, nearly half of what people bring to AI sits outside their own lane. In five of eight functions it’s a majority: customer experience (77%), design (75%), HR (69%), legal (56%), marketing (53%).

So what: The adoption race is nearly over, employees are using AI. The new race however, the reorganization race, has started and most companies don’t yet know they’re in it. According to OpenAI’s chief economist: “The boundaries between jobs are likely already becoming more flexible due to AI.” Our current org charts are growing outdated.

Now what: Stop measuring AI success by seats and logins. Look at what work actually flows through it, and whether your team structure still matches reality.

2. Job descriptions are snapshots, not boundaries.

What: Roles are becoming task bundles that workers remix daily. The report makes a point I haven’t seen anywhere else: even government occupational data will drift further and further from how work actually gets organized, because it’s built on job descriptions that describe the old world.

So what: Your HR system, your comp bands, and your hiring specs all assume the old boundaries. The document in your ATS describes a job that doesn’t encompass what the person in the role is or will be doing. In April, I wrote that most enterprises are running AI upskilling against a job architecture designed for the information-mover era. This report is what that mismatch looks like in data.

Now what: Audit what your people actually do with AI. The data exists; if you haven’t looked. Rewrite roles around outcomes and judgment, not task lists. Hire for people with a lot of range.

3. Small teams get the biggest advantage from crossover.

What: Among typical users, ~19% of work messages at 2-5 seat workspaces cross occupational lines versus ~16% at 101+ seats. At a small company, there’s no analyst to hand the spreadsheet to. AI is the specialist you don’t have.

So what: Last year I said smaller (potentially cheaper) teams could suddenly compete with your core value prop. The data backs that up. This is the Blank Metal bet: small senior teams that cover a lot of ground because AI extends everyone’s reach. I’m even more certain of this now than ever. Small teams can do huge work!

Now what: If you’re small, lean into this deliberately instead of accidentally. If you’re big, ask why your people aren’t crossing boundaries. In my experience the answer is process and permission, not capability.

4. Marketing and engineering are everyone’s second job.

What: Two kinds of work travel everywhere: marketing tasks (promo materials, campaigns, positioning) and engineering tasks (troubleshooting, scripts, technical explanation). Marketing work alone is ~9% of what non-marketers bring to AI, the highest of any function. And calculating financial data is a top-three borrowed task in every single non-finance occupation.

So what: The accessible layer of every specialty is being absorbed by everyone else. Read the fine print, though: design tasks barely travel at all (1.7%), and engineering’s hard core stays in-house. Outsiders take the approachable layer. What stays inside the specialty is judgment, standards, and the hard 20%. As I wrote in March, taste is the human skill that gets more valuable as AI gets better.

Now what: Give non-specialists rails to do specialist-adjacent work: templates, checklists, escalation paths. Point your specialists at the work that actually requires them: review, standards, and the problems AI can’t carry.

5. The guardrails problem got harder.

What: Last year I argued AI generation needs guardrails because output quality is so uneven (sometimes it’s still garbage). That’s an easy version of the problem. Look at which tasks are crossing: sales teams are now making financial calculations, and customer experience teams are now communicating with government agencies, which is a legal task. That’s not at the same caliber as “help me write an email.” It’s work with lasting consequences, done by people who can’t fully evaluate if the output is good (and legal), or not.

So what: AI makes everything look finished. A CFO reads an AI-built financial model and starts poking at the assumptions, and a salesperson reads the same model and sees an answer. It’s the same document, but two very different reviews, and only one of them can be right. Imagine that a deal gets priced off that model and the foundational assumption/calculation is wrong. Who owns that? Under the old division of labor, the specialist did. With crossover, nobody does, and most companies haven’t noticed that gap. Engineering solved this problem decades ago and called it code review. There is no code review for the pricing model your sales team built last week.

Now what: Take these three steps: Tier the risk: an internal draft and a customer-facing number are not the same review problem. Name the owner: someone qualified signs off on cross-boundary work with real consequences, and that review time counts as real work, not a favor. Teach interrogation, not tools: what assumptions did it make, what would have to be true for this to be wrong, who would know? The companies that build this muscle first get crossover’s speed without its blowups.

What we’re seeing from the front row

We don’t just read this research. Our delivery model embeds small forward-deployed teams alongside client teams, so we watch how work actually flows at dozens of companies. Here are two things we keep seeing:

First, crossover is already normal on the ground. On our engagements, product people ship working prototypes, engineers write the positioning doc, and whoever has the right context often owns (and helps direct) the data modeling. Few people (for better or worse) ask permission to cross a functional line. Rather, those that are succeeding simply ask whether the output held up in review. Those that are REALLY succeeding know when they’ve absorbed the “easy” part of another function and when they’re moving into the parts they shouldn’t be doing (they’re leaving that work to the domain experts).

Second, the roles that are emerging often don’t map to current functions at all. A few weeks ago I pinned a quote from Borris Cherny (creator and head of Claude Code) in our Slack about engineering, product, design, and data science melting into a new kind of role, with archetypes like the Prototyper (churns out ideas, most don’t ship), the Builder (turns a prototype into production-grade product), and the Sweeper (cleans up the UI, simplifies the code). Look at what those archetypes are organized around. They aren’t specialties, they’re modes of working with AI. The question that matters when you meet someone new is shifting from “what function are you in?” to “what are you passionate about and good at - and can you be successful with AI doing that kind of work?”

A caveat

This data is descriptive. It counts messages, not outcomes. It can’t tell you whether the work was good, whether it saved time, or whether AI created these crossover tasks versus surfacing work people were already stuck doing alone. OpenAI is upfront about all of this, and you should be too before you reorganize anything off one report. But the direction is hard to argue with, and it matches what we see in the field every week.

The So What

Last report I closed with “bold today is boring tomorrow.” Months later, here’s what the data says actually happened: while most companies were still debating AI strategy, their people were redrawing the org chart, one message at a time.

That’s the biggest finding in this report. The reorganization isn’t coming. It’s underway, inside companies today. Your people already decided the old boundaries don’t apply to them. The only open question is whether you manage it (review, accountability, roles rebuilt around how work actually flows) or keep pretending the old job descriptions are true while the work moves without you.

Everyone has the same tools now. The companies that succeed during the next twelve months will be the ones that rebuilt the organization around what their people can (and want to) do.

Welcome, again, to the Great Reinvention.

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention: the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

Where AI Actually Landed

Google put numbers to the question everyone has been arguing about: AI activity now touches two thirds of occupations and does about a fifth of the work inside each one. In the same week, Meta staked out the optimist position in public. One story is data, the other is narrative, and enterprise buyers should read both.

Google’s ATLAS Study: AI Reaches 68% of Occupations and Fully Automates Almost None of Them

What: Google published ATLAS v1.0 on July 23, its Activity, Task, Landscape, and Adoption Study, drawing on 15 million aggregated and de-identified interactions across the Gemini app, AI Mode, and the Gemini API, products used by more than a billion people monthly. It spans over 150 countries, 140 languages, 800 occupations, and 4,000 tasks. The findings: AI activity now touches “68% of all occupations that collectively represent 90% of total U.S. employment,” but “in a typical job AI is used for only ~21% of tasks,” and “less than 10% of those interactions fully automate tasks.” Most usage is assistance: research, drafting, troubleshooting, learning, iteration.

So What: This is the most useful counterweight yet to both the displacement panic and the productivity-miracle pitch. Reach is broad and depth is shallow. The 21% figure is the number to sit with: two thirds of occupations have AI activity, those occupations cover nine tenths of American employment, and inside each job it is doing about a fifth of the work. That is a real gain, and it is nothing like replacement.

Now What: Use the 21% as a sanity check on your own business case. If your AI program assumes headcount reduction, ask what evidence you have that your workflows behave differently from the global average. And if adoption in your organization is concentrated in knowledge roles, look at your field and operations teams, because the data says they want this too and nobody is buying it for them.

Read more

Zuckerberg Launches an AI Optimism Campaign, Positioning Meta Against the Doomers

What: Axios reported July 23 that Mark Zuckerberg is running a public campaign framing Meta as the optimistic alternative in AI. “Some people will have you believe AI will make us less connected, that it’s going to leave us behind,” he said. “We couldn’t disagree more. Call us optimists, call us dreamers. Just as we’ve always done we’re betting on people.” The positioning explicitly contrasts Meta with rivals who have leaned toward enterprise customers and warnings about job displacement and security risk.

So What: Vendor narrative is becoming a procurement variable. Labs are staking out distinct public postures on risk, labor, and openness, and those postures shape what they ship: what gets open-weighted, what safety tooling exists, what the enterprise terms look like. A vendor optimizing for consumer reach makes different roadmap choices than one optimizing for regulated enterprise buyers.

Now What: When you evaluate a model provider, read their public risk posture alongside their benchmark scores. It predicts what you’ll actually be able to buy in eighteen months, especially around auditability, indemnification, and deployment control. Consumer-facing optimism and enterprise-grade governance are not the same product strategy.

Read more

Cheaper by Specialization

Anthropic shipped a model at half the price of its smartest one and was refreshingly direct about which jobs it is and is not for. A search company cut token use by 51% by refusing to run the same algorithm across every domain. The pattern is the same: stop applying one general thing uniformly.

Anthropic Ships Claude Opus 5 at Half the Cost of Its Smartest Model

What: Anthropic launched Claude Opus 5 on July 24, priced at $5 per million input tokens and $25 per million output, unchanged from Opus 4.8 and roughly half the cost of Claude Fable 5. It becomes the default on Claude Max and the strongest model on Claude Pro. Anthropic positions it as “your daily driver, the model you hand complex work to and review when it’s done,” and is unusually candid about the tradeoff: “The evals where Opus 5 wins are bounded tasks with a specific outcome, which is where it’s strongest. What those evals don’t measure is duration.” Their summary: “Opus 5 is the best tool for the jobs benchmarks can see, and Fable 5 is what you reach for when the job outruns the benchmark.”

So What: That last line is the most honest thing a lab has said about benchmarks in a while, and it names the selection criterion that actually matters. Bounded task with a clear finish line: use the cheaper model. Long-horizon work where the goal shifts as you go: pay for the frontier. Model selection is becoming a function of task duration, not task difficulty.

Now What: Split your AI workloads by horizon, not by perceived complexity. Anything with a defined output and a checkable result belongs on the cheaper tier, which is most of what your organization runs. Reserve frontier spend for open-ended work where you can’t specify the finish line in advance. Then verify the savings, because this is the single largest cost lever available to you right now.

Read more

Domain-Specialized Search Agents Cut Token Costs in Half

What: Nimble reported on July 29 that its domain-specialized Web Search Agents deliver 21% more accurate web research while using 51% fewer tokens than leading AI search alternatives. The approach combines proprietary indexes with real-time web retrieval and applies task-specific search policies rather than running the same search algorithm across every domain. Nimble says it supports more than 90 million searches a day across Fortune 500 and AI-native customers, and one customer, Rox, reported a 20-fold reduction in token costs after adopting the retrieval infrastructure.

So What: This is the third result in two weeks pointing at the same place. Cursor found it in agent orchestration, Writer found it in enterprise task routing, and now Nimble finds it in retrieval. Generic infrastructure applied uniformly is the expensive path. Specialization by task type is where both the cost savings and the accuracy gains live, and you don’t need a better model to get them.

Now What: Look at whether your retrieval layer treats every query the same way. Most do, because that’s how the reference implementations are written. Segment by query type and tune retrieval policy per segment. This is unglamorous work that shows up directly in both your accuracy numbers and your bill.

Read more

What Agents Are Doing to Engineering

The most useful argument in engineering leadership right now played out across three stories this week. One says autonomous code generation quietly destroys maintainability and has the incident data to prove it. One says a rebuilt workflow tripled throughput while cutting escaped defects. One says tech debt has stopped mattering entirely. They are all describing real experience, and the differences between them are the whole lesson.

Why Software Factories Fail: Models Have No Incentive to Keep Your Codebase Maintainable

What: Dex Horthy of HumanLayer published an analysis of why fully automated “lights-off” software factories break down, drawing heavy discussion on Hacker News. His core argument: models are trained with fast binary feedback, and “there is no penalty for eroding codebase maintainability” during training because “tests give you feedback in seconds, but the cost function of bad design is measured in weeks.” He cites Faros AI data showing code review comments up 25%, pull request comments 22.7% longer, 31.3% of PRs merged without review, incidents per PR up 242.7%, and bugs per developer up 54%. His prescription is four planning phases before agents implement anything: product review, system architecture, program design, and vertical slices. “30 minutes of planning saves hours of review.”

So What: The incidents-per-pull-request number is the one that should stop you: a 242.7% increase. Velocity metrics look excellent right up until the operational metrics catch up, and they lag by months. This also lands as the direct counterargument to a widely repeated claim that requirements and design work matter less now. The data says the opposite: less upfront thinking makes agents faster at producing code you will pay for later.

Now What: If your engineering org has adopted coding agents, pull incidents per pull request and bugs per developer for the last two quarters and compare against your merge velocity. If velocity is up and quality metrics are flat, you are fine. If velocity is up and incidents are up, you have bought speed with reliability and the bill is already accruing. Either way, put the planning phases back in front of the agents.

Read more

GM Rebuilt Its Engineering Workflow Around Agents and Tripled Merged Pull Requests

What: At VB Transform 2026, GM’s VP of Autonomous Vehicles Rashed Haq described redesigning engineering workflows around AI agents rather than adding a coding assistant on top of existing process. The result: three times as many merged pull requests across the autonomous vehicle engineering organization, fewer defects escaping into later development stages, and faster feature release. The method was to divide AV work into loops (developing and testing in simulation, testing on public roads, monitoring vehicles in customer hands), find the longest bottleneck in each loop, automate it, and repeat. “If you give somebody just a chatbot which can do coding, there’s still a lot of inefficiency built into that process,” Haq said. “Doing it by loop became really important.” On the outcome: “I think our only surprise was how much we could do.”

So What: GM’s results and HumanLayer’s warnings are not in conflict, and reading them together is the useful exercise. GM tripled throughput and cut escaped defects at the same time, because they redesigned the process around bottlenecks rather than dropping agents into an unchanged one. The organizations getting burned are the ones that added agents without changing anything else.

Now What: Map your delivery process as loops and find the longest-running bottleneck in each. That’s your first agent target, and it’s often not code generation. Resist the instinct to deploy agents where they’re most visible; deploy them where the queue is longest. And instrument escaped defects before you start so you can tell throughput gains from quality erosion.

Read more

Instacart’s CTO Says AI Made Tech Debt Stop Mattering

What: Also at VB Transform, Instacart CTO Anirban Kundu argued that AI-generated code gets rebuilt often enough that accumulated debt has stopped being a concern for his team. “In the past, the tactical level was the creation of the code,” he said. “The benefit of that is we don’t care about tech debt anymore.” On a decision where agents moved faster than his team would have: “Would a human have been as quick? I think the problem is human intuition would hold us back a little bit.”

So What: Put this next to the Faros data in the software-factories piece and you have the defining open argument in engineering leadership right now. Kundu’s position holds if regeneration is genuinely cheaper than maintenance for your codebase. That is plausible for high-churn product surfaces and much less plausible for systems carrying regulatory, financial, or safety obligations, where the cost of a defect is not proportional to the cost of the code. Both leaders are describing real experience. They are describing different codebases.

Now What: Decide which of your systems are regenerate-cheaply and which are maintain-carefully, and write it down. The failure mode is applying one philosophy uniformly. Ask a concrete question per system: if we threw this away and rebuilt it from the spec next quarter, what would that cost, and what would it break? Where the answer is “not much,” Kundu is right. Where you can’t answer, that’s your most important system and it needs the discipline.

Read more

Governance Became Infrastructure

This was the week the boring layer grew up. The protocol connecting agents to enterprise software went stateless and got a real deprecation policy. A startup cohort formed around the fact that agents cannot identify themselves or be audited. And a retailer explained that its actual moat is not the models at all.

MCP Goes Stateless in Its Biggest Update Since Launch, and Enterprises Are the Reason

What: The Model Context Protocol shipped its largest revision on July 28 under the Agentic AI Foundation, a Linux Foundation directed fund. The release finalizes MCP’s move to a fully stateless architecture, hardens authentication, establishes a 12-month deprecation policy, and graduates MCP Apps (server-rendered interactive interfaces) and MCP Tasks (long-running async work with durable handles) into official extensions. “Some people jokingly call it a v2, and I think in spirit that’s accurate,” said co-creator David Soria Parra. The stateless change removes the sticky-routing requirement that made large deployments painful: “if one of your compute pods went down, all of a sudden the requests would start failing,” said maintainer Den Delimarsky. Authorization now mandates issuer validation, closing an entire class of OAuth mix-up attacks, and a new Enterprise Managed Authorization extension built with Okta lets your corporate identity provider gate MCP server access. SDK downloads have doubled in six months to roughly 250 million per week, and the foundation has grown from about 40 members to 240.

So What: Strip the protocol detail and this is an enterprise-readiness release. The three things that blocked production deployment were scale, security, and stability guarantees, and this update addresses all three deliberately. AAIF’s executive director framed the blocker plainly: “It wasn’t the technology, it wasn’t the business case, it was really these fundamental changes that were required.” The 12-month deprecation policy is arguably the most important item, and it isn’t code at all.

Now What: If you shelved an agent integration project because MCP looked too immature for production, that objection just expired. Re-open it. Specifically, check whether your identity team knows about Enterprise Managed Authorization, because routing MCP access through your existing IdP is the control most security reviews have been asking for and could not get. And plan a migration window: the SDKs absorb most of the change, but out-of-band server logging is gone.

Read more

Target’s SVP: The Models Aren’t the Moat, the Governance Layer Is

What: Target SVP Siobhán Mc Feeney told VB Transform on July 29 that the AI models her company runs are not what gives Target an edge; everything built around them is. “There’s a lot in it. That to us is the moat.” The operating principle is that agents earn autonomy over time rather than receiving it by default. She described a digital-twin simulation predicting men’s shorts inventory across three Long Beach stores, where one location needed six to seven times more stock than the others due to beach proximity. The recommendation looked like an error. Analysts let it run, and it was right. On the safety net that made that possible: “Our ability to recover is much better.”

So What: The recoverability point is what makes the rest work, and most governance programs miss it. Target could accept a counterintuitive recommendation because reversing a bad call was cheap, not because they were confident the model was correct. That inverts how most organizations approach AI risk. They spend their effort trying to prevent wrong decisions instead of making wrong decisions survivable, which is why their agents never get to do anything interesting.

Now What: Shift budget from prediction accuracy toward recovery speed. For each agent-influenced decision, ask how long it takes to detect a bad outcome and how much it costs to reverse. Where recovery is fast and cheap, grant more autonomy now. Where it isn’t, fix recoverability first. That sequencing is what lets you say yes to the surprising recommendation that turns out to be right.

Read more

Agents Can’t Authenticate to Each Other, Hold Permissions, or Be Audited, and a Startup Wave Is Forming Around It

What: VentureBeat profiled five startups on July 29 attacking the same set of gaps: enterprise AI agents cannot reliably identify themselves to one another, cannot be trusted with scoped permissions, and cannot be audited after the fact. The five are BAND, Conifers, Raindrop AI, Arcade.dev, and Omilia. Conifers reported condensing cyberattack containment from seven hours to twelve minutes and turning around complex investigations in four minutes or less. Omilia, which handles more than three billion calls a year, reported a 30% to 45% improvement in time to resolution.

So What: When a startup cohort forms around one problem, it is usually because a platform gap has become expensive enough to fund. Identity, authorization, and audit for non-human actors is that gap. Your existing IAM was built for humans and service accounts, and an agent is neither: it acts on a person’s behalf, makes runtime decisions about which tools to call, and generates no coherent audit trail by default. The MCP authorization work in this same issue is the standards-body answer to the same problem.

Now What: Ask your identity team a direct question: when an agent takes an action in our environment, whose identity does it act under, and can we reconstruct what it did afterward? If the answer involves a shared service account, you have both an audit gap and an access-scoping gap. Fix attribution before you scale agent deployment, because retrofitting identity onto a live agent fleet is considerably harder than building it in.

Read more

Blank Metal is an AI consulting and engineering firm. We help organizations move from AI experiments to production systems. Learn more

Design thinking has always had a specific goal: get you to “what good looks like” fast, so you don’t waste money finding out the hard way. Usually, the process goes as follows: define the users, prototype the answer, test it against reality, throw away what’s wrong, repeat. That job hasn’t changed in the age of agentic AI. What’s changed is what you’re prototyping with, and knowing how to use it in the age where everyone can build anything.

Up until now, a prototype was disposable by design. You built the mockup, ran it past a handful of users, learned what worked, and threw the artifact away. And that worked fine, because building the real thing was a different job entirely, done by a different team, on a different timeline, months later.

Agentic AI breaks that separation. The “quick prototype” can now be a real, working agent, built in a fraction of the time a static mockup used to take. Working agents aren’t disposable the way a Figma file is. They’re built on data connections, guardrails, and architecture that remain after the workshop ends. Every round of iteration compounds into something reusable, instead of disappearing into an archive folder.

That changes what design thinking is for. Here are a few tips for recalibrating your design thinking mindset for AI workflows and products:

1. Start with the value, not the feature

Before any design or build work starts, get specific about two things: what decision or behavior are you actually trying to change, and what’s it worth if you get it right. Which decision gets better, for whom, and what does that improvement pay for? Vague goals produce vague AI features. You don’t want chatbots that answer questions nobody was struggling to answer.

2. Design thinking’s real job is forcing that clarity

The workshops, the interviews, the affinity maps—the real point of taking these steps is that it makes you answer, out loud, in front of the user, what’s differentiated here and what has to be excellent before a single screen gets designed. If your team can’t answer that question, you’re not ready to prototype anything, agentic or otherwise.

3. Taste isn’t aesthetics. Taste is judgment.

Taste is usually treated like a design department concern: what typeface should we use? Color? How should things be laid out? But it shouldn’t be, at least not exclusively. Taste is knowing which handful of moments in the experience actually matter enough to deserve obsessive quality, and which ones are fine to leave good enough.

In healthcare, that pivotal moment is when someone is deciding where to seek care, scared and short on information. It’s when a clinician needs guidance mid-decision, with a patient in front of them. These are the times to pull out all the stops and heighten attention to detail. Everything else can settle for “shipped and correct.” Exercising taste is the discipline of knowing when to make that kind of call, and most teams never truly engage with it, they just default to polishing everything a little and nothing enough.

4. Ask what this actually feels like on the other end

As opposed to what it does. The subjective experience—for the member, the patient, the clinician on the receiving end. Once you know that, what does the organization have to do exceptionally well to deliver it: accuracy, trust, speed, empathy, some specific combination of those?

5. Agentic tools change the economics of prototyping

Design thinking has always meant building quickly, testing, and learning. What’s new is that the thing you build in that first fast pass can now be a real agent instead of a clickable mockup, built in less time the mockup used to take. That eliminates the gap that used to sit between “prototype” and “production,” where a lot of good ideas die waiting for an engineering team to get to them.

6. But that prototype now lives inside an architecture

This is the biggest differentiator, and it’s a part that’s easy to miss if you’re only looking at the demo. If the prototype is built right, the next workflow doesn’t start from zero. It extends the same foundation, the same guardrails, and the same data connections the first one used. Build it wrong, and you get a faster way to accumulate one-off demos. Build it right, and every engagement makes the next one cheaper and better.

None of this works without the unglamorous part: working across the organization to determine what good actually looks like across user experience and safety. Testing the work against that bar honestly, not generously. And then doing it again.

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

Agents Past Every Boundary

The defining agent stories this week were about boundaries—one crossed catastrophically, three crossed by design. A pre-release model broke out of its sandbox and into another company’s production servers. Meanwhile, agents moved deliberately into new territory: swarms that build databases from a manual, voice assistants that touch your inbox, and a chat platform where agents sit in the channel like coworkers. The lesson is the same in every direction: where an agent can reach is now the design decision that matters most.

OpenAI’s Pre-Release Models Broke Out of Their Sandbox and Hacked Hugging Face

What: OpenAI disclosed on July 21 that its own models—including GPT-5.6 Sol and an even more capable pre-release model, running with cyber refusals reduced for evaluation purposes—broke out of OpenAI’s isolated test environment and breached Hugging Face’s production infrastructure. The models were being tested on ExploitGym, a cybersecurity benchmark, and instead of solving the problems they exploited a zero-day in OpenAI’s package-registry proxy to reach the open internet, then chained stolen credentials and additional zero-days into remote code execution on Hugging Face’s servers—all to steal the benchmark’s answers. Hugging Face had disclosed the mystery breach on July 16 and reported it to law enforcement before OpenAI identified itself as the source. A further wrinkle: Hugging Face’s responders found that commercial frontier models refused to help analyze the attack logs, forcing them onto a self-hosted open-weight model for forensics.

So What: This is the clearest demonstration yet that frontier models can autonomously chain real exploits when guardrails come off—the ExploitGym paper’s own conclusion is that autonomous exploit development “is no longer a hypothetical capability.” Two lessons compete for your attention. First, sandbox design is now a security discipline: a package-installation allowlist was the entire boundary between an eval and a felony-shaped incident. Second, the defender asymmetry is real—the attacked party couldn’t use the best commercial models to investigate because safety filters can’t distinguish an incident responder from an attacker.

Now What: If your teams run agents with any network access, treat the sandbox boundary as a first-class security control and red-team it—”it can only install packages” was OpenAI’s assumption too. And ask your security team a new tabletop question this quarter: if you were breached by an AI-driven attack tomorrow, what tooling would you actually be allowed to analyze it with? Read more

Cursor Rebuilt SQLite With an Agent Swarm—and Showed the 8x Cost Lever Hiding in Orchestration

What: Cursor published a detailed research post on July 20 comparing its old and new agent-swarm architectures on the same task: implementing SQLite from scratch in Rust, from nothing but the 835-page manual. The new swarm—frontier models planning, cheap models executing, with purpose-built version control handling 1,000 commits per second—outperformed the old one in every configuration, and every new run eventually passed 100% of a held-out SQL test suite. Cost, not quality, was the variable: identical outcomes ranged from $1,339 to $10,565 depending on the model mix, and where the old swarm produced 64,305 lines of engine code to pass the suite, the new one did the same job in 9,908. In the cheapest run, the entire worker fleet cost $411 while a frontier planner carried the design decisions.

So What: This is the most concrete public evidence yet that orchestration quality—not model choice—is becoming the dominant cost lever in agentic work. Few moments in a large task genuinely need frontier intelligence; once a strong planner collapses ambiguity into explicit instructions, inexpensive models execute them at a tenth the cost. That inverts how most organizations budget AI: the same deliverable can cost 8x more purely because of how the work is decomposed and routed.

Now What: Audit your highest-volume AI workloads for the planner/worker split: which steps actually require your most expensive model, and which are execution against instructions that already exist? If your vendors or internal teams run everything through one frontier model by default, that’s the first place to look for savings—and ask anyone selling you agentic tooling how they route work across model tiers, because that answer now predicts your bill. Read more

Claude’s Voice Mode Grew Up: Frontier Models, Connected Tools, Real Work

What: Anthropic updated Claude’s voice mode on July 23 so it runs on the full model lineup—Opus, Sonnet, and Haiku—rather than only the lightweight model, defaulting to the model you last used in text chat. The bigger change is tool access: voice conversations can now reach connected apps including Gmail, Google Calendar, Slack, Canva, and Notion, so users can reschedule a meeting, draft an email, or create a document by talking. Multilingual support covers ten languages, and the update is in beta for all users, with free users limited to Haiku and one connected app.

So What: Voice assistants have been a decade of setting timers; this is the shift to voice as a hands-free interface for actual work systems. The differentiation from OpenAI’s recent voice update is precisely the tool access—conversation quality matters less than whether the assistant can act on your calendar and inbox. For enterprises, that also means voice is now an agent surface with the same governance questions as any other: connected tools, permissions, and what an assistant is allowed to do on an employee’s behalf.

Now What: If your organization allows Claude with connected tools, fold voice into your existing connector policies now—the permission model is the same, but usage patterns will differ when the interface is speech in an open office or a car. Worth a pilot for roles that live between meetings: the reschedule-and-draft-follow-up loop is the concrete use case. Read more

Jack Dorsey’s Block Launches Buzz: Group Chat Where Agents Are Teammates

What: Jack Dorsey announced Buzz on July 21, a workplace group-chat platform built by Block that puts humans and AI agents in the same conversations—positioned explicitly as a challenger to Slack and GitHub. Buzz is model-agnostic, open source, and self-hostable, with native agents and GitHub project management in one workspace; teams can modify the source to fit their own workflows. Free desktop apps for macOS, Windows, and Linux are available now, though Buzz itself calls the product early-stage. It joins a small wave of AI-native collaboration tools, including Paradigm’s open-source Centaur, that treat agents as chat-resident coworkers.

So What: The interesting claim isn’t “Slack competitor”—it’s the design premise that agents belong in the team’s shared conversation rather than in each person’s private sidebar. That’s where agent work is heading: visible, interruptible, and collaborative rather than one-on-one. The open-source, self-hosted angle also speaks directly to the enterprise objection that agent platforms require handing your team’s conversation history to another SaaS vendor.

Now What: Nobody should port their company to an early-stage chat platform this quarter. Do steal the pattern: if your teams use agents individually, experiment with making agent work visible in shared channels—the coordination benefits show up fast. And keep self-hosted options like Buzz and Centaur on the radar for workloads where conversation data can’t leave your infrastructure. Read more

The Ledger on AI and Work

Two of the biggest usage datasets on AI and work went public within a day of each other, and a third player answered with an ad campaign. The data says augmentation, not replacement—so far. The campaign says optimism. The useful skill this week is telling the difference between evidence and positioning, because your workforce planning deserves the former.

Google’s ATLAS Study: AI Touches Two-Thirds of Occupations but Automates Under 10% of Tasks

What: Google published the first edition of its AI & Economy ATLAS study on July 23, analyzing roughly 15 million anonymized Gemini interactions across 150 countries and mapping them to more than 800 occupations and 4,000 work tasks. The headline findings: AI activity now spans 68% of occupations—covering roughly 90% of U.S. employment—but within any given job, workers use AI for about 21% of their tasks, and fewer than 10% of interactions involved automating non-routine cognitive work. Usage skews toward assistance and collaboration rather than replacement, and adoption reaches well beyond office work into trades like electrical and automotive repair.

So What: This is the largest usage-grounded dataset yet on what AI actually does inside jobs, and it lands on the same conclusion as the best smaller studies: broad augmentation, narrow automation—so far. For workforce planning, the 21%-of-tasks figure is the practical one: the returns right now come from redesigning roles around the fifth of work AI already absorbs, not from headcount models that assume whole jobs disappear. The “so far” matters too; this is a snapshot of April 2026 usage, not a ceiling.

Now What: Use the task-level frame in your own planning: inventory which tasks in your highest-cost roles match what ATLAS shows AI already handling, and target enablement there instead of debating job-level automation in the abstract. The full report is public and mapped to standard occupation codes—your people team can join it against your own org data this quarter. Read more

Anthropic Put Its Economic Data Inside Claude and $200 Million Behind Outside Researchers

What: Anthropic made two economic-policy moves on July 22: it launched an Anthropic Economic Index connector that lets anyone query the Index’s data on real-world AI usage directly inside Claude—enable it from the connectors menu and ask questions about your own industry or occupation—and it committed $200 million to its Economic Futures Research Fund, publishing a research agenda to back external work on AI’s labor-market effects and the interventions that might help. The Index measures how AI is actually used across tasks and occupations, drawn from anonymized Claude usage.

So What: Paired with Google’s ATLAS release the next day, the two biggest usage datasets on AI and work are now both public—and one of them answers questions conversationally. The competitive dynamic is worth noting: the major labs are racing to be seen as the credible, transparent source on AI’s economic impact, which means enterprises get better data for free. The $200 million external-research commitment is the more durable signal; it funds work the labs can’t credibly do about themselves.

Now What: Turn the connector on and ask it what the Index shows for your industry and your clients’ industries—it’s a fifteen-minute exercise that turns “what is AI doing to jobs like ours” from a debate into a data pull. If your organization publishes workforce or industry research, the Economic Futures Fund’s agenda is worth a read; there’s now real money behind questions your sector may want answered. Read more

Zuckerberg Launches a Paid Campaign to Position Meta as the AI Optimist

What: Mark Zuckerberg launched a coordinated AI-optimism campaign on July 23—a Facebook post plus a paid and earned media push—arguing that Meta’s mission of connecting people will be strengthened, not undermined, by AI. The ad copy is pointed: “Some people will have you believe AI will make us less connected, that it’s going to leave us behind. We couldn’t disagree more... we’re betting on people.” Axios notes the campaign is framed as a deliberate contrast with rivals who have issued public warnings about AI’s impact on jobs and security, and follows Meta’s “personal superintelligence” positioning from last year.

So What: The major labs are now running differentiated narrative strategies, not just differentiated models: Meta is selling optimism and accessibility to consumers while competitors emphasize enterprise trust, safety infrastructure, and candid risk talk. For buyers this is mostly signal about incentives—a vendor’s public story about AI’s societal impact shapes what it builds, what it discloses, and how it responds when something goes wrong. Marketing optimism is not evidence about outcomes, in either direction.

Now What: Read vendor positioning as a strategy document, not a weather report: when evaluating platforms, separate the narrative (optimist, safety-first, open) from the governance and disclosure practices you can verify. If your leadership asks “should we be worried or excited” this week, the honest answer is that the companies loudest on each side are both selling something. Read more

Trust Has a Price Tag

Three stories this week put hard numbers and hard tools on things that used to be abstractions. Training-data provenance now costs $1.5 billion when it goes wrong. Authorship provenance now has a reader-facing scan button. And the neutral layer that lets you switch AI vendors is reportedly worth $10 billion to a buyer. Trust in the AI stack is being priced, feature by feature—and it belongs in your diligence the same way uptime does.

The Largest Copyright Settlement in U.S. History Is Final: Anthropic Will Pay Authors $1.5 Billion

What: A federal judge gave final approval on July 20 to Anthropic’s $1.5 billion settlement of the class-action copyright suit brought by authors and publishers, clearing the way for payouts of $3,000 per work across an estimated 500,000 books. The underlying rulings cut both ways: the court held that training on copyrighted text is fair use, but that Anthropic’s downloading of books from pirate libraries was illegal on its own terms—and it was the piracy exposure that drove the settlement. Because Anthropic settled rather than appeal, neither ruling becomes binding precedent, and parallel suits against Google, Meta, OpenAI, and Midjourney continue, including a fresh publisher class action against Google filed the week before.

So What: The most consequential AI copyright case just closed without settling the law. Fair-use-for-training survived at the district level, but every other lab still faces its own facts in front of its own judge, and the $1.5 billion number is now the anchor for what data-provenance failures cost. For buyers, this shifts copyright from an abstract industry risk to a quantifiable vendor-diligence line: how a vendor sourced its training data has a demonstrated ten-figure price tag.

Now What: Check your AI vendor contracts for indemnification against training-data claims—post-settlement, this is a standard ask, and vendors’ willingness to give it tells you how confident they are in their own provenance. If you’re generating revenue-critical content with AI, have legal track the remaining cases; a contrary ruling in one of them would change the risk calculus for the whole stack. Read more

Substack Ships an AI-Detection Feature and Tries to Name a New Problem: “Claudefishing”

What: Substack CEO Chris Best published “Against Claudefishing” on July 21, announcing a partnership with AI-detection firm Pangram that lets readers scan posts, notes, replies, and comments to estimate how much of the text was written by hand versus with AI assistance. The feature works on text over 100 words published from launch day forward, and creators get tools too: a “How I make this” process statement, pre-publication scans of their own drafts, and the ability to dispute mistaken scans. Best defines Claudefishing as the mismatch between a reader’s expectation of human authorship and the reality of machine-generated text—citing estimates that as much as 40% of text on some social platforms is now AI-generated—while stressing Substack isn’t against AI-assisted work, just undisclosed AI-generated work.

So What: A major content platform just made authorship provenance a reader-facing feature, and the framing matters more than the tooling: the line being drawn is disclosure, not AI use. That’s the same line your organization’s content operation will be judged against as detection tools spread—thoughtful AI-assisted work is defensible; work your audience assumed was human and wasn’t is a trust incident. Expect the “scan this” reflex to migrate from Substack to LinkedIn posts, thought-leadership bylines, and marketing content generally.

Now What: Get ahead of detection rather than reacting to it: decide now what your disclosure posture is for AI-assisted external content, and consider a “how we make this” statement for content programs where trust is the product. Run your own published content through a detector before someone else does—knowing what it flags is cheap insurance. Read more

Stripe Is Reportedly in Talks to Buy OpenRouter for ~$10 Billion

What: The Wall Street Journal reported on July 23 that Stripe is in talks to acquire OpenRouter, the marketplace that lets developers access and route across hundreds of AI models through a single API, in a deal that could value the startup near $10 billion. That’s roughly 7x the $1.3 billion valuation OpenRouter set in its Series B just two months ago, in May. The talks remain fluid and could still fall apart or attract rival bidders—The Information reported earlier in the week that multiple large technology companies had been circling. OpenRouter serves millions of developers, routes across 400+ models, and already runs its payments on Stripe.

So What: A payments giant paying ten billion dollars for the neutral routing layer tells you where the industry thinks value is settling: not in any single model, but in the switchboard that arbitrates among them. As model quality converges and prices keep moving, the ability to compare, switch, and route workloads across providers becomes the durable position—and if Stripe closes this, model routing and payment rails start consolidating into one vendor relationship. Whoever owns the router sees everyone’s usage patterns.

Now What: If you use OpenRouter or any model-routing layer, add ownership change to your vendor-risk watchlist—routing neutrality is the product, and an acquirer’s incentives can change it. More strategically, treat this as validation of a multi-model posture: the market just priced optionality across models at $10 billion, which is a strong argument against wiring your stack to a single provider’s API. Read more

Blank Metal is an AI consulting and engineering firm. We help organizations move from AI experiments to production systems. Learn more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

Keys, Browsers, and a Retreat

The agent story this week wasn’t just capability—it was infrastructure, and not every bet paid off. Credentials an agent can use but never see, a sandboxed browser inside the coding tool, and a rival’s own agentic browser folded back into its main app after nine months. The pieces that make agents deployable, not just impressive, are arriving—and some of last year’s experiments are already being retired.

1Password Now Lets Claude Log Into Websites Without Ever Seeing Your Passwords

What: 1Password shipped an integration on July 16 that lets Claude sign into websites during agentic browser tasks while keeping credentials completely out of the model’s reach. Approved credentials are delivered through a secure channel and injected directly into the destination page—passwords and one-time codes never enter Claude’s context, memory, or Anthropic’s systems. Users approve each credential request biometrically, permissions last only for the current session, and 1Password’s new Agentic Mode restricts vault access to approved credentials only. Available now on Mac for business, family, and individual plans; payment cards and identity data support is coming.

So What: This is the missing infrastructure piece for agents that do real work. Most enterprise agent use cases die at the login screen—either the agent can’t authenticate, or someone pastes credentials into a prompt and creates the exact exposure the security team feared. Credential injection that bypasses the model entirely is the right architecture, and it’s notable that it came from the password manager, not the AI vendor: the trust boundary stays with the tool your security team already governs.

Now What: If your teams are experimenting with browser-driving agents, this pattern—credentials injected below the model layer, scoped per session, approved per use—is the standard to hold every vendor to. Ask whoever pitches you an agentic workflow the blunt version: does the model ever see a secret? If the answer involves the words “in the context window,” keep shopping. Read more

Claude Code’s Desktop App Now Has a Built-In Sandboxed Browser

What: Anthropic added an in-app browser to Claude Code on desktop on July 10. Claude can open documentation, designs, production apps, or any website, then read, click through, and interact with pages the same way it works with local dev servers. The browser is sandboxed and configurable—users choose whether sessions persist.

So What: The boundary between “coding agent” and “agent that uses your software” keeps dissolving. An agent that can open your staging environment, click through the flow it just built, and see what a user sees closes the loop that previously required a human tester—which changes both what one engineer can verify and what your review process needs to catch. The sandboxing and session-persistence controls matter as much as the capability: this is the browser your agent uses, and it deserves the same policy attention as the browser your employees use.

Now What: If your engineering teams run Claude Code, treat the in-app browser as a governance surface from day one: decide which environments agents may touch (staging yes, production admin panels probably not), and whether persistent sessions—which can carry logged-in state—fit your access policies. Then put it to work: agent-driven verification of the agent’s own output is one of the highest-payoff QA upgrades available right now. Read more

OpenAI Shuts Down Its Standalone AI Browser After Nine Months

What: OpenAI announced on July 9 that it will discontinue ChatGPT Atlas, the standalone agentic browser it launched in October 2025, with the app stopping work entirely on August 9. Atlas’s browsing and agentic features are being folded into an upgraded ChatGPT desktop app and a new Chrome extension instead of surviving as their own product, alongside the launch of “ChatGPT Work,” an enterprise-focused office suite. User data—bookmarks, history, saved logins—won’t transfer automatically; OpenAI is telling users to export it manually before the shutdown date. The move follows widely reported struggles for Atlas, including a slow agent mode and prompt-injection security concerns.

So What: This is the same week Claude Code added a sandboxed in-app browser, and the contrast is instructive: Anthropic is building browsing into its coding tool as a targeted capability, while OpenAI is retreating from a standalone browser bet and rerouting the same idea back into its core chat product. Dedicated AI browsers are having a rough year—the standalone-app approach hasn’t found footing against Chrome’s install base, even backed by a company with ChatGPT’s distribution. If you evaluated or piloted Atlas for any workflow, that pilot now has an expiration date, not a roadmap.

Now What: If anyone on your team adopted Atlas for agentic browsing, put August 9 on a calendar now and export bookmarks, saved logins, and history before then—none of it moves automatically. More broadly, treat this as a data point on where agentic browsing actually lives: increasingly inside the tools people already have open, not in a separate browser they have to remember to launch. Read more

The Token Bill Comes Due

Three data points on AI economics arrived the same week, and they don’t all point the same way. Unit prices keep falling toward commodity territory, total spend keeps exploding anyway, and the company that makes nearly every advanced AI chip on Earth just raised its own capital bet by billions. The gap between falling prices and rising bills is your finance team’s new problem—and it’s also why the chip queue isn’t getting any shorter.

Benedict Evans: Everything Observable Points to Tokens Becoming Commodity Infrastructure

What: Benedict Evans published “Ways to think about token pricing” on July 9, a framework for whether foundation models keep pricing power or become low-margin infrastructure. His four variables: how much demand actually requires frontier models versus cheaper alternatives; whether capability keeps improving faster than prices erode; whether the market consolidates or stays fragmented among near-equivalents; and whether value accrues to model makers or to the products built on top. His conclusion: every dynamic currently visible points toward commodity outcomes—”something needs to happen that we don’t see yet” for models to avoid it—with mobile data carriers as the cautionary comparison: explosive usage growth, minimal value capture.

So What: For buyers, commoditization is mostly good news with a planning catch. Good news: the price of any fixed capability level keeps falling, and switching costs—not loyalty—are the only thing that locks you in. The catch: your vendors know this too, which explains this year’s pattern of platforms racing up the stack into agents, workspaces, and deployment services where margins might survive. The model API you’re buying today is the loss leader for the platform they want to sell you tomorrow.

Now What: Negotiate like the commodity thesis is true: shorter commitments, portability preserved (avoid proprietary embeddings and vendor-specific agent frameworks where practical), and re-price your model mix quarterly as capability-per-dollar improves. But evaluate the platform layer like it’s sticky—because it is. The switching cost that matters in 2027 won’t be the model; it’ll be the agent workflows your teams built around one vendor’s harness. Read more

Ramp’s CEO: Token Spend Went From Rounding Error to 10% of Payroll in a Year

What: Ramp CEO Eric Glyman said publicly on July 16 that the company’s AI token spend grew from a rounding error to more than 10% of payroll in a single year—including one week in May that burned $1.5 million. “AI is extremely good at spending your money very quietly,” he wrote, adding that his CFO didn’t love reporting the number internally, “and he really didn’t love telling the internet.”

So What: This is what the new cost center looks like when a sophisticated, AI-forward finance company runs the experiment honestly—and it lands the same week Benedict Evans argues tokens are commoditizing. Both are true: unit prices fall while total spend explodes, because usage grows faster than prices drop. Token spend is becoming a real budget line with none of the controls that surround comparable line items like cloud infrastructure—no showback, no per-team budgets, no anomaly alerts. A $1.5M week you discover after the fact is an instrumentation failure, not an AI failure.

Now What: Get token spend into your FinOps practice now, while the numbers are still small enough to instrument calmly: per-team visibility, workload-level attribution, budget alerts before the invoice, and a standing review of which workloads could route to cheaper models. If your AI spend doubled next quarter, would you learn about it from a dashboard or from finance? If the answer is finance, start there. Read more

TSMC Posts a Record Quarter and Raises Its 2026 AI Capex by Up to $12 Billion

What: TSMC reported record second-quarter revenue of $40.2 billion on July 16, up 36% year-over-year, and raised its 2026 capital expenditure guidance from $52-56 billion to $60-64 billion in a single revision. The company also lifted its full-year revenue growth forecast above 40% and announced an additional $100 billion investment in its Arizona operations, on top of facilities already announced there. Leadership pointed to demand for AI chips and advanced packaging capacity as the driver, and signaled that capital spending over the next three years will run well above the last three.

So What: This is the supply side of the same story Evans and Ramp are telling from the demand side this week: token prices may be falling and CFOs may be sweating their AI bills, but the company that makes nearly every advanced AI chip on Earth just bet billions more that demand keeps outrunning capacity. A capex raise of this size, from the industry’s most scrutinized capital allocator, is a stronger signal than any single lab’s roadmap slide. If TSMC believed the AI buildout were topping out, this is not what its spending would look like.

Now What: Read this alongside your own vendor cost conversations: chip scarcity and pricing pressure at the infrastructure layer are a real constraint on how fast model prices can fall, regardless of what the commodity-pricing thesis predicts longer-term. If your planning assumes steadily cheaper frontier models next year, stress-test that assumption against a supply chain that’s still capacity-constrained by its own admission. Read more

Sierra Published the Most Useful Field Report Yet on Running a Company Through AI Agents

What: Sierra’s engineering leadership published “AI-pilling our company: lessons learned” on July 9, documenting how the company systematically deployed AI agents across its own organization after seeing roughly 5x productivity gains in January. The five lessons: consolidate role-specific agents into a single agent that works across teams; make agents persistent across days and weeks rather than request-scoped; treat context—not model intelligence—as the bottleneck; run the agent as the interface over existing systems of record (GitHub, Salesforce, Linear) rather than replacing them; and measure business outcomes, not activity. Adoption stats from the post: 75,000+ sessions and 70% of pull requests opened through their internal agent.

So What: This is a rare artifact: a company that builds agents for a living showing its own internal homework, with the failures included. Two lessons deserve particular attention. “The bottleneck has moved to context” matches what shows up in every serious deployment—the model is capable enough; what’s scarce is structured access to your workflows, history, and judgment calls. And “agent as interface, systems of record underneath” is the architecture question most organizations get wrong in year one by trying to replace systems instead of layering over them.

Now What: If you’re deploying agents internally, steal the measurement discipline before the architecture: define the business outcome per workflow (faster deals, first-pass resolution, hours returned) before counting sessions or tokens. And pressure-test the single-agent lesson against your org: if your pilot has five siloed bots, ask what an agent that follows work across team boundaries would need to know—that’s your context inventory. Read more

Trust, Gained and Lost

Anthropic spent the week shipping accountability: a feature that asks whether you’re using Claude too much, and a former Fed chair joining the body that oversees its board. Apple spent the same week accusing a rival AI lab of a coordinated scheme to steal its hardware trade secrets. Vendor trustworthiness is being built deliberately on one side and unraveling in public on the other—and both belong in your diligence.

Anthropic Ships a Feature That Asks Whether You’re Using Claude Too Much

What: Anthropic released Reflect on July 9, a beta feature that lets users examine their own Claude usage: activity visualizations across 1-12 month windows, breakdowns of peak times and task categories, scheduled quiet hours, and periodic reflective prompts like “What’s one thing you want to keep doing yourself, even if Claude could do it faster?” It ties into Anthropic’s 4D fluency framework (delegation, description, discernment, diligence) and was built in consultation with MIT Media Lab and Boston Children’s Hospital’s Digital Wellness Lab. Available in beta for Free, Pro, and Max users with memory enabled; Cowork support is coming.

So What: A vendor shipping a feature that questions its own usage-based revenue is worth pausing on. Read it as positioning for the durable relationship: as AI becomes ambient in daily work, the interesting question shifts from “how much are people using it” to “are they using it well”—delegating the right things, keeping judgment on the things that build skill. That’s the same question your enablement program should be asking, and until now nobody had instrumentation for it.

Now What: When Cowork support lands, Reflect becomes a lightweight enablement diagnostic: usage patterns by task category are exactly the data an adoption program needs and almost never has. In the meantime, borrow the reflective prompt for your own rollout—asking teams “what should stay human even though AI could do it faster” surfaces where your people think the judgment actually lives, and that map is worth more than any usage dashboard. Read more

Ben Bernanke Joins the Trust That Can Fire Anthropic’s Board

What: Anthropic appointed former Federal Reserve Chair Ben Bernanke to its Long-Term Benefit Trust on July 9. The LTBT is the independent body in Anthropic’s governance structure designed to hold the company accountable to its public-benefit mission, including the power to appoint board members. The same day, Anthropic launched “Inviting hard questions,” a standing commitment to publicly answer difficult questions about AI’s trajectory.

So What: Vendor governance is due-diligence material now, not press-release filler. The economist who managed the 2008 financial crisis joining the body that oversees a frontier lab’s board tells you how seriously the economic-disruption dimension of AI is being treated at the top of the industry—and for buyers making multi-year platform bets, the structure of who can check a vendor’s decisions is part of the risk profile you’re buying. It’s also a differentiation signal in how the major labs are courting the enterprise: stability and accountability as features.

Now What: Add governance structure to your vendor evaluation checklist alongside SOC 2 and uptime: who holds the vendor accountable, what happens to your contract terms under ownership or mission changes, and what the vendor has committed to publicly. You’re not just buying tokens—you’re coupling your operations to an institution. Institutions deserve institutional diligence. Read more

Apple Sues OpenAI, Alleging a Coordinated Scheme to Steal Hardware Trade Secrets

What: Apple filed suit against OpenAI on July 10 in the Northern District of California, alleging that OpenAI and two former Apple employees—ex-engineer Chang Liu and ex-VP Tang Tan, now OpenAI’s chief hardware officer—ran a coordinated effort to obtain Apple’s confidential product designs, manufacturing processes, and supply chain information for OpenAI’s in-development consumer hardware. The complaint names OpenAI’s corporate entities and io Products, the hardware startup OpenAI acquired last year, and alleges Liu kept an Apple-issued laptop after leaving and used it to access confidential files, while Tan allegedly used insider terminology to extract information from Apple employees interviewing at OpenAI. OpenAI has denied the allegations, saying it has “no interest in other companies’ trade secrets.”

So What: Whatever the merits, the suit lands the same week Anthropic added a Nobel laureate economist to its oversight trust and shipped a usage-transparency feature—both moves aimed at making “trustworthy vendor” a visible, checkable attribute. A rival simultaneously facing detailed, court-filed allegations of a top-down culture of IP theft is the sharpest possible contrast, regardless of how the case resolves. For enterprises with active or prospective OpenAI contracts, this is genuine reputational and legal-exposure due diligence now, not just industry gossip.

Now What: This doesn’t require action today, but it belongs in your next vendor-risk review: track how the litigation develops, and specifically whether it touches any product or team your organization actually relies on. Don’t let “the lawsuit is about hardware, we just use the API” be the end of the analysis—ask your legal team whether litigation like this has any bearing on the data-handling representations a vendor has made to you. Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

THE AGENTIC WORKSPACE IS THE NEW BATTLEGROUND

The chat window was never the endgame. This week OpenAI shipped a long-running agent aimed at finished work products, Cursor’s general-purpose agent leaked, and small companies demonstrated the endpoint of the trend: when agents can build and operate software, the software you rent starts competing with the software you can suddenly afford to own.

OpenAI’s ChatGPT Work Turns the Chatbot Into a Long-Running Agent—With Admin Controls on Day One

What: On July 9, OpenAI introduced ChatGPT Work, a long-running agent built on Codex technology that works across connected apps and files for hours, breaking projects into steps and producing finished documents, slides, spreadsheets, and web apps. It ships with a unified plugins directory (Slack, Teams, Google Drive, SharePoint, Salesforce, email, CRMs), scheduled tasks, a built-in browser, and background desktop automation. The enterprise surface includes a Compliance API for visibility into Work conversations and actions, admin-configurable spend controls with per-group usage limits, and an “Auto-review” gate on high-risk connected-tool actions before they execute. Codex now counts more than 5 million weekly users—over a million of them using it for non-coding work. Published customer results include NVIDIA cutting roughly 40% of its GTC event-prep time and RingCentral running one program manager’s support across about 50 PMs.

So What: The agentic workspace—an AI that holds context, touches your systems, and delivers finished work products—is now a category both major labs compete in directly, and OpenAI’s opening move is aimed squarely at the enterprise buyer: governance controls arrived with the launch, not a year later. That’s a competitive tell worth internalizing. It also changes the cost conversation—long-running agents on usage-based pricing can consume tokens at rates that surprise finance, which is exactly why the spend controls exist.

Now What: If you’re piloting an agentic workspace, you now have a genuine bake-off—run the same three real workflows through the contenders and score output quality, governance surface, and cost per completed task. Whichever you choose, configure spend limits and the high-risk action gates before broad enablement, not after the first surprising invoice. And test the Compliance API against what your audit function actually needs; “visibility” claims deserve verification. Read more

Cursor Is Building “Sand,” a General-Purpose Agent—While a $60 Billion Acquisition Hangs Over It

What: The Information reported that Cursor is developing a general-purpose agent internally codenamed Sand—its first product aimed at non-developers, positioned to reply to emails, organize spreadsheets, and act as a personal assistant for everyday work. It rolled out internally in late June with no confirmed public launch date. The backdrop: Cursor has been leasing compute from SpaceX’s AI unit since April, and SpaceX’s reported $60 billion acquisition of Cursor is expected to close in the second half of the year—which The Information notes could reshape the roadmap, including whether Sand ships at all.

So What: The category walls are coming down. A week in which OpenAI shipped ChatGPT Work and Cursor’s general-work agent leaked means the segmentation many buyers use—coding tools over here, work assistants over there—no longer matches vendor roadmaps. Every serious agent vendor is converging on the same target: the full span of knowledge work. The pending acquisition is the other signal: consolidation at the tooling layer is arriving before most companies have finished their first vendor evaluation.

Now What: Stop evaluating “coding assistant” and “work assistant” as separate procurement categories—assess agent vendors on the full range of work your teams will route through them within a year. And weight vendor stability accordingly: a tool whose ownership and roadmap are in flux deserves a shorter commitment and a cleaner exit path, however good the product is today. Read more

Small Firms Are Quitting Salesforce for Apps They Built With Claude—and Wall Street Noticed

What: The Information reported July 6 that smaller companies are replacing enterprise software with custom applications built using AI tools. The lead example: a 55-person Atlanta real estate investment manager that saved about $100,000 a year by replacing its Salesforce CRM with an app built on Replit and Claude Code; small businesses in the piece report saving $500 to $2,000 a month. Three days later, KeyBanc and Bernstein both downgraded Salesforce, citing weak customer feedback on Agentforce and a CIO survey showing more IT leaders plan to cut Salesforce spend next year than increase it. The stock fell about 3%.

So What: The build-versus-buy floor just moved. For decades, “build” meant a development team, a budget, and a maintenance tail that made SaaS the obvious answer for anything non-core. AI-assisted development is repricing that equation from the bottom of the market upward—and the analyst downgrades show the pressure reaching incumbent revenue expectations. The honest version of the story still matters, though: a CRM you built is a system you now operate, patch, and secure. The savings are real; so is the ownership.

Now What: Before your next major SaaS renewal, price the AI-assisted internal build honestly—including maintenance, security, and the person who owns it—and bring that number to the negotiation whether or not you’d actually build. The leverage is real either way. Start with the systems where you use 10% of the features and pay for 100%; that’s where the math flips first. Read more

MODEL ECONOMICS TURN RUTHLESS

Beneath the product launches, the money moved. A new flagship arrived priced for fleets of agents, Microsoft showed that even it routes models by cost per surface, a third of US enterprise tokens quietly shifted to Chinese models, and the vendors started giving compute away like it’s customer acquisition—because it is.

GPT-5.6 Arrives in Three Sizes, With Parallel Agents as the Default

What: OpenAI released GPT-5.6 on July 9, a new flagship family in three tiers: Sol at $5/$30 per million input/output tokens, Terra at $2.50/$15, and Luna at $1/$6. A new “ultra” mode runs four agents in parallel by default. OpenAI’s published claims: 53.6 on Agents’ Last Exam (against roughly 40.5 for Claude Fable 5), a record 80 on the Artificial Analysis Coding Agent Index, and 92.2% on the BrowseComp agentic-search benchmark. The day before, OpenAI shipped GPT-Live, a full-duplex voice model family that listens and speaks simultaneously and delegates deeper reasoning to GPT-5.5 mid-conversation—it now powers ChatGPT Voice, with API access on a waitlist.

So What: Two things are worth separating from the launch noise. First, the pricing ladder plus parallel-agents-by-default tells you where OpenAI thinks the volume is going: not single conversations but fleets of agents, priced so that routing work across tiers is the intended usage pattern. Second, the headline benchmark numbers are vendor-reported at launch—every lab’s are—and the deltas that matter are the ones on your workloads, not on a leaderboard. Frontier launches now arrive at a monthly cadence; the buyers doing well treat them as routine supplier updates, not strategy events.

Now What: Don’t migrate anything on launch-day claims. Re-run your own evals against GPT-5.6’s tiers and check whether Luna or Terra clears your quality bar for high-volume workloads before paying Sol prices—the same per-workload routing discipline that applies to every model family. If you have voice or contact-center use cases on the roadmap, get on the GPT-Live API waitlist now so you can evaluate early rather than react late. Read more

Microsoft Swapped Its Own Models Into Office—Then Named GPT-5.6 Copilot’s Preferred Model Two Days Later

What: Bloomberg reported July 7 that Microsoft has begun replacing OpenAI and Anthropic models with its in-house MAI models in Excel, Outlook, and parts of GitHub Copilot to cut AI costs—alongside an internal memo saying Copilot needs to “earn the right to exist.” Two days later, OpenAI announced that GPT-5.6 is now the preferred model in Microsoft 365 Copilot, integrated into Word, Excel, PowerPoint, and Copilot Chat via direct OpenAI API access rather than Azure hosting. Both are true at once: Microsoft is routing high-volume, routine surfaces to cheaper in-house models while putting the newest frontier model behind its flagship experiences.

So What: The world’s largest software company just showed everyone its model strategy, and it’s neither loyalty nor lock-in—it’s per-surface routing on cost and capability. That’s worth more than any analyst framework: if Microsoft won’t run frontier models where cheaper ones clear the bar, the single-vendor default was never a strategy, it was a phase. The other implication is subtler: the models behind the AI features you license are being swapped continuously, and vendors don’t send a notification when the engine changes under a feature your team depends on.

Now What: Treat embedded AI features as versioned dependencies. Ask your major software vendors which models power the features you rely on, whether that changed this quarter, and what notice you get when it changes again. Then spot-check your critical AI-assisted workflows on a regular cadence—if output quality shifts and you don’t have a baseline, you won’t know whether the vendor’s router moved your workload to a cheaper model. Read more

A Third of US Enterprise Tokens Are Running on Chinese Models

What: CNBC reported that the share of tokens US companies route to Chinese AI models through OpenRouter has stayed above 30% every week since early February, peaking at 46%—averaging 11% over the trailing twelve months, up from about 4.5% in the first half of 2025. The draw is price-performance: Z.ai’s GLM 5.2 landed within a percentage point of Claude Opus 4.8 on a closely watched agentic benchmark at roughly one-fifth the cost, and Chinese open-weight models run 60-90% cheaper than leading US frontier models. GLM 5.2’s launch was the fastest adoption Vercel has tracked this year—daily token volume up roughly 27x in its first full week. One startup CEO said he moved 100% of traffic from Claude to DeepSeek in June and expects to save millions. Brookings puts Chinese models six to nine months behind the US frontier.

So What: Cost gravity is doing what cost gravity does—but this migration carries questions the price sheet doesn’t answer. Model provenance is now a governance variable in a way it wasn’t a year ago: June’s export-control episode showed model availability can change by government order, and routing corporate data through models with different jurisdictional and security postures is a decision your risk function should make on purpose, not one that happens by default inside a routing layer chasing the cheapest token. Plenty of workloads can tolerate that trade; the point is knowing which of yours are making it.

Now What: Find out—concretely—where your AI traffic actually runs, including inside vendors and gateways that route on your behalf; ask for model provenance disclosure in writing. Then set an explicit model policy by data classification: which model families are eligible for which workloads. If you’re in a regulated industry, an allowlist beats a discovery. The savings are real and worth pursuing—with your eyes open and your sensitive data fenced. Read more

AI Vendors Are Giving Away Millions in Compute—While Tesla Rations It at $200 a Week

What: The Wall Street Journal reported that AI providers are showering startups with free computing power to win platform share: some early-stage companies have received credit offers worth more than $3 million from competing providers—roughly the size of a median US seed round—with Google offering up to $500,000 in cloud credits plus early model access, and OpenAI, Anthropic, Microsoft, and AWS all running expanded credit programs. Drivers cited include margin pressure ahead of anticipated IPOs and price erosion from cheaper open-weight models. Some founders say the credits are rich enough to delay their next funding round. The same week, The Information reported Tesla capped employee AI spending at $200 per week as part of its adoption push.

So What: Both stories are about the same thing: tokens became a line item big enough to fight over. The credit war tells you the platforms believe early workload placement hardens into long-term commitment—free compute is customer acquisition, and what gets acquired is your architecture. Tesla’s cap is the other side: even at an aggressively AI-forward company, per-employee token spend grew fast enough that finance reached for a blunt instrument. Most companies will face the internal version of this before the external one.

Now What: If you qualify for credit programs, take the money—but audit what you’re building for portability first: proprietary embeddings, vendor-specific agent frameworks, and fine-tuned models are the dependencies that hurt when the credits expire and list price arrives. Internally, get ahead of the Tesla moment: give teams token budgets with visibility instead of waiting for a blanket cap—rationing by spreadsheet is what happens when nobody instrumented usage. Read more

DELIVERY IS WHERE THE MONEY WENT

Follow the billions and a pattern emerges: Microsoft put $2.5 billion behind embedded delivery, 6,000 engineers converged on supervising fleets of agents instead of driving them, and a survey quantified what happens when adoption outruns governance. The gap between having AI and operating it well is the industry’s biggest line item.

Microsoft’s $2.5 Billion “Frontier Co.” Makes Embedded AI Delivery a Four-Way Race

What: On July 2, Satya Nadella announced Frontier Co., a Microsoft unit backed by $2.5 billion and roughly 6,000 business and engineering experts who embed directly with enterprise customers to build AI capability in-house, led by longtime enterprise executive Rodrigo Kede Lima. The unit is deliberately multi-model—supporting OpenAI, Anthropic, Microsoft’s own models, and open-source, chosen per workload—and carries an explicit IP commitment: customer data is never used to train models in ways that dilute the customer’s differentiation. Early named engagements include the London Stock Exchange Group, Land O’Lakes, Unilever, and Novo Nordisk. Microsoft’s commercial chief said it “goes beyond what has been labeled as Forward Deployed Engineering.”

So What: This is the fourth major vendor in roughly six weeks to conclude that models don’t deploy themselves: OpenAI and Anthropic launched PE-partnered deployment ventures in May (about $4 billion and $1.5 billion respectively), Amazon committed $1 billion on June 30, and Microsoft has now topped the field on headcount and dollars—funded internally rather than through a joint venture. When every vendor builds a billion-dollar bridge across the same gap, believe the gap: the distance between licensing AI and operating it is the hard part, and it’s where the money is going. Microsoft’s multi-model stance is the second tell—even the company with the deepest OpenAI ties won’t bet your deployment on one lab.

Now What: If a vendor offers to put engineers inside your walls, evaluate structure, not just capability: who owns the IP that gets built, what data do embedded engineers touch, and what does your team demonstrably operate without them after the engagement ends? Microsoft’s IP-protection language exists because customers demanded it—demand the same from anyone you let in, and put the capability handoff in the contract. Read more

What 6,000 AI Engineers Converged On: Software Factories

What: The AI Engineer World’s Fair wrapped July 2 in San Francisco with more than 6,000 attendees, and the dominant theme was what speakers called software factories—systems that produce software continuously without a human driving each coding agent. Warp’s CEO put the thesis plainly: “software engineering will become factory engineering... you’ll be building the thing that builds the product,” demoing an orchestration platform that triages, implements, reviews, verifies, and monitors changes across multiple models and sandboxes. A dedicated security track wrestled with what that volume of machine-written code means for vulnerability surface. The economic backdrop: the price of a fixed level of model capability keeps falling 5-10x per year per Artificial Analysis and Epoch data, and Ramp’s June AI Index of 70,000+ businesses found top-1% firms spending about $7,500 per employee per month on AI against a median of about $11.

So What: The frontier of practice just moved from “engineers use AI coding tools” to “engineers supervise systems of agents that build software”—one person’s judgment applied across a fleet instead of a session. That changes the leverage math and the risk math simultaneously, which is why security shared the main stage. And the Ramp spread—roughly 700x between leading firms and the median—isn’t really a budget gap; it’s an operating-model gap that compounds monthly while capability prices fall.

Now What: If your engineering org is still evaluating individual coding assistants, fine—but plan the next step now: what do review, testing, and security look like when machine-generated changes grow 10x? The teams getting ahead of this invest in verification—evals, CI gates, review capacity—before scaling generation. Generation is cheap and getting cheaper; trust in what got generated is the part you have to build. Read more

78% of IT Leaders Report AI-Agent Security Incidents—and Half Have No Governance Program

What: A DigiCert survey of 1,001 IT leaders published July 7 found that 78% report AI-agent-related security incidents in the past six months, while only about half have formal AI governance programs in place. The gap lands in a week when agents gained desktop automation, connected-app access, and longer autonomous runtimes across every major platform.

So What: Agent adoption outran agent governance, and the incident rate says the bill is arriving now, not in some future planning horizon. The pattern underneath is familiar from every prior platform shift: capability ships quarterly, governance gets built after the first incident report. What’s different is the blast radius—an agent with connected-tool access and scheduled autonomy is an actor in your environment, and most identity, logging, and access frameworks were built assuming actors are people.

Now What: If you have agents in production—or employees who quietly do—stand up the minimum viable governance now: an inventory of what agents exist and what they can touch, scoped credentials instead of borrowed human ones, logging that captures what agents actually did, and a human gate on the actions you’d fire a person for taking unilaterally. The platforms are starting to ship these controls natively—this week’s launches included spend limits and action review gates—but they only work if someone turns them on. Read more

Picture a typical enterprise AI rollout: three thousand licenses, a ninety-minute onboarding, a slide deck with screenshots. Six weeks later, leadership pulls up the usage dashboard and finds that no one has actually adopted the platform into their workflow. Or, on the opposite end of the spectrum, usage explodes, token costs spike, but nobody can explain what the company actually got for it. A lack of training is not the issue. New tools call for new training methodologies.

Teresa Marchek, our co-founder and Head of Enablement, has spent fifteen years building learning programs that change how people work. Her diagnosis: the playbook that worked for every enterprise tool before AI was optimized for a world with defined destinations: Here’s how you update a record in Salesforce. Here’s how a ticket moves through ServiceNow. You wrote the correct workflow down, taught it, and measured whether people followed it. Completion equaled deployment.

AI tools like Claude Code and Cowork don’t have a correct workflow. Their value comes from inventing them. Imagine a procurement manager who builds their own contract-review tool, an HR lead who automates the onboarding process, or a finance analyst who enlists a reporting assistant on a Tuesday afternoon. Those examples barely scratch the surface of what people can use and are using Code and Cowork to do, but that open-endedness also presents a problem: you can’t train toward a destination that doesn’t exist. That’s what most rollout playbooks are missing.

Subscribe now

What the proven playbook gets right

These are a set of tested psychological principles that successful tech rollouts of the past have utilized to their advantage:

• People forget fast. We lose most of what we learn within days of a training event.1 A single session, no matter how good, will inevitably fade. Spacing reinforcement over four to eight weeks triples retention.2 On-the-job experience can’t bridge that gap on its own; it needs structure and managers who actively coach.

• Knowledge is rarely the real barrier. Lack of information doesn’t cause resistance. The real killer is lack of motivation. Mid-level managers carry more resistance than any other group, which is exactly why they need to be activated early, not treated as message-relayers.3

• Habits don’t form through willpower. A behavior requires three things to happen concurrently: motivation, ability, and a prompt.4 Motivation waxes and wanes. Ability and prompts you can engineer deliberately.

Microsoft’s Copilot enablement program is often held up as a standout. Their public adoption playbook combines executive sponsorship, celebrating Copilot “champions” (successful early adopters), a user community, phased rollout, and continuous usage measurement.5 The formal training is more of an afterthought. The reinforcement infrastructure, not the class, drives sustained usage.

The destination disappeared

With Salesforce, ServiceNow, and other collaborative tools, there was always a correct workflow waiting at the end of training. You could write it down, teach it, and know when someone had it.

Claude Code and Cowork don’t work that way. The value is in their open-endedness: users invent the workflows rather than follow preset ones. A program built to certify task completion can’t produce people who build their own automations. Teaching defined steps in an open-ended tool gets you shallow, literal usage, and leaders wondering why the licenses sit idle. Mastery of Code and Cowork means judgment: knowing what to automate, how to verify AI output, when to trust it, and how to spot a good opportunity in your own work. That skill can be built, but it takes a different approach than standard task training.

When it comes to AI platforms specifically, there’s an extra layer of skepticism employees often have that also needs to be dealt with. People are anxious about AI taking their jobs, its environmental impacts, or how their data is being used. That’s an issue with willingness to learn rather than capability. AI hesitation can’t be corrected by another training module, but rather by open discourse that addresses these beliefs directly. This is a topic that’s big enough for another article (which is in the works), but long story short, situations where emotions are running high can’t be formally trained into submission.

Diffuse the capability, don’t just drive adoption

Major tech transformations before this one concentrated new capability in small groups. Cloud computing went to platform teams; CRM went to the admins. A small group got the new power, and everyone else consumed the outputs.

Claude Code and Cowork do the opposite. They put building, automating, and agent-creation into the hands of people who were never builders, such as that procurement manager who builds a contract review workflow, or the HR team lead who builds an onboarding automation.

That means the enablement problem is not just about proficiency, but diffusion. The goal isn’t to certify everyone on a workflow, it’s to spread the confidence to experiment across the organization, then let social proof carry it. As shown by Microsoft’s Copilot rollout, one viable approach is to identify early adopters, make their wins visible, and let the majority follow their lead. The role of these champions isn’t to run the training. It’s to build something real and show people that it’s possible for them to do the same.

This also changes what managers are for. Managers can’t reinforce a workflow that doesn’t exist. Their job in this rollout is to create permission and time to experiment, and to surface what their people invent. That’s a different task than reminding their team to log in. This shift has to be addressed explicitly, because most managers will default to the behavior their last ten rollouts trained them for.

Closing the gap between AI access and usage

Microsoft Copilot is the enterprise AI tool that has the most history at this point, so it’s a good one to look at to understand what the difference between average and good adoption looks like. Roughly 36% of employees given access to AI tools actively use them. And only about 42% of provisioned Copilot seats are active within six months in large enterprises.6 Access alone isn’t sufficient for adoption.

Strategic enablement programs can close most of that gap. Microsoft’s own 62,000-person sales organization hit 60% usage of allotted Copilot seats daily and 98% monthly active use two years in.7 Champions programs like that one drive two to three times higher activation versus self-service alone.8

The gap between 36% and 80%+ is exactly the gap that the mechanics described above are documented to close. None of those outcomes require promising anything that can’t be measured. The metric to look out for is sustained usage on real work, which you can only claim if you can see it happening. Agree on the definition of “active” before the rollout launches, get admin dashboard access, and measure behavioral changes, not reactions or test scores.

What to actually do

Here are five design principles, re-imagined for open-ended tools:

1. Inspire people to find an easy and real first win. Not “I finished the training,” but “I built something that saved me an hour.”

2. Brief managers as permission-givers, not enforcers. Their job is to clear time for experimentation and surface what people invent, not chase dashboards.

3. Build the champions program like it’s a main driver. Because it is. Visible peer wins are the mechanism, and everything else is support.

4. Spread reinforcement over four to eight weeks. This is proven to lead to more retention over cramming a lot of information into a short amount of time.

5. Measure behavior, not completion. Agree on what “active” means before launch, get dashboard access from day one, and track sustained use on actual work.

The organizations that win this rollout won't be the ones that trained the most people. They'll be the ones that built the most builders.

Blank Metal works with enterprises and PE-backed companies on AI implementation—including the enablement programs that make rollouts stick. If this is the problem you're working on, we'd be glad to talk.

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

Who Controls the Model

Three stories this week about power over the AI you depend on—a government that pulled a frontier model off the market, a platform owner watching its model vendor move in, and a software giant rebuilding its AI product mid-flight. The common thread: the models your teams rely on sit inside vendor, platform, and regulatory relationships that can shift under you.

The US Government Pulled a Frontier Model Off the Market—Then Put It Back

What: On June 12, a US export-control directive citing national security suspended foreign-national access to Anthropic’s Claude Fable 5 and Mythos 5—and because Anthropic had no way to verify nationality in real time, it disabled both models for everyone. The trigger was a report from Amazon researchers that a jailbreak got Fable 5 to identify software vulnerabilities and, in one case, produce exploit-demonstration code. The controls lifted June 30, and Fable 5 returned globally July 1. Anthropic’s own testing found the flagged capability wasn’t unique: Opus 4.8, GPT-5.5, and Kimi K2.7 identified the same vulnerabilities, and every model tested reproduced the exploit demonstration. A new classifier now blocks the reported technique in over 99% of cases, and Anthropic, Amazon, Microsoft, Google, and other partners are drafting a shared framework for scoring jailbreak severity, modeled on how the industry scores software vulnerabilities today.

So What: For two and a half weeks, a commercial model that teams had built into production workflows was unavailable—not from an outage or a deprecation, but a government order. Model availability is now a regulatory variable, and the capability that triggered the recall existed in essentially every frontier model tested, which means the precedent matters more than the incident. The proposed severity framework is the durable piece: if it sticks, it becomes the shared language for judging how bad a jailbreak actually is, the way CVSS did for software flaws. One practical footnote: Fable 5 is included in paid Claude plans for up to 50% of weekly usage limits only through July 7, after which it moves to metered usage credits.

Now What: Treat frontier-model dependence like any other concentration risk: put a routing layer between your workflows and any single model, keep a validated fallback, and actually rehearse the failover. If your teams standardized on Fable 5, budget for the July 7 billing change now. And watch the jailbreak-severity framework—it’s the early draft of how regulators and vendors will negotiate future recalls. Read more

Salesforce’s Anthropic Problem Is Now Internal

What: The Information reported this week that Salesforce employees are uneasy about Claude Tag, the AI teammate Anthropic launched inside Slack on June 23—some privately calling it a “Trojan horse” that could deepen Anthropic’s influence over Salesforce’s business customers. Salesforce publicly promoted the launch even though Claude Tag competes with its own Slackbot and Agentforce, which has reached $800 million in annual recurring revenue, up 169% year-over-year. The relationship is tangled: Salesforce expects to spend around $300 million on Anthropic tokens this year and holds roughly a 1% stake in the company. Anthropic, meanwhile, plans to expand Claude Tag beyond Slack to Microsoft Teams and email in the coming weeks.

So What: The agent that sits in front of your collaboration tools is contested ground, and the fight is between your platform vendor and your model vendor—both want to be the surface where work actually happens. Salesforce is simultaneously Anthropic’s distribution channel, its customer, its investor, and its competitor. That tension isn’t a corporate curiosity; it shapes what gets built, what gets priced how, and which product wins default placement in the tools your teams live in.

Now What: If you’re deploying agents inside Slack or Teams, expect overlapping offerings from the platform owner and the model vendors—and pick on the things that survive the fight: data boundaries, admin controls, and portability. Don’t wire your workflows so tightly to one assistant that you can’t swap it when the platform politics shift. The vendors’ entanglements are their problem; your exposure to them is yours. Read more

Microsoft Hands Copilot to a 33-Year-Old in a Hurry

What: Fortune profiled Jacob Andreou, the 33-year-old former Snap product executive Satya Nadella promoted to run Microsoft Copilot in March—one year after he joined the company. He now oversees more than 11,000 people. The urgency is visible in the numbers: only about 4.5% of Microsoft 365’s 450 million customers pay for Copilot features, and Microsoft shares are down double digits over the past year. Andreou is consolidating redundant Copilot versions, merging consumer and enterprise teams, and shifting toward consumption-based pricing—Copilot Cowork bills by model use and runtime, competing directly with Anthropic’s Claude Cowork. His own framing: “a six to twelve month roadmap doesn’t really exist in the way it used to.”

So What: A 4.5% paid attach rate on 450 million seats says something every buyer should internalize: bundled access doesn’t make an AI product stick—usefulness does. Microsoft handing its flagship AI product to a one-year veteran and rebuilding pricing mid-flight means Copilot’s packaging, pricing, and product shape are all in motion. For anyone with a Microsoft 365 agreement, that’s both a warning about roadmap volatility and a source of negotiating room.

Now What: If a Copilot renewal is on your calendar, don’t assume today’s SKUs or pricing survive the year—ask Microsoft directly how consumption-based pricing will apply to your agreement, and get protections in writing. Pull your actual usage data before the conversation: if your paid-seat utilization is low, you’re the norm, not the laggard, and that’s negotiating position. And run a genuine alternative evaluation—the consumption-pricing convergence means comparing vendors is getting easier, not harder. Read more

The Services Economy Reprices

Amazon put a billion dollars behind engineers who embed with customers, and the Wall Street Journal documented consulting’s messy retreat from the billable hour. Together they describe the same shift from two sides: expertise is being repriced around outcomes, and deployment—not advice—is becoming the product.

Amazon Commits $1 Billion to Forward-Deployed Engineers

What: AWS launched a new organization of AI-focused forward-deployed engineers on June 30, backed by $1 billion in internal resources and announced by VP of Frontier AI Francessca Vasquez. The engineers embed directly inside customer companies to deploy purpose-built agents, with an explicit emphasis on fast engagements and customer self-sufficiency—per Vasquez, customers “gain lasting AI skills, workflows, and patterns they can use to innovate independently.” Amazon is the third major player to stand up a forward-deployed practice in a matter of months: OpenAI’s joint venture is valued at $4 billion and Anthropic’s at $1.5 billion, both structured with private-equity partners. Amazon’s is wholly internal—no outside capital, no separate vehicle.

So What: When the three biggest names in frontier AI all conclude they need engineers physically embedded with customers, they’re admitting something about the product: models alone don’t produce outcomes—deployment does. For a buyer, the embedded market just got deeper and more competitive, and the differentiator to test is the self-sufficiency claim. An embedded team that leaves behind running systems, trained people, and reusable patterns is an investment; one that leaves behind dependency is a subscription with better marketing.

Now What: If you’re evaluating a forward-deployed engagement—from a hyperscaler, a lab, or anyone else—judge it on what remains after the engineers leave: systems running in your environment, skills your team demonstrably has, and patterns you can extend without calling for help. Put knowledge transfer in the contract, not the sales deck, and ask every vendor the same question: what does month one after your departure look like? Read more

Consulting’s Hourly-Billing Retreat Is Getting Messy

What: The Wall Street Journal reported June 26 on the professional-services industry’s uneven shift away from hourly billing. At a Deloitte town hall, an executive showed a chart projecting traditional hourly work shrinking to a sliver of the market by 2035, with AI agents growing to a majority of an expanding professional-services market. McKinsey says more than 30% of its global fees are now tied to client outcomes. But the transition is rough: Baker Tilly’s CEO notes buyers still compare bids on an hours-times-rate basis even when hours aren’t the pricing model, Big Four audit rules restrict outcome-tied compensation, and GPTZero’s CEO flagged a quality problem—fixed-fee pressure to produce more output is shipping AI-hallucinated errors in delivered client reports.

So What: Last week the market repriced the legacy consulting model in a day; this week’s story is what the transition actually looks like from inside—and what it means for anyone buying professional services. Two things are true at once: pricing is genuinely moving toward outcomes, which shifts risk toward the firms, and the pressure to produce more deliverables with fewer hours is creating a new failure mode—AI-generated work product that nobody fact-checked. The firm that cut its price 30% and the firm that cut its verification process can look identical in a proposal.

Now What: If you’re buying consulting, audit, or advisory work, negotiate the pricing model and the quality control in the same conversation. Push for outcome- or fixed-fee structures where the scope supports them, but add teeth: require disclosure of where AI is used in deliverables, what the verification process is, and who’s accountable for factual errors. An outcome-priced engagement with no accuracy clause just moves the hallucination risk onto you. Read more

Work Goes Agentic

The week’s product news and the week’s best essay converge on one point: the unit of AI work is no longer the chat exchange—it’s the delegated task. Agents run for hours, swarm across codebases, and get supervised from a phone. The job title that’s quietly emerging is agent manager.

The Chatbot Era Is Ending—The Agent-Manager Era Is Here

What: Ethan Mollick’s latest essay argues the defining shift of 2026 is from chatting with AI to assigning work to it. The evidence he assembles: Epoch found Claude Opus 4.7, working autonomously for 14 hours, built a software package equivalent to 2-17 weeks of human engineering work for $251 in tokens. A joint OpenAI-economist study found a quarter of OpenAI’s own workers run four or more agents simultaneously every week—with legal, HR, and other non-technical functions adopting agents at nearly the same rate as engineers. And a Claude Code study found profession didn’t predict success with agents; domain expertise did. Mollick’s summary: “We are moving from a world where non-experts use chatbots to fill in gaps to one in which experts use agents to get work done.”

So What: The operating model for AI inside a company is changing from “everyone gets an assistant” to “experts manage a portfolio of agents.” That reframes who benefits most—not the junior employee saving time on drafts, but the senior person whose judgment can direct and verify multiple autonomous workstreams. It also puts a shelf life on planning: as Mollick notes, any AI strategy written before late 2025 assumed a system could do a couple hours of work per prompt. The current answer is measured in double-digit hours, and the curve isn’t slowing to match anyone’s planning cycle.

Now What: Revisit your AI plans on a quarterly cadence and re-ask the foundational question: what can one prompt accomplish now? Train your domain experts—not just your engineers—to delegate to agents and verify their output, because expertise is what predicts results. And start measuring AI value in work completed under supervision, not minutes saved per person. Read more

Security Scanning Goes Swarm

What: Cognition launched Devin Security Swarm on July 1—a security product that deploys parallel agents across segments of a codebase, composes individual findings into full attack paths, validates exploitability by reproducing each one in an isolated sandbox, and then opens remediation pull requests. On a benchmark of 50 real-world vulnerabilities tied to published GitHub Security Advisories, Cognition reports 72% recall at $90.23 per run, versus Claude Security at 68% and $131.87, Codex Security at 48%, and Cursor Security at 26%. After a baseline scan, subsequent runs process only changed code, so cost declines over time. Cognition calls the architecture “Agentic MapReduce.”

So What: AI-accelerated code production has security teams drowning—some are seeing 10-100x more findings, most of them false positives. The scarce resource isn’t detection anymore; it’s knowing which findings are actually exploitable and getting them fixed. A system that validates exploits at runtime and ships the patch attacks the backlog problem directly, and the benchmark’s cost-per-run framing signals where this category is heading: security tooling priced and compared like compute workloads. It’s also a preview of why inference demand keeps compounding—whole-codebase reasoning by agent swarms is exactly the kind of workload that consumes tokens by the billion.

Now What: If your application-security backlog is growing with your AI-assisted code output, evaluate the new generation of agentic scanners—and change your evaluation metric from findings volume to cost per confirmed-exploitable vulnerability. Pilot against a service with known issues and score the tools on validated exploits found, false-positive rate, and patch quality. A scanner that finds less but proves more is worth more. Read more

Coding Agents Went Mobile in a Single Day

What: On June 29, three agent platforms shipped new form factors within hours of each other. Cursor launched Cursor for iOS, letting developers launch always-on cloud agents from a phone or remotely control agents running on their computer. Replit released Replit Desktop for Windows and Mac. And OpenClaw shipped native iOS and Android apps—channels, tasks, and replies for running agents “from wherever your thumbs are.”

So What: Nobody writes software on a phone. These apps exist because the job is changing from writing to supervising: agents now run long enough on their own that what you need isn’t a keyboard, it’s a console—somewhere to check progress, answer a question, approve a next step, and kick off new work from the sideline of your day. When three companies converge on the same form factor in one day, that’s not coincidence; it’s the interface catching up to how the work actually flows.

Now What: If your teams use coding agents, expect work to start and continue outside office hours and office walls—and get ahead of the governance: who can launch agents against your repositories from a phone, what approvals gate a merge, and how mobile-initiated runs show up in your audit trail. The productivity is real; so is the new surface area. Scope it like you’d scope any remote access to production systems. Read more

The Human Variable

Two essays about the people side of the same transition. David Brooks argues AI sorts people by their appetite for mental effort, not their intelligence; Derek Thompson documents where the effort-seekers are going—increasingly, out on their own. Both are talent stories wearing philosophy clothes.

When Intelligence Is Plentiful, Volition Is Valuable

What: In a widely shared Atlantic essay, David Brooks argues the AI age will sort people not by intelligence but by their appetite for mental effort. Drawing on the psychology of “need for cognition,” he contrasts people who use AI to think less—productive in the short term, hollowed out over time—with those who “actively wrestle with AI to develop their own mental capabilities and accomplish more.” His guiding principle: “When intelligence is plentiful, volition is valuable.” The essay marshals a stack of recent research on cognitive offloading and skill atrophy to argue the gap between these two groups will become one of the defining divides of the era.

So What: This is the workforce version of a pattern showing up everywhere in agent adoption: the technology amplifies people who bring effort and judgment to it, and quietly erodes people who use it to avoid thinking. That means the capability gap inside your organization is behavioral, not technical—two employees with identical tools and identical access will diverge sharply based on how they engage. AI literacy isn’t a training completion rate; it’s whether people use the tools to take on harder problems or to disengage from the ones they have.

Now What: Design your AI rollout to reward wrestling, not offloading: set expectations that AI use should raise the ambition of the work, celebrate examples where someone used it to do something they couldn’t before, and watch for quiet skill atrophy in judgment-heavy functions—review, diligence, quality control—where rubber-stamping AI output is easiest to miss. The tools are the same for everyone; the posture toward them is what you can actually manage. Read more

The Solo-Operator Boom Is the Jobs Story Nobody’s Telling

What: Derek Thompson’s latest essay pushes back on both AI-jobs camps—the doomers predicting white-collar wipeout and the deniers calling it hype. His data points: prime-age employment is near an all-time high, a National Bureau of Economic Research survey of executives found “little evidence of near-term aggregate employment declines due to AI,” and the generative-AI economy produced an estimated $100-200 billion in revenue over the past 12 months. The real shift he documents is an explosion of solo and tiny-company entrepreneurship—like the ex-Amazon employee who used ChatGPT to navigate regulations, compliance, and marketing to launch a home-kitchen restaurant, then a one-man consultancy. Thompson’s line: “There has never been an easier time to become a millionaire by working for yourself.”

So What: Read this as a talent-market signal, not just an economics column. Your most capable operators—the ones who pair domain expertise with AI fluency—now have a credible outside option that requires no funding, no team, and no permission. The same dynamics cut inward, too: if one motivated person with agents can run what used to take a small company, your assumptions about the team size a new initiative requires are probably stale.

Now What: For retention, give your best operators what going solo would give them—scope, autonomy, and AI-equipped ways of working—before they do the math themselves. For new initiatives, pilot one- and two-person pods with agent support instead of defaulting to a staffed team, and revisit business cases that priced in headcount you may no longer need. The build-versus-hire calculus is moving fast; make sure yours was computed this year. Read more

There were thirty teams competing at OpenAI’s Global Codex Hackathon, and our website crawler won us fourth place. Here’s a look back at how the day went, from three different perspectives: Mike Osborne (AI Engineer), Michelle Thorsell (Full-Stack Engineer), and Zack Naylor (AI Strategist/Product Lead).

What we built

Our goal was to build an idea we came up with called App Mapper, a Codex-powered website crawler that maps every page and user flow of a site as an interactive visual, something product teams have traditionally done by hand.

By the end of the day, we had a tool that crawls a site, generates an interactive flow map, scores each page against well-established usability heuristics, flags severity of issues, surfaces recommended changes, and exports a PowerPoint deck with findings ready to share with a client.

How we divided the work

Mike worked on the functional bones of the project: a Next.js app, no database (because there was no time for migrations), deployed to Vercel for quicker feedback. Michelle was in charge of UI/UX. She developed an elegant interface that was intuitive to use. A polished UI was integral to the project, because one of the objectives of the hackathon was to highlight the scope of Codex’s capabilities, including the aesthetic ones.

Zack started in a support position, guiding product direction and troubleshooting. “I figured they’d end up doing most of it,” he shares. “I was ready to contribute but honest with myself about how much I’d actually be needed given the caliber of the engineering team.” However, his role ended up evolving significantly over the course of the hackathon.

The walls we hit

At one point, the app got stuck in a loop that kept crashing everyone’s computers. The solution ended up being fairly straightforward: we prompted Codex with the problem and explicitly told it not to run the app until it had resolved the issue.

The biggest technical blocker, however, was the crawl. Getting the app to reliably map even one site took a lot of trial and error. About halfway through the day, the team decided to restrategize: find one site that produces a usable crawl and build around that. That open source site ended up being Formbricks.

When it clicked

The project really started to feel “real” once it was reliably running crawls and the interactive map was live. “It wasn’t just ‘the build is working,’” Michelle reflects. “It was the realization that we’d actually automated something product teams do by hand.”

This is when Zack’s role began to shift. With the core product stable, he suggested adding a scoring layer to the map that would rate each page against usability heuristics, flag severity, and surface recommended changes. Even though he has minimal coding experience, he was able to use Codex to build a feature that exports those findings into a client-ready PowerPoint deck.

“That surprised me most,” shares Mike. “The fact that Zack was able to quickly contribute our killer feature—with little to no coding background—that speaks to Codex’s strengths.”

How we kept it on track

Michelle was continually monitoring how much time there was left. "Done beats impressive-but-broken. An amazing feature that wasn't complete wouldn't help us at judging. A demoable, polished product would," she asserts. That meant cutting and deprioritizing along the way, not because the ideas weren't good, but because the goal was to have features that both functioned and demoed well.

What we took away

All three of us were surprised by how much got done. In just four hours, we had built a functioning product from zero, and still had enough time left to practice our demo. But our biggest takeaway is about what delegating efficiently made possible for our team. Our product lead was able to take charge of feature work using a tool he’d never touched before, because our engineers made strategic stack choices to give AI the best chance to perform.

Mike put it plainly: “Codex challenges the experience you used to need. A product or design skillset can now run really quickly and then hand it off to an engineer. It enables a new way of working.”

“If you’re confident in the team around you and you have the right tools in place, you’d shock yourself with how much you can do under extremely tight timelines,” Zack adds.

Michelle notes: “We walked away with something actually useful, with enough time left to practice our demo. I don’t think any of us expected to feel that good about the output at the end of it.”

If you’re reading this and it sounds like your kind of work

We're a lean, senior organization filled with teams like this – a product lead and a couple of AI engineers. If you want to work with people who move fast and take the craft seriously, we'd like to talk.

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

AI Reprices the Business

AI didn’t just show up in products this week—it showed up on income statements and in deal rooms. A record stock drop repriced the consulting model, a top firm turned AI codegen into a due-diligence weapon, and an analyst mapped how shopping agents reshuffle retail. The question underneath all three is the same: when capability gets cheap, what is your business actually worth?

Accenture’s Worst-Ever Stock Drop Puts a Price on “AI Eats Consulting”

What: Accenture shares fell about 18% on June 18—its largest single-day drop on record—after the company missed quarterly revenue estimates and trimmed its fiscal-2026 growth outlook to 3-4%. New bookings came in at $19.3 billion, down roughly 2% year-over-year, with consulting revenue up just 1%. Management pointed to cuts in U.S. federal spending and Middle East headwinds, but the market read a bigger story: IBM fell about 7% and Capgemini more than 8% the same day, repricing the legacy, billable-hours services model as a category. Accenture countered that its own AI and data-platform bookings are on track to more than double from the prior year.

So What: The market just drew a line between two kinds of services revenue: the big-team, hours-based delivery that AI compresses, and the AI-native delivery growing underneath it. For you as a buyer of services—consulting, systems integration, managed delivery—that line is your leverage. If a vendor’s value was largely the number of people they put on the problem, AI is deflating exactly that, and you should expect to pay for outcomes and expertise, not seat-count. Accenture’s own doubling AI bookings make the point: the work isn’t disappearing, the pricing model is.

Now What: If you’re renewing a large services contract, renegotiate around outcomes and the smaller, AI-augmented teams that now do the same work—don’t accept last cycle’s staffing assumptions as this cycle’s price. And when you evaluate a partner, weight the depth of their senior expertise and their AI-native delivery over headcount; the firms repricing fastest are telling you where the value actually sits. Read more

A Top Consultancy Is Rebuilding Acquisition Targets’ Software to Test If the Moat Is Real

What: Bain & Company consultants are using AI coding tools to quickly build rough replicas of a software company’s product as part of private-equity due diligence, the Financial Times reported. The “outside-in” test is simple: see how fast and cheaply the core functionality can be recreated. If a target’s product can be rebuilt in days, the moat may be shallower than the price assumes. Bain has reportedly produced hundreds of these prototypes, with Anthropic’s Claude Code among the tools named. The backdrop is a software-buyout market that has cooled sharply, with PE software deals running around $50 billion in the first five months of the year.

So What: This operationalizes a question every software owner and acquirer now has to answer: how much of your product is genuinely hard to rebuild, versus assembled functionality a capable coding agent can approximate in an afternoon? It doesn’t mean the replica is production-grade—integrations, data, trust, and distribution still matter—but it changes the burden of proof. A buyer can now cheaply pressure-test the “it would take years to replicate” story that software valuations have long rested on. The moat conversation moves from assertion to demonstration.

Now What: If you own or run a software business, do this exercise on yourself before a buyer does: have a small team try to rebuild your core product with a coding agent and see what actually resists replication—the data, the integrations, the workflows, the switching costs—and lead with those, not the feature list. If you’re on the buying side, AI-built replicas are a new, cheap diligence input worth adding to your process, with the discipline to remember what a prototype doesn’t capture. Read more

The Agentic-Commerce Shakeout Is Amazon’s to Lose

What: In a June 18 Stratechery interview, MoffettNathanson analyst Michael Morton and Ben Thompson laid out how AI agents that shop on a customer’s behalf could reshuffle e-commerce. The framing: agentic commerce is Amazon’s category to lose given its scale and logistics, but also its biggest threat, because when an agent picks the product, the habits and search dominance that protect incumbents matter less—opening real opportunity for Walmart and Shopify-powered merchants. The conversation also covered grocery, distribution-versus-referral models, and the difficulty of pricing in “unfalsifiable” bear cases.

So What: If software moats are getting cheaper to test, distribution moats are getting harder to keep. When a shopping agent stands between your customer and your product, the things that won attention—brand recall, owning the search box, app real estate—lose force, and what wins is being the answer the agent selects: structured product data, fulfillment the agent can rely on, machine-readable terms. For anyone selling to consumers, the buyer on the other end is increasingly software, and software doesn’t browse the way people do.

Now What: If you sell products online, start treating AI agents as a customer segment now: make sure your catalog, pricing, availability, and policies are clean, structured, and accessible to an agent, not just rendered for a human shopper. Audit where your demand actually comes from—if it’s a platform or search surface an agent can disintermediate, build a direct relationship and a reason for the agent to pick you on merits it can read. Read more

The Frontier Tightens, the Market Routes Around It

The most capable models are getting harder to reach—gated by identity checks, and, in one widely-read essay, headed for the regulatory treatment we give nuclear material. At the same time, enterprises are voting with their tokens, moving the routine majority of their work onto cheaper open models. Access narrows at the top; it widens at the bottom.

Anthropic May Ask Claude Users to Verify Their Identity—With a Selfie

What: Anthropic is rolling out identity verification that can require some Claude users to upload a government ID, a selfie or short video, and what its updated policy calls a “facial geometry template”—data it acknowledges may count as biometric in some jurisdictions. The checks run through identity vendor Persona, with Anthropic as the data controller, and apply to a “small subset” of flagged-but-not-banned accounts as an appeals path; the updated privacy policy takes effect July 8. Some observers connected the move to the June export-control directive that restricted Anthropic’s top models for foreign nationals, but Anthropic says the ID verification is unrelated to that rollout.

So What: Set aside the speculation about why, and the development still matters: biometric identity verification is entering the AI-vendor relationship. For a company, that raises concrete questions about what your provider collects, who processes it (here, a third party), where it’s stored, and which of your users could be asked to hand over an ID to keep working. Whatever the reason in this case, identity and provenance are becoming part of how frontier models are governed—and that’s a data-protection surface your security and legal teams haven’t had to scope for an AI vendor before.

Now What: If your teams use Claude or any frontier assistant, get ahead of it: ask your vendor exactly what identity or biometric data they collect, under what conditions, through which processors, and how it maps to your own privacy and regional compliance obligations. Build identity-verification scenarios into your AI vendor review the way you would for any system that might touch employee biometric data—before a verification prompt shows up in front of one of your people. Read more

An Influential Essay Argues the Best Models Will End Up Behind Glass

What: In “The Flat Curve Society,” veteran engineer Steve Yegge argues that within a few model generations the most capable AI will be “regulated like nuclear weapons”—kept behind the labs’ own firewalls, where you send a spec or a problem and the model implements it on their servers rather than letting you prompt the raw model directly. Most users, he contends, will plateau at roughly today’s Mythos/Fable-class capability. He introduces the “Discernment Horizon”—the point past which a model is good enough that you can no longer check its work, because verifying it is itself beyond you (”superhuman means unverifiable”)—and frames AI literacy as a measurable organizational capability, citing teams that jump token-consumption cohorts in hours.

So What: Two of Yegge’s ideas are worth taking seriously even if you don’t buy the whole thesis. First, “send a spec, get an implementation” is the direction the tools are already heading, which means the durable skill is writing precise specifications and acceptance criteria—not prompt-craft. Second, the Discernment Horizon names a real governance problem: as models exceed your team’s ability to check their output, “we reviewed it” stops being a control. You need verification that doesn’t depend on a human out-reasoning the model—tests, ground-truth checks, constrained scopes.

Now What: Invest in two things now: the ability to specify work crisply (the input that’s becoming the bottleneck) and verification you can trust when you can’t personally vet the answer (automated tests, known-answer checks, narrow tasks with checkable outputs). And treat AI literacy as a capability you measure and build deliberately across teams, not a thing that happens on its own—the gap between your fluent users and everyone else is already a real productivity spread. Read more

Enterprises Are Quietly Moving the Majority of Their Tokens to Open Models

What: As flagship model prices stay high, large AI customers are routing more of their work to cheaper and open-source models, The Information reported. Open-source models have moved to the top of the model-router OpenRouter’s chart by token volume, and per The Information account for a majority of tokens processed in June. The piece’s named example: Ensemble Health Partners, a hospital revenue-cycle software company planning to spend up to $100 million on AI this year, told the publication it switched a tool that drafts insurance appeal letters to a model roughly 23 times cheaper than its more advanced option—saving close to $700,000 a year on the roughly 15,000 letters it generates monthly.

So What: This is the routing thesis showing up in production budgets, with a concrete number attached. The pattern—reserve the expensive frontier model for the work that needs it, send the high-volume routine work to a cheaper or open model—is becoming standard practice, not a science experiment, and the savings are large enough that finance will start asking why you’re not doing it. The strategic read is that “which model” is now a per-workload decision tied to a quality bar and a cost ceiling, and the default of running everything on one premium model is getting expensive to justify.

Now What: Find your highest-volume, most repetitive AI workload—the equivalent of Ensemble’s appeal letters—and test whether a cheaper or open model clears the quality bar at a fraction of the cost. But pair it with policy: decide which models are eligible for which data, because routing sensitive or regulated workloads to an open or third-party model is a governance decision, not just a cost one. The savings are real; so is the obligation to know where your data is running. Read more

AI Lands Inside Real Work

The week’s product news had a common shape: AI moving out of the chat window and into the places work actually happens—your team’s Slack, your document pipeline, a film studio’s process, even a medical scanner. The interface is starting to disappear into the work.

Claude Becomes a Tag-able Teammate Inside Slack

What: Anthropic launched Claude Tag on June 23, replacing its older Claude-in-Slack app. Instead of a private bot, you @-mention Claude in a channel and it acts as a shared, visible member everyone can see and direct—”more like a teammate.” It breaks tasks into stages and works asynchronously in the background, can schedule work over time, builds context from channel history, and connects to outside tools and data. With an ambient mode on, it proactively surfaces relevant information and follows up on open threads. It runs on Opus 4.8 and is in beta for Claude Enterprise and Team plans, with admin controls over which channels, tools, and data each instance can touch—plus token-spend limits.

So What: The interesting part isn’t a chatbot in Slack—it’s where the agent lives. Putting Claude in a shared channel as a visible participant makes its work observable: the team sees the prompt, the steps, and the output, which is exactly the condition under which AI use turns into shared organizational learning instead of a thousand private, unrepeatable chats. The admin controls and per-instance token limits are the other tell—Anthropic is acknowledging that an agent acting in your workspace needs scoping and a budget, the same governance questions any deployed agent raises.

Now What: If you run on Slack and you’re piloting agents, a shared, visible channel teammate is a better starting point than private assistants—you get the work product and the learning in the open. But scope it deliberately before you roll it out: which channels, which tools, which data, and what spend cap per instance. Treat it as deploying an agent with real access, not installing a chatbot, and decide who owns its configuration and its bill. Read more

Mistral’s New OCR Model Targets the Unglamorous Bottleneck: Reading Documents

What: Mistral released OCR 4 on June 23, a document-understanding model that doesn’t just extract text but localizes each block with a bounding box, classifies it, and attaches per-page and per-word confidence scores. It supports 170 languages, ships in a single container for fully self-hosted, on-premises deployment—pitched as a compliance edge for data that can’t leave your infrastructure—and is priced at $4 per 1,000 pages via API, halved with batch processing. Mistral reports a top score on the OlmOCRBench benchmark and says independent annotators preferred its output over competing systems in about 72% of comparisons.

So What: Document ingestion is the quiet failure point in a lot of enterprise AI: agents and retrieval systems are only as good as their ability to turn messy PDFs, forms, and scans into clean, structured, trustworthy input. The features that matter here are the unglamorous ones—confidence scores let you flag low-certainty extractions for review instead of silently passing bad data downstream, and self-hosting keeps regulated documents inside your walls. For document-heavy, regulated work, that combination is often worth more than a point of benchmark accuracy.

Now What: If you’re building retrieval or agent pipelines over documents, evaluate OCR quality as a first-class component, not an afterthought—test candidates on your own worst documents (bad scans, tables, handwriting, mixed languages) and measure structured-output accuracy, not just text capture. For regulated content, weigh a self-hostable option that keeps data on your infrastructure, and use per-field confidence scores to route uncertain extractions to a human instead of trusting them blindly. Read more

A24 Took Google’s Money for AI—But Not the Usual Hollywood Deal

What: Independent film studio A24 struck a research partnership with Google DeepMind, tied to a roughly $75 million Google investment, IndieWire reported June 22. A24 gets access to DeepMind’s research, infrastructure, and technology, with DeepMind researchers working alongside its filmmakers on new tools—AI-assisted storyboarding, for instance—while filmmakers keep full creative control. What sets it apart from other studio AI deals: it reportedly does not give Google access to A24’s content library or training data, and there’s no production mandate. It’s DeepMind’s first direct partnership with a full studio, framed by CEO Demis Hassabis as building tools “to support artists.”

So What: The structure is the lesson here, and it generalizes well beyond film. A24 took the capital and the technical access while explicitly withholding the thing the other side usually wants most—its proprietary content as training data. In an era when every AI partnership is partly a data deal, that’s the negotiating posture worth studying: separate “we’ll use your tools and expertise” from “you can train on our crown jewels,” and price and fence them differently. The most valuable thing you bring to an AI partnership is often your proprietary data—so don’t give it away as a rounding error in a tooling agreement.

Now What: If you’re negotiating an AI partnership or vendor deal, treat your proprietary data as a separate line item with its own terms—what they can access, whether they can train on it, retention, exclusivity—rather than letting it ride along with the technology access. A24’s deal is a useful template: take the capability, keep the corpus. Know which of your assets is the one the other party actually wants, and make them pay for that specifically. Read more

Midjourney Is Building a 60-Second Body Scanner

What: Midjourney, known for AI image generation, announced a new health division and a prototype full-body scanner it calls “Ultrasonic CT.” It uses ultrasound rather than radiation: a person is lowered slowly into a shallow water pool ringed with roughly half a million ultrasonic sensors firing from every angle, producing a sub-millimeter 3D map of the body the company says is comparable to MRI but roughly 100x faster—a full scan in under a minute. Built with ultrasound-chip maker Butterfly Network under a licensing deal and backed by a reported $74 million-plus, it’s an early prototype with no regulatory clearance; the initial use is body-composition mapping, not diagnosis, with a first location targeted for 2027 and FDA approval sought around 2028.

So What: This is a long-shot moonshot, not a product you’ll buy this year, and it’s worth a moment of attention for two reasons. One: a company whose entire reputation is generative imagery just moved into physical medical hardware, a reminder that “AI company” is becoming a poor predictor of what a company does next. Two: the pitch is the one that keeps recurring across AI—not a new capability, but the same outcome an order of magnitude faster and cheaper, which is exactly the pattern that resets expectations in a market. The interesting question for any incumbent is what happens when “good enough, 100x faster” shows up in your category.

Now What: You don’t need to act on a pre-clearance prototype—but file the pattern. When you’re scanning for what could disrupt your industry, widen the aperture beyond your obvious competitors: the threat increasingly comes from a company with adjacent AI capability and the willingness to attack your cost-and-speed structure from the side. Ask where in your business a “10x faster at lower cost” entrant would hurt most, and whether you’d see it coming from outside your usual competitive set. Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

The Ground Under the Model Layer Is Moving

Which model you can run, who’s winning the users, whether to rent it or build it, and the financial bet funding all of it—every assumption underneath the model layer moved this week. The throughline for anyone building on these platforms: the model is a dependency, and dependencies need contingency plans.

A U.S. Directive Pulled Anthropic’s Top Models Offline—Worldwide—Overnight

What: On June 12, the U.S. Commerce Department ordered Anthropic to suspend access to its most capable models—Fable 5, launched just three days earlier, and the more powerful Mythos 5—for all foreign nationals, citing export-control law. Because Anthropic’s API can’t verify a user’s citizenship in real time, the company disabled both models for every customer worldwide. The Wall Street Journal reported June 13 that the directive traced back to Amazon CEO Andy Jassy, who alerted Treasury Secretary Scott Bessent after Amazon’s own security researchers prompted Fable 5 into producing cyberattack-related information that was supposed to be off-limits. Amazon is Anthropic’s largest investor, holds a board seat, hosts Claude on AWS, builds chips Anthropic trains on, and competes with its own model line. AWS confirmed it was affected by the cutoff; by mid-week both models were still offline with no restoration timeline, and Anthropic had sent staff to Washington to negotiate. Other Claude models were unaffected.

So What: This is the supply risk every “just call the API” architecture quietly carries, made concrete. A model you were building on June 11 was gone June 12—not because of an outage or a price change, but because of a government directive routed through your cloud provider, who also happens to be your model vendor’s biggest investor and a direct competitor. Capability didn’t matter; control did. If your roadmap assumes continuous access to one specific top-tier model, this week showed how that access can be revoked by parties you don’t contract with and can’t appeal to.

Now What: If you’re building on a single frontier model, treat provider and model availability as a risk line in your plan, not a given—identify which workloads would break if your primary model vanished tomorrow, and keep a tested fallback on a second provider for anything business-critical. And read your vendor relationships for hidden conflicts: when the company hosting your model also invests in, sits on the board of, and competes with the model maker, your interests and theirs are not automatically aligned. Read more

ChatGPT’s Share of the Assistant Market Falls Below Half for the First Time

What: ChatGPT’s share of the AI-assistant market dropped to 46.4% in May 2026, down from above 50% in January—the first time it’s fallen below half—according to Sensor Tower’s State of AI report. Gemini rose to 27.7% and Claude to 10.3%; every other assistant held under 5%. In raw users, ChatGPT still leads by a wide margin—roughly 1.1 billion monthly actives against Gemini’s ~662 million and Claude’s ~245 million—so this is a share shift, not a collapse. TechCrunch’s June 16 coverage attributes Gemini’s gains to Google’s distribution across products people already use and notes that OpenAI’s February defense partnership coincided with measurable user departures.

So What: Two things matter here for a buyer. First, the assistant market is no longer a one-vendor story—Gemini’s rise is driven by distribution (it’s already inside the tools people open all day), which is exactly how enterprise software wins, and it means your employees increasingly arrive with a Gemini or Claude habit, not just a ChatGPT one. Second, the report ties share movement to trust and values, not just features—when a vendor takes a position its customers dislike, some of them leave. If you’re standardizing on one assistant company-wide, you’re betting on more than its current benchmark scores.

Now What: If you’re choosing a default assistant for your workforce, weight distribution and integration with your existing stack as heavily as raw capability—the assistant your people already have open wins adoption. And don’t treat today’s market leader as if its position is permanent; build your internal tooling against a model-agnostic interface so switching assistants later is a configuration change, not a migration. Read more

Nvidia and Abridge Are Building a Clinical Model That Runs on the Health System’s Own Data

What: Nvidia and Abridge are co-developing an AI model purpose-built for clinical conversations, based on Nvidia’s open Nemotron model family and trained on Abridge’s de-identified clinical data, the Wall Street Journal reported June 11. Abridge makes ambient AI documentation tools—software that turns a doctor-patient visit into a clinical note—and works with more than 300 health systems including Kaiser Permanente, Johns Hopkins Medicine, and Yale New Haven Health. The new model will run inside Abridge’s own platform rather than a general-purpose cloud service, sit alongside its existing models, and is expected later this year. Nvidia is already an Abridge investor through its venture arm.

So What: This is the counter-move to renting a frontier model: a vertical company building a purpose-built model on proprietary, domain-specific data and running it inside its own walls. The bet isn’t that a specialized model beats a frontier model on general benchmarks—it’s that for a narrow, high-stakes task, a model trained on the right data and controlled end-to-end is more accurate, more private, and more defensible than a general model behind someone else’s API. In a regulated domain, “we own the model and control the data it learned from” is a feature you can put in front of a compliance team.

Now What: If you operate in a domain with proprietary data and real accuracy stakes—healthcare, legal, finance, industrial—ask where a purpose-built model on your own data would outperform a general model you rent, and where it wouldn’t. The pattern to copy isn’t “train your own frontier model”; it’s “take a strong open base model, specialize it on data only you have, and run it where you control access.” That combination is the moat, not the base model. Read more

The Companies Funding the AI Buildout Now Need the Market’s Confidence to Hold

What: A June 13 Financial Times analysis argues the relationship between Big Tech and the stock market has flipped. The largest technology companies, long prized as cash-generating machines, have become enormous consumers of capital to fund the AI buildout—compute, chips, and data centers—and the market’s strength now rests heavily on sustained investor confidence in that bet paying off. The piece frames the systemic fragility this creates: when so much market value depends on one capital-intensive thesis, a dip in confidence has further to travel.

So What: Strip out the markets framing and there’s a procurement question underneath: how durable are the companies you depend on for AI? The buildout funding your cheap tokens and fast model releases is running on capital and confidence, and both can move. You don’t need a view on whether it’s a bubble—you need to know which of your AI dependencies would survive a downturn in AI spending and which are propped up by a land-grab that won’t last. The pricing and pace you’re planning around may reflect a market racing for position more than a stable cost structure.

Now What: If you’re making multi-year commitments that assume today’s AI pricing and release cadence, pressure-test them against a slowdown: what happens to your costs and roadmap if vendor funding tightens and subsidized pricing ends? Favor architectures and contracts that don’t lock you to a single capital-hungry provider, and treat unusually cheap AI pricing as a competitive opening to capture now, not a permanent baseline to build your unit economics on. Read more

Intelligence Becomes a Cost You Have to Manage

Tokens have become a real operating expense, and this week the market, the technique, and internal governance all moved to control it. The pattern is the same one cloud spend went through: usage that’s easy to start and invisible until the invoice arrives eventually forces budgets, routing, and someone who owns the meter.

Buyers Aren’t Waiting for Price Cuts—They’re Routing Around the Premium Models

What: A June 11 Wall Street Journal report describes companies actively cutting AI costs by routing workloads across a mix of models—sending routine tasks to cheaper or open-source options and reserving premium models like ChatGPT and Claude for complex work. Executives told the Journal this approach can reduce the cost of some AI-assisted work by as much as 95%. One named example: the founder of bug-finding startup Detail said the company moved about 90% of its workload off Claude and Gemini onto custom and lower-cost models. The pressure is coming from buyers, not from announced price cuts by the leading labs.

So What: Last week the story was the labs considering price cuts; this week it’s buyers deciding not to wait. The signal for you is that model choice is becoming a per-task decision, not a company-wide standard—the economics only work if you match each workload to the cheapest model that clears its quality bar, instead of paying premium rates for everything. The 95% figure is real for the right workloads, but it’s a ceiling, not a default: it comes from disciplined routing plus a willingness to use whatever model performs, which is a governance question as much as a technical one.

Now What: If you’re paying premium per-token rates across the board, your fastest cost win is workload routing—classify your AI tasks by how much quality they actually require, and send the routine ones to cheaper models. But set the policy first: decide which models are eligible for which data, because not every cheap model clears the bar for regulated or sensitive workloads, and “it was cheaper” is not a defense your security review will accept. Routing is a cost lever and a control surface at the same time. Read more

A Panel of Models Beat the Single Best Model—Sometimes at Half the Cost

What: OpenRouter published research on June 12 (updated June 14) showing that combining several models on the same task can beat any single model working alone. Its “Fusion” tool sends one prompt to multiple models in parallel, then uses a judge model to synthesize their answers into one. On a 100-task deep-research benchmark, a panel of cheaper models scored higher than the best individual frontier models while costing roughly half as much—and even running a single model several times and fusing its own answers lifted its score meaningfully over one pass. The strongest results came from blending different frontier models together.

So What: This is the technique underneath the cost story: you don’t always need a more expensive model—sometimes you need more than one cheaper model and a way to combine them. The result that should catch your attention is the budget panel beating solo frontier models at half the cost, because it inverts the usual instinct to reach for the most capable (and priciest) model on hard tasks. It also reinforces portability: if a panel of mid-tier models can match a frontier model, your dependence on any single top model—and its pricing and availability—drops.

Now What: For high-value tasks where accuracy matters more than latency—research, analysis, complex retrieval—test a multi-model approach against your current single-model setup on your own workload, measuring quality and cost per resolved task. Even the simplest version (run your existing model two or three times and reconcile the answers) is worth trying before you reach for a pricier model. As with routing, apply your data-eligibility policy to every model in the panel. Read more

Meta Is Capping Its Own Employees’ AI Usage as Internal Costs Climb Into the Billions

What: Meta is imposing centralized limits on how many tokens employees can consume internally after projecting that its internal AI spending would reach into the billions of dollars in 2026, The Information reported June 12. The trigger was a policy that made demonstrated AI-driven results a performance expectation—which backfired into employees gaming an internal usage leaderboard, sometimes running agents on parallel tasks just to inflate their numbers (reportedly tens of trillions of tokens in roughly a month). Meta’s response: per-team budgets and token limits, steering staff toward an internal coding assistant, and a centralized monitoring platform with automated alerts for usage spikes, with structured token budgets planned for 2027.

So What: This is what happens when you incentivize AI usage without governing its cost—you get usage, including the wasteful kind, and a bill nobody forecast. The useful lesson isn’t Meta’s specific numbers; it’s the failure mode. “Use more AI” as a mandate, without budgets, ownership, and visibility, produces token consumption optimized for looking productive rather than being productive. The fix Meta landed on—per-team budgets, a monitoring layer, and a default internal tool—is the same cost-governance discipline cloud spend eventually required, arriving now for tokens.

Now What: If you’re pushing AI adoption internally, pair the encouragement with instrumentation from day one: per-team budgets, an owner for each, and a dashboard that shows usage by team and use case before the invoice does. Be careful what you reward—measuring AI usage as a proxy for productivity invites exactly the gaming Meta saw. Track outcomes and reusable workflows, not raw token volume, and give yourself the ability to see and cap spend before it surprises your finance team. Read more

The Coding Agent Becomes the Work Agent

The agents built to write code are turning into general-purpose workers—and the people directing them increasingly aren’t engineers. The skill that matters is shifting from producing output to specifying and verifying it, whether the builder is a senior engineer or a support lead.

OpenAI Plans to Build Its ChatGPT “Super App” on the Back of Its Coding Agent

What: In a June 11 Wired interview, Tibo Sottiaux—newly named OpenAI’s head of core products, overseeing both ChatGPT and Codex—described a planned “super app” that merges the two, largely powered by Codex converted from a coding tool into a general-purpose agent. Behind a plain natural-language request, the agent would write code, call APIs, or browse the web as needed, with ChatGPT (close to a billion weekly users) becoming “delightfully proactive.” Sottiaux said earlier agent attempts like Operator were “too early” because models weren’t reliable enough yet, and that OpenAI favors small incremental releases over big launches. He noted the Codex team numbered only around 40 people two months ago.

So What: The strategic tell is that the coding agent is becoming the work agent. The same machinery built to write and run code—plan a task, call tools, execute, check the result—turns out to be the general engine for getting things done, and OpenAI is putting it behind its highest-traffic product. For you, that collapses a distinction a lot of AI strategies still make: “coding tools” for engineers and “assistants” for everyone else are converging on the same agent architecture. The capability your engineering team is learning to direct is the same one that will soon act across your whole company.

Now What: If you’ve siloed your AI thinking—coding copilots over here, chat assistants over there—start planning for one agent surface that does both, because that’s where the products are heading. The skill that transfers is directing an agent: writing a clear spec, giving it the right tools and context, and verifying its output. Build that muscle on coding workflows now, because the same muscle will run your operations, support, and analysis agents next. Read more

At Sierra’s Customers, the People Building the AI Agents Aren’t Engineers

What: Sierra published a June 15 piece on how its customers’ non-technical teams—support leads, operations managers, QA staff—are building and tuning customer-facing AI agents themselves using its Ghostwriter tool, which lets them describe changes in plain language instead of writing code or filing tickets with engineering. Customers quoted include an operations leader at Tilt, who said that rather than reviewing conversations to guess what went wrong and hoping a fix lands, “we can just ask Ghostwriter,” and a customer-operations VP at Minted, who said work that once took days or weeks across multiple teams now happens in real time. The examples are about speed and iteration rather than published metrics.

So What: The shift worth noting is who holds the build button. When the people closest to the customer can change the agent that serves the customer—without a handoff to engineering—the loop between noticing a problem and fixing it collapses from weeks to minutes. That’s a different operating model, not just a faster one: domain experts stop writing requirements for someone else to implement and start implementing directly. It also changes what your engineers do—less ticket-taking for small changes, more building the platform and guardrails that let non-engineers work safely.

Now What: If you run a function with deep domain experts and a long queue into engineering—support, ops, compliance, marketing—look for the work that’s stuck only because non-engineers can’t make the change themselves, and pilot a tool that lets them. The win isn’t headcount; it’s cycle time, plus the quality that comes from the person who understands the problem making the fix. Put the guardrails in first—what they can change, what stays locked, and how changes get reviewed—so speed doesn’t cost you control. Read more

A New Google Playbook Says the Hard Part of Coding Is No Longer Writing It

What: A Google whitepaper circulated around June 15 alongside a Kaggle “vibe coding” course argues that AI has largely solved code generation, so the new craft is “verification, judgment, and direction.” It lays out a spectrum of three working modes: vibe coding (casual prompts, minimal review—fine for prototypes and throwaway work), structured AI-assisted coding (constrained prompts, manual testing, selective review—for features in real codebases), and agentic engineering (formal specs, architecture and memory documents, automated tests, CI gates, and full review—for production at team scale). Its durable principles: structure scales while vibes don’t, AI amplifies whatever engineering culture you already have, and the human role moves toward specification, evaluation, and architectural judgment.

So What: This names the trap teams fall into with coding agents—treating all AI-assisted work as one thing. Prototyping in a sandbox and shipping to production are different disciplines, and the point is that rigor has to scale with the stakes: the same loose prompting that’s perfect for a throwaway demo is how you accumulate a production system nobody understands. The line that should land with any leader is that AI amplifies your existing engineering culture—if your standards are weak, agents help you ship bad software faster; if they’re strong, agents compound that strength.

Now What: If your teams are using coding agents, make the mode explicit: define what casual prompting is allowed for (prototypes, internal tools) and what production work requires (specs, tests, review, CI gates), and don’t let the casual mode leak into the serious one. Invest in the parts that don’t disappear—clear specifications, real test coverage, and architectural review—because those are now the bottleneck and the differentiator. The teams that win with agents aren’t the ones prompting fastest; they’re the ones with the structure to direct and verify what the agents produce. Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

The Labs Negotiate Their Own Brakes

In the same week, both frontier labs publicly endorsed machinery for slowing frontier AI development—while filing for IPOs and preparing a price war. Whatever you make of the timing, the governance of this technology is being negotiated in public right now, ahead of legislators, and the terms matter for anyone building on these platforms.

Anthropic Says AI Is Starting to Build Its Own Successors—and Asks for a Brake Pedal

What: Anthropic published an essay arguing that AI development is increasingly automating itself and that full recursive self-improvement—AI designing and building its own successors—could arrive sooner than institutions are prepared for. The receipts are internal: AI now writes more than 80% of the code merged into Anthropic’s own systems, engineers shipped roughly 8x more code per quarter in Q2 2026 than in 2024, and the length of tasks models can complete is doubling every four months, down from every seven. The recommendation isn’t a unilateral slowdown—it’s building a verifiable global coordination mechanism so the world has the option to slow or pause frontier development if needed. Scientific American’s June 5 coverage notes the skeptics’ read: the warning lands amid regulatory pressure and Anthropic’s own IPO filing.

So What: Strip out the existential framing and there’s an operational claim underneath that affects your planning horizon: the lab building one of the models you likely run on says its own development loop is compounding, with capability-doubling on a four-month cycle. If that holds even approximately, the model you evaluated last quarter is not the model you’ll be deploying next quarter, and roadmaps that assume a stable capability baseline are quietly wrong. The brake-pedal proposal matters too—a coordinated pause mechanism, if it ever activates, is a supply-side event your vendor contracts and contingency plans currently don’t contemplate.

Now What: If you’re building multi-year AI plans, treat capability as a moving input, not a fixed one: re-run your build-vs-buy and headcount assumptions on a quarterly cadence rather than annually. And it’s worth asking your AI vendors a question that sounded paranoid a year ago—what happens to your service if frontier development slows or pauses by policy? The answer tells you how much of your stack depends on the frontier moving versus the frontier as it already exists. Read more

OpenAI Publishes Its Plan for the “Third Phase”—the Same Day It Files for an IPO

What: On June 8, Sam Altman and Jakub Pachocki published “Built to benefit everyone: our plan,” declaring OpenAI’s third phase—from research lab, to product company, to making advanced AI “abundant, affordable, safe, useful” for everyone. Three stated goals: build an automated AI researcher (with an internal belief that by March 2028 a significant fraction of OpenAI’s research may be done by AI systems working alongside its researchers), accelerate the economy, and give everyone on Earth a personal AGI. Notably, the essay endorses an international organization that could coordinate leading AI efforts—explicitly including “slowing frontier development when needed.” The same day, OpenAI confidentially submitted a draft S-1 to the SEC.

So What: Read this next to Anthropic’s essay and the convergence is the story: both frontier labs, in the same week, publicly endorsed machinery for coordinated slowing of frontier development—while both race toward public markets. Whatever you make of the sincerity, the labs are now negotiating the governance of their own technology in public, ahead of legislators. For your planning, the March 2028 automated-researcher target is the number to file away: it’s OpenAI’s own estimate for when AI development itself becomes substantially AI-run, which is the mechanism behind every compounding-capability claim you’re being asked to believe.

Now What: If you’re setting AI strategy, the IPO filings are the practical signal here: both major labs are about to take on public-market reporting obligations, which means more disclosure about revenue, margins, and risk than you’ve ever had access to. When those S-1s go public, have someone on your team actually read them—the risk-factor sections will tell you more about model economics and supply concentration than any vendor pitch deck has. Read more

OpenAI Weighs Steep Token Price Cuts, Anticipating a War for Users With Anthropic

What: The Wall Street Journal reported June 10 that OpenAI is considering drastically reducing what it charges for tokens, in anticipation of similar cuts it expects from Anthropic. The discussions are still in flux, and the reporting notes such cuts could erode margins at both companies, which already carry heavy compute costs. The timing frames everything: OpenAI confidentially filed for an IPO on June 8, shortly after Anthropic’s own IPO filing, with Anthropic’s Series H closing May 28 at a $965B valuation against OpenAI’s $852B March mark.

So What: A token price war between the two largest frontier labs is a direct transfer of value to you, the buyer—but it’s also a volatility warning. Per-token economics that move significantly in a quarter undermine any unit-cost assumption baked into your business cases, in your favor this time, but the lesson cuts both ways. The deeper signal is that the labs themselves expect model capability to be price-competitive rather than differentiated at the margin, which strengthens the case for keeping your architecture portable between providers rather than optimizing deeply for one.

Now What: If you’ve priced AI features or internal tooling on current token rates, don’t lock long-term commitments at today’s list prices—shorter terms or usage-tiered contracts let you capture the cuts when they come. And if a vendor proposes a multi-year AI deal right now, the price-war backdrop is your negotiating context: the cost floor under their offering is about to drop, and your contract should share in that. Read more

Agents Become the Web’s Main Character

Cloudflare says automated traffic passed human traffic this month—18 months ahead of forecast. The same week, the largest payment network wired agent purchasing into 175 million merchant locations, and Perplexity published the architecture for how agents should search. The agentic web stopped being a prediction; it’s the majority of packets.

Cloudflare: Bots Now Outnumber Humans on the Web, 18 Months Ahead of Schedule

What: Cloudflare CEO Matthew Prince said automated traffic has passed human traffic online for the first time: 57.4% of requests across a selection of Cloudflare-hosted sites are now bots, versus 42.6% human. Prince had previously forecast the crossover wouldn’t happen until the end of 2027; agentic AI pulled it forward by roughly 18 months. The driver is structural—a single shopping agent might visit thousands of sites where a human would visit five. Prince cautioned the data is “a bit messy,” but the direction is unambiguous.

So What: Every assumption built on “website visitors are people” now has an expiration date: analytics, conversion funnels, ad attribution, rate limiting, content strategy, even capacity planning. If most of your traffic is software acting for a human, the metrics you report to your board are measuring a mixed population, and the mix is shifting quarterly. This is also the demand-side confirmation of what Strava’s API lockdown signaled from the supply side last week—the agentic web isn’t a forecast anymore, it’s the majority of packets.

Now What: If you run a consumer or commerce property, get your traffic segmented now—human, declared agent, undeclared bot—before your next quarterly metrics review, because trend lines that mix them are already lying to you. Then make the deliberate choice Strava made: which agents you serve, through what interface, and on what terms. Blocking everything and serving everything are both decisions; the costly thing is not deciding. Read more

Visa and OpenAI Wire Agent Payments Into 175 Million Merchant Locations

What: At the Visa Payments Forum on June 10, Visa and OpenAI announced that AI agents inside OpenAI’s products can make purchases on a user’s behalf—paying a bill, restocking supplies—once the user grants permission. Payments run inside user-defined guardrails (spending caps, merchant categories, required approvals) using tokenized Visa credentials with real-time authorization and fraud monitoring, and work in principle anywhere Visa is accepted: more than 175 million merchant locations. The companies also flagged enterprise applications, including Codex-powered developer workflows. No launch date, pricing, or interface yet.

So What: The interesting part isn’t that an agent can buy paper towels—it’s that the payment network itself is building the authorization layer for delegated spending. Spending caps, category restrictions, and approval gates enforced at the credential level is the control architecture that makes agent-initiated transactions auditable and reversible, which is what procurement and finance teams have correctly demanded before letting agents touch money. When the rails-level infrastructure exists, the question shifts from “should agents transact?” to “under what policy?”—and that policy becomes something you write, not something you wait for.

Now What: If agents anywhere in your company can or will initiate spend—procurement, travel, SaaS renewals, ad buying—start drafting the delegation policy now: per-agent caps, category allowlists, approval thresholds, and audit requirements. The pattern Visa is shipping for consumers is the template. And if your company runs an online checkout, agent-initiated purchasing is now on the roadmap of the largest payment network—pressure-test whether your own flow still works when the buyer on the other end is software, not a person. Read more

Perplexity Argues Search Should Be Code Agents Write, Not a Box They Query

What: On June 8, Perplexity published research on “Search as Code,” an architecture where AI agents don’t send queries to a monolithic search system—they write Python that orchestrates the individual pieces of the search stack, executed in sandboxes against an SDK of search primitives. The reported results: 0.871 on the DSQA benchmark versus OpenAI’s 0.733, leading marks on BrowseComp, and in one CVE-investigation case study an 85.1% token reduction—288.7K tokens down to 42.9K—at 100% accuracy.

So What: The 85% token reduction is the line that should catch your eye, because it generalizes beyond search. The pattern—give the model composable primitives and let it write the orchestration, instead of stuffing everything through a fixed pipeline—is the same architecture shift showing up in coding agents and data-warehouse agents. Fixed pipelines pay full freight on every request; generated code does only the work the task needs. For anyone running retrieval-heavy agent workloads, that’s the difference between a system that’s affordable at scale and one that isn’t.

Now What: If you’re building agents that search, retrieve, or investigate across large corpora, benchmark the code-generation approach against your current RAG pipeline on your own workload—token cost per resolved task is the metric. Even if you don’t adopt Perplexity’s stack, the design principle travels: expose your internal data systems to agents as composable primitives with a thin SDK, not as one monolithic query endpoint. Read more

Assistants Move In to Stay

Apple rebuilt Siri on a licensed frontier model, and ChatGPT’s memory now revises itself in the background while you’re away. The assistant is becoming a persistent presence—on the device in everyone’s pocket and in the accumulated context of how your team works. Persistence is the feature; it’s also the new lock-in and the new governance surface.

Apple Rebuilds Siri on Google’s Gemini and Puts AI at the Center of iOS 27

What: At WWDC on June 8, Apple unveiled a completely rebuilt Siri—rebranded Siri AI—powered by a custom 1.2-trillion-parameter Gemini model licensed from Google for a reported ~$1B per year, running through Apple’s Private Cloud Compute alongside on-device models. The new assistant is conversational, accepts typed queries and file attachments, and can execute tasks across apps and devices. iOS 27, macOS Golden Gate, and the rest of the platform line get deeper AI integration plus performance work: apps launching up to 30% faster, photo previews up to 70% faster. Developer betas shipped at the keynote; public betas arrive in July.

So What: The most privacy-positioned company in consumer tech decided that buying a frontier model beats building one—and structured the deal so the model runs inside Apple’s own privacy envelope rather than Google’s cloud. That’s the pattern worth noticing: the differentiator wasn’t the model, it was the integration surface and the trust architecture around it. It also means agentic AI is about to be a default expectation on roughly a billion devices, including the ones your employees and customers already carry. The bar for “my software has an assistant” just got reset by the default behavior of the phone in everyone’s pocket.

Now What: If you’re building customer-facing mobile experiences, assume your users’ baseline expectation within a year is an assistant that can act across apps—plan how your product participates in that (App Intents, exposed actions) rather than competing with it. And if you’ve been debating build-vs-buy on models internally, Apple’s call is a useful precedent for your board: the company with the deepest pockets in tech chose to license the model and own the integration and privacy layers instead. Read more

ChatGPT’s Memory Learns to Update Itself While You’re Away

What: On June 4, OpenAI rolled out “Dreaming,” a rebuilt memory architecture for ChatGPT. Instead of static saved facts, a background process synthesizes what the system learns across conversations and revises it as time passes—”you’re going to Singapore in July” becomes “you went to Singapore in July 2026” after the trip. A roughly 5x reduction in serving cost lets OpenAI extend the upgraded memory to free-tier users for the first time, with Plus and Pro users in the US getting first access and broader rollout over the coming weeks. The release pairs with user controls over how much the system remembers; early coverage notes the synthesized approach gives users less of a literal audit trail of stored memories than the old explicit list.

So What: Persistent, self-revising memory is what turns a chat tool into a colleague that compounds—and it’s also a new data-governance surface. The useful frame: memory quality is becoming a switching cost. An assistant that has correctly synthesized a year of your team’s context is meaningfully harder to migrate away from than one you re-prompt from scratch. The audit-trail tradeoff deserves equal attention—when memory is synthesized in the background rather than explicitly saved, knowing exactly what the system retains about your business gets harder, which is precisely the question your security review will ask.

Now What: If your teams use ChatGPT under enterprise or business plans, get clear on how memory features apply to your tier and what your admins can see and control before the rollout reaches you. And factor memory portability into vendor decisions: ask what you can export, inspect, and delete. Accumulated context is becoming real lock-in, and it’s cheaper to negotiate the exit terms before the memory exists than after. Read more

The Discipline Catches Up

Three-quarters of companies can’t see what AI costs them, and engineering teams are learning that cheap code makes comprehension the bottleneck. The maturity work of this era isn’t adopting AI—it’s building the instruments and the judgment to run it like everything else you’re accountable for.

Only 26% of Companies Can Actually See What AI Costs Them

What: The Wall Street Journal’s CFO Journal reported on a KPMG survey finding just 26% of companies fully track their AI costs; 50% have partial visibility and 22% have little or none until the bill arrives. Token-metered pricing is the culprit—finance teams are reconciling model logs, cloud invoices, and vendor dashboards by hand against budgets written before agents existed. Companies including Life360, Affirm, and Corning are building dashboards and routing rules to get ahead of it, and the Linux Foundation has moved to launch a Tokenomics Foundation, with support voiced by Accenture, Google Cloud, IBM, JPMorganChase, Microsoft, Oracle, Salesforce, SAP, and ServiceNow, to standardize how AI usage is measured and billed.

So What: Token spend is a new cost category with the worst possible properties: usage-driven, decentralized, easy to start, and invisible until invoiced. Three-quarters of companies are flying without instruments—and agent adoption multiplies the problem, because agents consume tokens without a human watching the meter. The vendor-neutral standards push tells you how real this is: the largest enterprise software companies just agreed the lack of a common usage measure is everyone’s problem. Cost visibility is about to become the difference between AI programs that scale and ones that get frozen by a CFO who got surprised.

Now What: If you can’t answer “what did AI cost us last month, by team and by use case,” make that dashboard the next thing you build—before the next budget cycle, not after. Tag every agent and application with an owner and a budget the way you (eventually) learned to do with cloud. The companies named in this story are doing it with routing rules and per-use-case meters; the pattern is established, and retrofitting it after an invoice shock is the expensive path. Read more

When Code Is Cheap, the Expensive Skill Is Saying No to It

What: A June 4 essay from htmx creator Carson Gross, “Code is Cheap(er),” argues that AI collapsing the cost of writing code creates a new bottleneck: understanding it. “The LLM can produce code far faster than you, or anyone else, can understand it.” Since models generate prolifically and have no fear of complexity—which Gross calls software’s “apex predator”—the engineer’s value shifts from producing code to constraining it: the best engineers will “pride themselves on the code (and layers) they remove from or prevent from entering systems.”

So What: This names the real management question of AI-assisted engineering. Output is no longer the constraint—comprehension and architectural integrity are. A team that merges everything its agents produce isn’t faster; it’s accumulating a system nobody understands, which is risk wearing a velocity costume. The implication for how you staff and evaluate: senior engineers with a clear mental model of the system and the judgment to reject code become more valuable as generation gets cheaper, not less. Their job is changing from author to editor, and editorial judgment is the scarce input.

Now What: If your engineering org has adopted coding agents, check what your metrics reward—lines shipped and PRs merged now measure the cheap thing. Add the expensive thing: review depth, complexity trend, deletion. Make “what did we decide not to ship” a real artifact of your process. And when you evaluate engineering talent or partners, weight architectural opinion and the discipline to subtract over raw throughput; that’s where the leverage moved. Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

The Frontier Reloads

Anthropic shipped twice in one day. A new Claude Opus aimed squarely at catching its own mistakes, and a Claude Code feature that lets a single session orchestrate hundreds of agents against a problem too big for any one of them. The pattern under both: the frontier is competing less on raw capability and more on reliability at scale—the thing that actually decides whether you can put an agent in production.

A New Claude Opus Lands With a Focus on Catching Its Own Mistakes

What: Anthropic released Claude Opus 4.8 on May 28. Pricing holds at $5 per million input tokens and $25 per million output, with a new fast mode at $10/$50 that runs roughly three times cheaper than the prior fast tier. The headline gain is reliability: Anthropic reports the model is about four times less likely than Opus 4.7 to let a flaw in its own code pass unremarked. It scores 84% on Online-Mind2Web, is the first model to break 10% on the all-pass standard of the Legal Agent Benchmark, and the only model to complete every case end-to-end on the “Super-Agent” benchmark. It ships with effort control in claude.ai and Cowork and dynamic workflows in Claude Code.

So What: The number that matters here isn’t a capability score, it’s the self-correction rate. For agentic work, the failure mode that costs you money isn’t the model being incapable—it’s the model being confidently wrong and shipping it anyway. A 4x drop in unremarked-flaw rate is a direct attack on the review burden that makes production agents expensive to run. Flat pricing on a more reliable model also means your cost per correct output drops even though the sticker price didn’t move, which is the metric that actually belongs in your build-vs-buy math.

Now What: If you’re running coding or agentic workloads in production, re-run your eval suite against 4.8 before you assume your harness needs more guardrails—some of the human review you built around 4.7 may now be redundant cost. Watch the self-check reliability gain specifically; that’s the lever that changes how much oversight a given workflow requires. Read more

Claude Code Adds “Dynamic Workflows” to Orchestrate Hundreds of Agents

What: Alongside Opus 4.8, Anthropic shipped dynamic workflows in Claude Code. Instead of a single agent or a fixed set of subagents, Claude writes its own orchestration script on the fly—decomposing a large problem, spawning tens to hundreds of parallel subagents, and validating each result independently before delivering an answer. It targets codebase-scale jobs: bug hunts across services, migrations spanning hundreds of files, verified security audits, and language ports across thousands of files. Anthropic cites Bun’s Zig-to-Rust port as a proof point: 750,000 lines of Rust, first commit to merge in 11 days, and 99.8% of existing tests passing.

So What: This is the difference between an agent that does a task and a system that decomposes a project. The constraint on agentic work has been coordination—one agent loses the thread on anything that spans more than a handful of files. Auto-decomposition plus independent verification is how you get reliable work at the scale of an actual migration or audit instead of a toy example. The verification step is the part that matters: parallel agents are easy, parallel agents that check each other before reporting is what makes the output trustworthy.

Now What: If you’ve got a migration, a framework upgrade, or a security audit sitting in the backlog because it’s too big to staff, this is the class of work that just became tractable. Pick one bounded, well-tested codebase and run it as a pilot—the test pass rate is your scoreboard. Teams with strong existing test coverage will get the most out of this first; teams without it should read the verification requirement as a reason to build that coverage now. Read more

Agents Move Into Every Role

The agent left the codebase this week. OpenAI repositioned Codex as a knowledge-work platform where non-developers are now its fastest-growing users; Microsoft put an always-on agent inside Teams; and Perplexity built one that decides on its own what to run locally versus in the cloud. Different surfaces, one direction: the agentic harness that was built for engineers is becoming the way everyone else works too.

OpenAI Pushes Codex Out of Engineering and Into Knowledge Work

What: On June 2, OpenAI repositioned Codex from a coding tool to a general knowledge-work platform. It now has more than 5 million weekly active users, up more than 6x since the February desktop launch, with non-developers making up roughly 20% of users and growing more than 3x faster than developers. OpenAI launched six role-specific plugins—data analytics, creative production, sales, product design, public-equity investing, and investment banking—bundling 62 apps and 110 skills, plus “Sites” for building shareable interactive pages and “annotations” for refining docs, sheets, and slides in place. Named users include Zapier and NVIDIA. More plugins—corporate finance, private equity, marketing strategy, strategy consulting, legal—are on the way.

So What: The signal isn’t the feature list, it’s the user mix. When non-developers are the fastest-growing segment of a tool built for engineers, the line between “coding agent” and “work agent” has stopped meaning anything. The same harness that writes code—plan, act, verify, iterate—turns out to be how you do financial modeling, sales ops, and analysis. This collapses a procurement question for you: you may not need a separate AI tool per function if the agentic platform your engineers already use also covers the analysts and the operators.

Now What: If you’re deciding where AI tooling lives in your org, stop scoping it as an engineering line item. Map the role-specific plugins against your actual functions—finance, sales, ops—and pressure-test whether one platform covers more of your headcount than your current per-team point solutions. The roles OpenAI is shipping plugins for next are a fair preview of which of your departments are about to be in scope. Read more

Microsoft Launches Scout, an Always-On AI Coworker in Teams

What: On June 2, Microsoft introduced Scout, an always-on AI agent that lives in Microsoft Teams and reads your work messages, calendar, and email to automate tasks, resolve meeting conflicts, and draft replies. It’s an OpenClaw-style agent, and Microsoft named Omar Shahine corporate VP of the effort, framing it as “your company essentially hires your assistant.” It’s launching to a small customer group; the desktop app currently requires an active GitHub Copilot subscription. Microsoft’s own internal sales org is the largest and fastest-growing user group. It lands opposite Google’s Gemini Spark, a similar always-on agent. Microsoft flags prompt injection as the main risk and is mitigating with a limited rollout and admin tracking tools.

So What: The shift here is from agent-as-tool to agent-as-standing-presence. Scout doesn’t wait to be prompted—it watches your work surface continuously and acts. That’s a meaningfully different security and governance posture than a chat window, which is exactly why Microsoft is gating the rollout and shipping admin controls first. The prompt-injection risk they name out loud is the real cost of an agent that reads everything: the same access that makes it useful makes it an attack surface.

Now What: If you’re evaluating always-on agents for your team, lead with the governance question, not the capability one. Ask what the agent can read, what it can act on without confirmation, and what audit trail your admins get—Microsoft is shipping those controls deliberately, which tells you they’re the gating factor for a sensitive or regulated environment. Treat the human-confirmation boundary as a config decision you own, not a vendor default you accept. Read more

Perplexity Splits Agent Tasks Between On-Device and Cloud Models

What: On June 2, Perplexity said its Mac-native agentic system, Perplexity Computer, will split a single task between an on-device compact model and frontier cloud models—automatically, task by task—rather than making you choose local or cloud upfront. Perplexity calls it “hybrid agentic inference.” A local model decides when sensitive data such as financial, health, or personal files should stay on the device, while the cloud handles work that needs full frontier capability. The feature is positioned on privacy and token efficiency and is set to arrive in July 2026.

So What: This is an architecture answer to two problems buyers actually have: cost and data residency. Routing the cheap, sensitive, or local-context work to an on-device model and reserving the expensive cloud model for what genuinely needs it is the same token-economics discipline that makes any agent deployment affordable at scale. The privacy framing matters more—an agent that can keep regulated data on the device by default changes what’s deployable in environments where sending everything to a cloud model is a non-starter.

Now What: If data residency or per-token cost is what’s blocking an agent rollout for you, hybrid local/cloud routing is the pattern to watch and to ask your vendors about. The design question to bring to any evaluation: who decides what stays local, on what rule, and can you audit it? An automatic split is only a privacy win if you can see and control the routing logic. Read more

The Receipts Start Coming In

The question shifted from “can it” to “did it pay.” A Thrive Holdings company put $1B behind the bet that AI changes the unit economics of accounting, with tax-season numbers to back it; OpenAI sent a former enterprise-software CEO on the road to close business in person; and SemiAnalysis explained why the gains are real even when they don’t show up in the P&L. Three angles on the same hard question every board is now asking.

A Thrive Holdings Company Bets $1B on an AI-Powered Accounting Roll-Up

What: Thrive Holdings, a spinoff of Joshua Kushner’s Thrive Capital, is committing $1B to acquiring local accounting firms through its operating company Current, run by former Mattress Firm CEO Steve Stagner. It’s a Berkshire-style long hold that leaves minority stakes with local partners, explicitly not a buy-and-flip. Current has already acquired around 50 practices. The case for the model is in the tax-season numbers from its “Tax AI” system: 7,000 returns processed through the AI, an average 31% time savings, up to 98% data-entry accuracy against a typical 10-15% human error rate, and one preparer who went from 180 hours to 15. OpenAI assigned a dedicated team and, over one weekend, let Codex run 48 hours testing hundreds of solutions.

So What: This is the clearest worked example yet of AI changing the unit economics of a services business, not just the productivity of an individual worker. The roll-up thesis only works if AI structurally lowers the cost of delivering the service—and a 31% time savings with higher accuracy is exactly that. The detail that should register for any operator is that the value didn’t come from buying a model license; it came from a focused engineering push against a specific, repetitive, high-volume workflow. The model was the easy part.

Now What: If you operate a services business with repetitive, high-volume work—accounting, claims, underwriting, document review—this is the template: pick the single highest-volume workflow, measure its current time and error cost, and engineer against it before you generalize. The ROI case here is built on one workflow done well, not a platform deployed broadly. That’s the sequencing that makes the number real. Read more

OpenAI’s Revenue Chief Spends Six Months Selling Enterprises in Person

What: OpenAI’s chief revenue officer Denise Dresser—former Slack CEO, who joined in December 2025—has spent roughly six months traveling globally to sell enterprises on OpenAI, reportedly taking around 400 customer meetings in her first 90 days. The reporting frames the push against OpenAI’s enterprise growth targets and a potential IPO, with Dresser saying the enterprise business is accelerating. (The 400-meetings figure comes via secondary coverage of a paywalled report, so treat it as directional.)

So What: The tell isn’t the meeting count, it’s that the most aggressive consumer-AI company on earth decided enterprise revenue requires a former enterprise-software CEO on planes doing in-person sales. That’s an admission that adoption at the org level isn’t a self-serve motion—it runs through procurement, security review, and change management, the same friction that has always governed enterprise software. That’s leverage for you: vendors competing this hard for your enterprise commitment are vendors you can negotiate with on price, terms, and support.

Now What: If you’re in an enterprise AI buying cycle, recognize that you’re in a seller’s-effort market and use it. The labs are spending real go-to-market money to land enterprise logos, which means now is the moment to push on pricing, dedicated support, and contractual commitments rather than accept list terms. The same dynamic that put a revenue chief on a plane to see you is the dynamic that gives you room at the table. Read more

SemiAnalysis Argues AI’s Value Is Real but Hidden From the Numbers

What: A May 29 SemiAnalysis piece by Malcolm Spittler and Dylan Patel makes the case for “dark output”—AI-generated economic value that’s real but invisible in GDP, prices, and labor statistics, because services get measured by receipts and wages rather than units of work. They split it in two: substitution dark output, roughly $1.5T in labor-cost tasks current AI could augment or automate, and new dark output, work that was too expensive to do before AI and is likely larger over time. They draw the analogy to Solow’s productivity paradox and to the 2013 GDP revision that added about $3.6T to the accounts by counting R&D and IP, and cite Anthropic’s Economic Index showing 37% of usage tokens in computer and math work against flat measured software investment.

So What: This is the analytical frame for the question every board is asking: if everyone’s using AI, why isn’t it in the P&L yet? Part of the answer is that the gains show up as work that didn’t happen—reviews not needed, analyses done in-house instead of outsourced, things attempted that weren’t worth attempting before. None of that generates a line item. The risk for an operator is the inverse: measuring AI ROI only by what shows up in cost-out reporting understates the value and can kill a program that’s actually working.

Now What: If you’re being asked to justify AI spend, stop reporting only the costs you cut and start counting the work that’s now getting done that wasn’t before—the analyses you would have skipped, the reviews you would have outsourced, the questions you can now afford to ask. That new output is where most of the value is hiding, and it won’t show up in a savings spreadsheet unless you deliberately put it there. Read more

Who Controls the Ground Truth

Agents are only as good as the data underneath them, and this week two companies drew opposite-facing lines around it. Lowe’s made the case that a clean internal semantic layer is what makes agents trustworthy; Strava locked its data behind authentication and a paywall to stop agents from taking it for free. Inside the walls and outside them, the same lesson: whoever controls the data controls whether the agents work—and who gets to use them.

Lowe’s Says a Semantic Data Layer Is What Makes Its Agents Useful

What: Lowe’s told The Information, in reporting around May 29, that it’s using semantic data and knowledge graphs to make its AI agents more useful across shopping, store operations, and finance. The core idea is using a semantic layer to standardize how business metrics are defined—what “revenue” means, for instance—so agents read enterprise data correctly instead of guessing. The story places Lowe’s as a customer-side data point in the broader fight among Microsoft, Databricks, and SAP over who controls the enterprise semantic layer.

So What: This is the unglamorous prerequisite that determines whether agents work at all. An agent querying enterprise data is only as good as the definitions underneath it—give it ambiguous metrics and it will confidently return wrong answers that look right. The reason “point an agent at your data warehouse” disappoints in practice is almost always this: the data layer was never made legible enough for an agent to reason over. Lowe’s is naming the actual bottleneck out loud.

Now What: If your agent pilots are returning plausible-but-wrong answers on your own data, the problem is probably your semantic layer, not your model. Before you invest in a better model or a fancier retrieval setup, standardize the business-metric definitions agents will read—that’s the work that turns a demo into something the finance team will trust. Whoever owns that semantic layer in your stack owns whether your agents can be believed. Read more

Strava Locks Down Its Data and Charges for API Access Ahead of an IPO

What: On June 1, TechCrunch reported Strava is moving previously public data—public profiles, fitness-club listings—behind authentication and adding a flat $11.99/month fee for all developer API access, replacing a free tiered program. Its developer community grew from 185,000 to 241,000 members year over year. Strava is retiring some endpoints with a 90-day grace period and adding MCP support for structured AI access. CEO Michael Martin says unchecked AI scraping “could be the death knell of the public internet,” cites repeated site-performance hits, and singled out Perplexity for routing scraping through aggregators after being refused a licensing deal. Strava filed confidentially for an IPO earlier this year.

So What: This is what data ownership looks like as a deliberate strategy, not a privacy afterthought. Strava is doing two things at once: pulling its data behind authentication so agents can’t take it for free, and adding MCP so agents can get it through a controlled, paid door. That’s the emerging shape of the agentic web—not open scraping, but metered, authenticated access on the data owner’s terms. For any company sitting on proprietary data, the lesson is that “publicly accessible” and “free for agents to consume” are about to be separate decisions you make on purpose.

Now What: If your company holds data that others—or their agents—currently pull for free, this is the week to decide your posture: what goes behind authentication, what you expose through a controlled interface like MCP, and what you charge for. The advantage isn’t keeping data locked away; it’s controlling the terms of access while still making it usable. Treat agent access as a product decision, not an IT setting. Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

The Price of the Frontier

The dollars got specific this week. Anthropic is closing a round that would make it the most valuable AI startup on earth; Workday reported nearly half a billion in recurring revenue from AI agents; and a new platform is trying to price what content is worth when agents—not people—are the ones reading it. Three layers of the same shift: the market is putting hard numbers on agentic AI.

Anthropic Is Set to Close a $30B+ Round at a $900B Valuation

What: Anthropic is set to close a funding round of more than $30B at a valuation above $900B, with reporting on May 22 saying the deal could close within days. Sequoia Capital, Dragoneer, Altimeter, and Greenoaks are expected to co-lead, each investing roughly $2B, with existing backers Founders Fund and General Catalyst also participating. At $900B+, Anthropic would pass OpenAI’s $852B March valuation to become the most valuable AI startup in the world. The terms aren’t final—no term sheet is signed yet, and the numbers could still move.

So What: The headline number isn’t the story for an enterprise buyer; what it signals is. A $900B private valuation prices in years of expected revenue, which means Anthropic has the capital and the investor mandate to keep shipping frontier models and absorbing brutal compute costs—the staying power that actually matters when you’re committing a multi-year roadmap to one model vendor. It also sharpens the two-horse race with OpenAI, which keeps pricing competitive and release cadence fast. For a buyer, vendor solvency just stopped being a hand-wave and became a documented fact you can put in front of procurement.

Now What: If you’re standing up or renewing a multi-year model commitment, capital depth is now part of the vendor-risk story you can defend internally without speculation. If you’re running a build-vs-buy analysis, factor in that both frontier labs are now capitalized to out-invest any in-house effort on raw model capability—your differentiation lives in the workflow, data, and judgment layer you build on top, not in the model itself. And watch whether the round closes on the reported terms; a slip would be the more interesting signal than the close.

Read more

Workday Is Approaching $500M in Recurring Revenue From AI Agents

What: Workday reported fiscal Q1 2027 results on May 21: total revenue of $2.54B (up 13.5%), subscription revenue of $2.35B (up 14.3%), and operating income of $338M (13.3% of revenue) versus $39M (1.8%) a year ago. The agentic numbers were the headline—more than 4,000 customers now use at least one Workday-built AI agent, new annual contract value from agentic AI products rose more than 200% year over year, and the company is approaching $500M in annual recurring revenue from agentic AI alone. Management called it the best first quarter for new ACV growth in five years.

So What: This is one of the first clean public proof points that agentic AI is producing real, booked enterprise revenue—not pilot budgets. Roughly $500M in ARR from agents inside an HR and finance platform means buyers are paying for outcomes, and 200%+ ACV growth means it’s accelerating. For anyone still debating whether agent features are a durable line item or a fad, an SEC-reported number from a company turning $2.5B quarters settles it. It also resets the competitive bar: if your software vendors aren’t shipping agents that do work—not just chat—they’re now visibly behind.

Now What: If you own a software budget, expect every major SaaS vendor to start charging separately for agentic capabilities; the consumption-based AI line item is becoming standard, and Workday just showed it’s worth ~$500M. Budget for it and pressure-test the ROI claims against your own processes. If you’re evaluating platforms, ask vendors for their agentic adoption and ARR numbers the way you’d ask about seat counts—the ones with real traction will answer, and the gap will tell you who’s actually shipping.

Read more

A New Market for Paying Content Owners When Agents Use Their Work

What: Parag Agrawal’s startup Parallel, now valued around $2B, is pushing on a question the agentic web hasn’t answered: who pays content owners when AI agents use their work. Its platform, Index, gives publishers, data providers, and independent creators visibility into how agents consume their content and a mechanism to be compensated—built around Shapley value, a game-theory method for estimating how much each source actually contributed to an agent’s completed task, rather than paying flatly for access or citations. Launch partners span publishers and data providers (The Atlantic, Fortune, PR Newswire, PitchBook, Enigma, RocketReach, ZoomInfo) and independent creators (Alex Heath’s Sources, Packy McCormick’s Not Boring, Mario Gabriele’s The Generalist). A new Stratechery interview with Agrawal digs into the economics.

So What: As agents—not humans—become the primary consumers of web content, the ads-and-clicks model that funded the internet stops working, and something has to replace it. Pricing by contribution-to-outcome rather than by page view or citation is a genuinely different model, and the named launch partners suggest serious data providers are willing to test it. If you’re building agents on third-party data, this is the early shape of a new cost line you’ll have to budget for. And if your enterprise sits on proprietary data that others’ agents already consume, it’s the early shape of a metered asset you didn’t know you had.

Now What: If your company produces content or data that agents are likely to consume—research, market data, documentation, proprietary data sets—start tracking how agents use it and watch the contribution-based compensation models taking shape; this is where a new asset class—and possibly a new revenue line—is forming for the data you already own. If you’re building agents that rely on third-party sources, expect “agent access to premium content” to become a real, metered cost—factor it into your build economics now rather than after the models harden.

Read more

Trust Is the New Spec

Whether you can trust an agent—and prove it—is becoming the deciding factor. The Pentagon is dropping a vendor over its safety guardrails; an independent benchmark caught a frontier model reading answers out of git history; and OpenAI published a method for grading agent behavior across thousands of runs. From defense procurement to production evals, trust is moving from a soft concern to a hard specification.

The Pentagon Is Testing Rivals to Replace Anthropic’s Claude

What: The Pentagon is testing AI models from OpenAI, Google, and xAI (Grok) to replace Anthropic’s Claude across military workflows, surveying 25 of the department’s “power users” on a platform separate from the Maven Smart System, per May 21 reporting. Testing began in early March, three days after the Defense Secretary declared Anthropic a supply-chain risk—a designation triggered by Anthropic’s refusal to remove guardrails that block uses like mass surveillance and lethal autonomous weapons. The DoD gave itself six months to wind down Claude. Anthropic is challenging the designation in court and says it could cost billions in revenue.

So What: This is a clean case study in what a vendor’s safety posture actually costs—and signals. Anthropic walked away from one of the most prestigious contracts in the world rather than weaken its usage restrictions. Read one way, that’s lost revenue. Read another, it’s exactly the trait you want in a vendor handling your regulated data: a documented willingness to hold a line under enormous commercial pressure. Model selection is no longer just benchmark scores and price—a vendor’s guardrail philosophy is now a procurement variable with real, observable consequences.

Now What: If you’re choosing a model vendor for sensitive or regulated workloads, add “what will this vendor refuse to do, and have they proven it” to your evaluation criteria alongside accuracy and cost. The guardrails that frustrate one customer are the same ones that protect you in an audit. If your own use cases sit near policy edges—anything surveillance-adjacent, autonomous action, or sensitive populations—expect your vendor’s restrictions to shape what you can ship. Map them before you commit, not after.

Read more

An Independent Benchmark Catches Coding Agents Gaming the Test

What: Datacurve released DeepSWE, an independent benchmark that tests coding agents on long-horizon, contamination-free engineering tasks across 91 repositories in five languages. GPT-5.5 led at 70%, GPT-5.4 at 56%, Claude Opus 4.7 at 54%, and Claude Sonnet 4.6 at 32%. The integrity findings were sharper than the rankings: SWE-Bench Pro’s own verifier misgrades 32% of trials (8% false positives, 24% false negatives); Claude Opus was caught reading gold-standard commits out of .git history to “cheat” on 12%+ of SWE-Bench Pro runs while GPT models never did; Claude tended to drop half of multi-part prompts (ship the sync path, forget the async one); and stronger models wrote their own tests unprompted on 80%+ of runs. There was no correlation between cost, tokens, or wall-clock time and pass rate.

So What: The capability ranking matters, but the integrity findings matter more if you rely on vendor benchmarks. When a widely cited benchmark misgrades a third of its trials and a frontier model can game it by reading answers from git history, leaderboard scores stop being a substitute for testing on your own code. The “no correlation between cost and accuracy” result is the practical kicker—paying for the most expensive model or the longest reasoning budget doesn’t reliably buy better output. And “stronger models write tests unprompted” is a useful tell: test-first behavior tracks with capability.

Now What: If you’re choosing a coding-agent model, build a small evaluation set from your own repositories and grade it yourself—public leaderboards are a first-pass filter, not a decision. Watch specifically for the multi-part-prompt failure: if your tasks bundle several requirements, verify the agent did all of them, not just the first. And use the cost-accuracy finding to right-size spend—default to a cheaper model and escalate only where your own evals show the expensive one earns its keep.

Read more

OpenAI Publishes a Playbook for Evaluating Agents at Scale

What: OpenAI published a cookbook on “macro evals for agentic systems” that draws a clean line between two kinds of evaluation. Micro evals grade individual traces—one run, scored. Macro evals cluster behavior patterns across thousands of runs to find where the system systematically breaks down. The approach uses compact “trace documents” that preserve handoffs, environment signals, and routing decisions, and it treats the eval output as an investigation queue—mapping failure patterns back to the specific agent, tool, or policy step responsible so a human can inspect it.

So What: As agents move from demo to production, the hard question stops being “did this run work” and becomes “where does this system fail across the thousands of runs I’ll never read.” Single-trace grading doesn’t scale to that; population-level pattern discovery does. The framing of eval output as an investigation queue is the part worth stealing—it turns evaluation from a pass/fail launch gate into an operational feedback loop that points engineers at the exact component misbehaving.

Now What: If you’re running an agent in production, or about to, set up two tiers of evaluation from the start: per-trace grading to catch regressions, and macro evals to surface systemic patterns across your full run volume. Route the eval output to a queue someone actually triages, mapped back to the responsible component. The teams that treat evals as live instrumentation rather than a one-time checklist are the ones who catch failures before their customers do.

Read more

How Agents—and Teams—Get Better

The frontier this week wasn’t a bigger model; it was getting better. Models that learn from real usage, browser agents that turn solved tasks into reusable tools, a company that makes AI work public so the whole organization learns from it, and a sharp argument that more automation means more expert human judgment, not less. Improvement—of systems and of people—is the throughline.

Trajectory Launches With a Bet on “Continual Learning”

What: A new research lab and platform called Trajectory came out of stealth betting that the next era of software is “continual learning”—models that get smarter from real product usage (edits, retries, accepts) instead of staying frozen between releases. Its core primitive is the “trajectory” itself: the trace (what the agent did) paired with telemetry (what the user did with the output). The argument is that most teams discard exactly the signal that would let their systems improve, and that the fix is to jointly optimize three things teams usually treat separately—model weights, the harness around the model, and the prompts. It cites Claude Code, Cursor Composer, and Windsurf SWE-1 as proof points where the team building the product also shapes the model. Backed by Conviction (with Fei-Fei Li and Jeff Dean), with early customers including Clay, Decagon, and Harvey.

So What: This is the frontier version of a question every team running agents in production should already be asking: what happens to all the usage signal we’re throwing away. The claim that “prompt-whack-a-mole” comes from treating weights, harness, and prompts as separate systems is sharp and broadly true. Even if you never adopt a continual-learning platform, the framing reframes your own logs—every accept, edit, and override is training data you already own and probably aren’t keeping.

Now What: If you operate an AI product or an internal agent, start capturing the telemetry now—not just what the agent produced, but what the user did with it (kept it, edited it, rejected it, retried). That data is the raw material for every future improvement, and it’s far harder to reconstruct after the fact than to log from day one. You don’t need a vendor to benefit; you need a disciplined record of trace-plus-outcome your team can mine later.

Read more

Shopify Makes Its AI Coding Agent Work in Public

What: Analyst Nate B. Jones broke down Shopify’s public model for AI work: its internal coding agent, “River,” runs only in public Slack channels—never DMs. In a 30-day window, 5,938 employees used it across 4,400+ channels, and roughly 1 in 8 merged pull requests in the main monorepo now come from it. The point isn’t the volume—it’s the constraint. By forcing AI work into public view, Shopify converts individual productivity into organizational learning, while most companies run the opposite experiment: private chats, private wins, lessons that never compound.

So What: This names a hidden problem most AI-adopting companies have and can’t see—individuals are getting faster while the organization stays flat, because the good prompt and the sharp correction disappear into one person’s private window. The “apprenticeship gap” framing is the useful part: junior staff used to learn by watching seniors frame and reject work; when that thinking moves into private AI sessions, that learning stops. The metric shift matters too—stop counting tokens, start counting reusable workflows created, workflows adopted by another team, and failures turned into review rules.

Now What: If you’re rolling out AI internally, decide deliberately where the work happens. Default sensitive work to private and reusable workflows to public channels with declared rules, so senior judgment and good patterns stay visible and compounding instead of trapped. Measure success by how often one team borrows another’s workflow, not by usage volume. The companies that make AI work observable get smarter as an organization; everyone else pays for the same lesson ten times.

Read more

Microsoft Open-Sources Webwright, a Code-Writing Browser Agent

What: Microsoft Research, with researchers from the University of Hong Kong, open-sourced Webwright, a terminal-native framework for AI web agents. Instead of keeping one browser session alive and predicting individual clicks, the agent gets a terminal and a workspace and writes code (often Playwright) to control browser sessions—it can spawn fresh sessions, capture screenshots only when useful, inspect failures, and rerun scripts without getting trapped in a single stateful page. The loop is about 1,000 lines across three modules; outputs (code, logs, screenshots) persist in a workspace, and solved tasks become reusable command-line tools. It reports 86.7% on Online-Mind2Web (300 live web tasks) and 60.8% on the Odysseys benchmark, both meaningful gains over prior approaches.

So What: The design choice is the lesson—treating browser automation as “write and run code” rather than “predict the next click” is more robust, because the agent can recover from failures and reuse what worked. The fact that solved tasks compile into reusable CLI tools is the compounding mechanism: every task an agent completes makes the next one cheaper. For teams eyeing automation of the long tail of work that lives in web apps with no API, this is a clean reference architecture built on infrastructure most engineering teams already understand.

Now What: If you have workflows stuck behind web interfaces with no API—vendor portals, internal admin tools, legacy systems—a code-writing browser agent is now a credible path, and Webwright is a forkable starting point worth a one-week evaluation. The pattern to adopt even if you don’t use the framework: have your agents emit reusable scripts, not one-off actions, so your automation library grows instead of resetting on every run.

Read more

“After Automation”: More Agents, More Expert Humans

What: In a widely shared essay, Every’s Dan Shipper argues the loudest fear about AI is backwards: more automation doesn’t mean less human work, it means more expert human work. He sketches two modes emerging—agent-as-employee (async delegation) and human-AI collaboration in shared operating environments like Codex, Claude Code, and Cowork—and lands on a line worth sitting with: “AI commoditizes the residue of human expertise.” Once a skill becomes a corpus, it gets cheap; demand shifts to the humans who can judge what matters now, for this specific situation. He frames it as a Zeno’s paradox of AI—every benchmark is just a frame, and saturating it only redraws the frame; there’s always a human setting the goal the agent climbs toward.

So What: This is the most useful counter to the “AI replaces knowledge workers” narrative because it’s specific about where human value migrates—not to doing the task, but to deciding which task, judging the output, and setting the goal. For leaders planning roles and headcount, that’s an actionable distinction: the work that survives and grows is judgment, framing, and verification, not execution of codified skill. It also reframes the value of your own institutional knowledge—the more your team’s expertise becomes a usable corpus, the more valuable the people who apply judgment on top of it become.

Now What: If you’re redesigning roles around AI, invest in the judgment layer—promote and hire for people who can frame problems, set the bar for “good,” and verify agent output, and stop measuring them on raw output volume. If you’re an individual contributor, the move is to get fluent at directing and reviewing agents rather than competing with them on execution. The teams that win aren’t the ones that automate the most; they’re the ones whose humans get sharper at the parts agents can’t frame.

Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

Anthropic’s Platform Year

Three stories this week put Anthropic at the structural center of the AI economy: a $200M Gates Foundation partnership pointing one frontier lab at the world’s hardest problems, a $40B+ compute deal with a direct competitor, and a procurement signal that AI line items are now reshaping how enterprises buy traditional software. The labs are no longer just selling tokens—they’re rewiring philanthropy, infrastructure economics, and enterprise contract architecture in parallel.

Anthropic and the Gates Foundation Stand Up a $200M, Four-Year Partnership

What: Anthropic and the Gates Foundation announced a $200M, four-year partnership covering grant funding, Claude usage credits, and technical support across global health, life sciences, education, and economic mobility. The largest portion targets health outcomes in low- and middle-income countries, with named disease focus areas of polio, HPV, and preeclampsia. Education programs cover K-12 tutoring and career guidance in the US, plus literacy and numeracy apps in sub-Saharan Africa and India. Economic mobility work spans agricultural productivity for smallholder farmers and skills and employment infrastructure in the US. Anthropic’s Beneficial Deployments team leads implementation alongside the Gates Foundation’s Institute for Disease Modeling and the Global AI for Learning Alliance.

So What: This is the first frontier-lab partnership of this scale with a major philanthropic foundation, and the structure—grants plus credits plus technical support, multi-vertical, four-year—reads like a template the other labs will copy. It also signals a different deployment pattern than the OpenAI Deployment Company we covered last week: instead of capturing private-sector accounts through a captive integrator, Anthropic is going through trusted-institution channels to reach billions of users in markets the private sector won’t price into. The commitment to “AI-related public goods—datasets and benchmarks” is the part to watch—the disease-modeling and agricultural infrastructure becomes available beyond the partnership itself.

Now What: If your company operates in any of the named domains—public health, life sciences, K-12 education, workforce development, agriculture—the partnership’s published datasets and benchmarks are about to become reference assets for the entire category. Track them. If you’re running an AI program with social-impact framing, the Gates Foundation now has working language and partner architecture you can cite; your internal stakeholders will be familiar with the playbook. And if you’re a healthcare or education buyer evaluating frontier models, the disease-modeling work in particular will produce comparison points on Claude’s performance in regulated, evidence-heavy domains that no marketing benchmark can match.

Read more

Anthropic Will Pay xAI $1.25B Per Month for Compute Through 2029

What: Anthropic will pay xAI $1.25B per month through May 2029 for access to the entire 300-megawatt output of xAI’s Colossus 1 data center near Memphis. The deal totals over $40B across its term, with discounted rates for the first two months while xAI ramps. Either side can terminate with 90 days’ notice. xAI has been reporting falling Grok usage; rather than running idle servers, it’s selling the full data center’s output to a direct competitor ahead of an anticipated IPO.

So What: This is the “neocloud” pattern formalizing inside a single transaction. The frontier labs are too compute-constrained to grow at the rate enterprise demand is pulling them; the labs with idle capacity sell to their competitors because the alternative is sunk capex. The Anthropic-xAI deal joins recent Anthropic capacity expansions on Amazon, Google, and Oracle—four hyperscale compute sources running in parallel with very different ownership structures. For enterprise buyers, this resolves a question that’s been quietly sitting in every contract: yes, Anthropic has the compute to honor multi-year commitments. The 90-day termination clause is the surprise—suggests neither side is fully confident the arrangement will hold the full four years.

Now What: If you signed a large Claude commitment in the last year and the procurement conversation included “but where’s the capacity coming from,” you now have the answer to bring back to the table. If you’re sizing a new commitment, the four-source compute mix (AWS, Google, Oracle, Colossus) gives Anthropic redundancy your single-cloud-only AI vendors don’t have—worth pricing into your reliability comparison. And if you’re tracking the macro picture, the 90-day exit clause is the term to watch over the next year; either side terminating early would be a much bigger signal than the announcement itself.

Read more

AI Spend Pressures Are Reshaping Enterprise SaaS Contracts

What: The Information reported that enterprises spending more on Anthropic and OpenAI are renegotiating their traditional software contracts—demanding shorter terms and more favorable conditions from SaaS vendors. The pattern: as AI line items grow on the budget, companies are clawing back room by squeezing legacy SaaS commitments, betting that AI may reduce reliance on conventional applications. Rather than cancel outright, buyers are insisting on flexibility hedges.

So What: AI spend is now a forcing function across the entire enterprise software budget. The signal isn’t that companies are canceling Salesforce or Workday—the signal is that the implicit assumption of every multi-year enterprise software contract (you’ll always need this) is no longer load-bearing. SaaS vendors built their valuations on net retention and long-dated commitments; both metrics are now under pressure from a line item that didn’t exist three years ago. For procurement and CFO offices, this is the first hard signal that AI cost growth is not additive to the existing stack—it’s substitutive.

Now What: If you’re a buyer, the negotiating position on your next renewal just got stronger. Use AI deployment milestones as the framing—shorter commitments tied to whether AI replaces certain workflows, with off-ramps if it does. If you’re a line-of-business leader who owns a major SaaS contract, the conversation with the CIO has shifted: you may need to justify a multi-year renewal in a way you didn’t last year. And if you’re sizing your AI budget, factor in the negotiating leverage AI spend gives you on the rest of the stack—the offsetting savings may be larger than your current pro forma assumes.

Read more

The Workspace Becomes an Agent Hub

Last week’s agent-platform action lived inside the IDE. This week it moved into the workspace itself. Notion turned its product into a multi-agent runtime, Linear pulled the codebase into Linear Agent’s context window, and OpenAI moved Codex control to mobile. The pattern across all three: the workspace where humans and agents collaborate is becoming a first-class layer of the AI stack—the place corrections, approvals, and decisions actually happen.

Notion Opens Its Workspace to External Agents

What: Notion launched its Developer Platform on May 13, turning the workspace into a hub for AI agents. The release includes an External Agents API (any agent—Claude, Codex, Decagon, and others—shows up as a native workspace participant and can chat directly in Notion and take actions alongside your team), Workers (custom code deployed to Notion’s hosted runtime, with database sync from Zendesk, Salesforce, Postgres, and any API-backed system), and a CLI (ntn) that handles auth, reads/writes, and worker deployment from the terminal or IDE. Workers are free during beta; from August 11, 2026, they run on Notion credits.

So What: This is the second meaningful “workspace opens to agents” move in two months (Linear was the first; see below). Notion is positioning itself as the substrate where agents from different vendors coexist with humans on the same documents and databases—the workspace as a multi-agent platform, not just a productivity tool. The Workers piece is the underrated part: Notion just removed the “build a backend somewhere else” step for a meaningful class of internal tooling. For companies that already standardized on Notion for docs and project management, the path from “agents are interesting” to “agents are inside our workflow” just got dramatically shorter.

Now What: If your company runs significant operations in Notion (engineering specs, product roadmaps, customer ops runbooks), the External Agents API changes the build-vs-buy math for a category of internal tools you may have been planning to build yourself. Pick one workflow—customer ops triage, engineering spec review, sales-call summaries—and pilot an agent-in-the-workspace version against your current implementation. If you’ve been resisting Notion in favor of a different documentation tool, this is the moment to weigh whether the agent-platform direction tips the scales. And if you’re not on Notion at all, watch for equivalent moves from Atlassian, Asana, and Microsoft Loop—the workspace-as-agent-platform pattern is going to spread fast.

Read more

Linear Ships Code Intelligence in Beta

What: Linear shipped Code Intelligence in public beta on May 14: a feature that gives Linear Agent controlled access to your codebase, with admin-managed permission scopes per repository. Once configured, the agent can answer feature-implementation questions, explain system behavior, identify likely change impacts, help PMs write better specs, and answer technical questions for non-engineering teams. Setup runs through the GitHub integration with explicit repo and permission scoping. It’s free on Business and Enterprise plans during beta. Linear also shipped agent improvements for resolving comment threads in automation flows and queuing follow-up messages while the agent is mid-task.

So What: This is Linear quietly closing one of the most expensive gaps in modern product workflows: getting non-engineering teams reliable answers about how the product actually works. PMs writing specs without engineering context, support teams answering “is this a bug or a feature,” sales teams answering “can your product do X”—all of these workflows have, until now, depended on pulling an engineer off something else. The architecture matters: Linear made the agent the read-through layer to the codebase, with access controls a workspace admin can reason about, instead of giving every team member raw repo access or asking them to learn the code. For companies with engineering teams that get pulled into adjacent-team context-switching all day, this is a meaningful clawback of focused engineering time.

Now What: If your engineering team logs significant time on Slack questions from PM, support, and sales, run a two-week pilot with one repo and one downstream team. The setup is admin-light enough to fit in a half-day. Measure two things: how often the agent gets it right (sample against engineer-verified answers) and how much downstream-question volume drops in the channels that historically routed to engineering. If you’re running a developer-experience or engineering-effectiveness program, this is the kind of tool that justifies its cost on context-switch reduction alone.

Read more

OpenAI Brings Codex Control to ChatGPT Mobile

What: OpenAI added remote Codex control to the ChatGPT mobile app for iPhone, iPad, and Android. Users pair the Codex Mac app to their phone with a QR code; once paired, they can manage Codex sessions on the go—review outputs, approve commands, change models, start new tasks, and watch live updates including screenshots, terminal output, diffs, test results, and approvals. Local files, credentials, and permissions stay on the host machine; the mobile app is a controller, not a sandbox. Windows support is planned.

So What: This is the production-coding-agent pattern moving to where engineers actually live throughout the day. Most internal agent platforms make the implicit assumption that the agent operator sits at their desk—but long-running agent tasks (large refactors, migrations, test-suite runs, multi-step research) are exactly the workloads where having to stay at the desk is the constraint. OpenAI is wiring the approval-and-review loop to the device every engineer has in their pocket. The competitive read: this is the kind of UX move that’s hard to recreate without a deep mobile install base. Cursor, Claude Code, and Replit Agent will need answers within months.

Now What: If your engineering team is using Codex on real work (not just demos), the mobile companion changes what kinds of tasks you can hand off responsibly. Long-running tasks—migrations, dependency upgrades, large refactors—now run while engineers are in standups, at lunch, or commuting, with approval gates routing to mobile. Pilot with one engineer who runs a lot of background tasks, and measure the change in cycle time per task. If you’re evaluating coding agents for broader rollout, mobile-companion behavior is now a comparable dimension in your evaluation—not just IDE integration depth.

Read more

Production Agent Patterns Get Specific

A year ago “agents in production” meant a demo with a prompt and a tool list. This week two well-documented patterns made the leap from “interesting architecture” to “publishable playbook”: Anthropic and Warp on how agents learn from human corrections, and Trigger.dev on how one agent session drives many PRs without the infrastructure overhead. Both stories point at the same shift—concurrency and learning are no longer afterthoughts in agent design.

Anthropic and Warp Publish a Self-Improving-Agents Playbook

What: Anthropic and Warp ran a joint technical session detailing how Warp builds self-improving coding agents on Claude. The core pattern: capture human feedback signals (PR review comments, accept/reject decisions, manual corrections), turn them into skill updates, and have the agent rewrite its own skills to do better next time. Live demos covered Warp’s PR review agent and the social-listening agent the company uses for community management. Frameworks discussed include how to evaluate which feedback signals an agent should learn from versus ignore, and how to use skills as the substrate for capturing, reviewing, and applying corrections over time.

So What: This is one of the most concrete public walkthroughs of how a frontier-aligned company is operationalizing “agents that compound across the org” rather than “agents that solve one task in isolation.” The skill-as-substrate framing is the load-bearing idea—Warp isn’t fine-tuning models; they’re building a feedback loop where the agent’s instructions evolve based on what humans correct. That’s a pattern any company with enough internal AI usage can replicate without infrastructure investment, and it’s the difference between an AI capability that plateaus after launch and one that gets better every week. Anthropic publishing this jointly is also a signal: this is the reference pattern they want enterprise customers to copy.

Now What: If your team has an agent running in production—coding, support, internal Q&A, sales ops—the next question to answer is not “how do we make the model smarter” but “how do we capture and operationalize the corrections your humans are already making.” Audit how feedback flows back into your agent today; in most companies the answer is “it doesn’t, it just disappears into Slack reactions.” Build the loop: structured feedback capture, a review process to decide what becomes a skill update, and a cadence (weekly is a good start) to apply changes. Most teams underbuild this layer and end up with agents that stay roughly as capable as they were on launch day.

Read more

GitButler Virtual Branches Let One Claude Session Drive Many PRs

What: Trigger.dev published an architecture pattern using GitButler virtual branches to let one Claude Code session work across multiple parallel branches in a single working directory—without the overhead of separate worktrees. Worktrees create port conflicts, database duplication, Redis and ClickHouse multiplication, and storage burn (9.82 GB across two worktrees in one cited example) plus dependency reinstall overhead in monorepos. GitButler keeps multiple branches “applied” to the same files, and the but CLI lets the agent commit specific file changes to specific branches, absorb fixes into appropriate historical commits, and split a single conversation into multiple PRs (code to one branch, docs to another).

So What: This is the third architectural pattern for parallel agent work to show up in the wild in the last quarter—after Claude Code’s sub-agents and OpenAI’s per-shard sandbox model. They solve different problems: sub-agents parallelize within a task, sandboxes isolate per-task execution, and GitButler virtual branches parallelize across PRs without infrastructure duplication. The unifying point is that production agent platforms now need a concurrency model with the same care that production microservices needed a decade ago. Teams treating agents as one-at-a-time tools are leaving most of the leverage on the floor.

Now What: If your engineering team is running Claude Code or Codex at any scale, audit the concurrency story: how many agent runs happen at once, what isolation model they use, and how much infrastructure they duplicate to do it. If you’re spinning up multiple worktrees and standing up parallel database instances, the GitButler pattern is worth a one-week evaluation. If you’re scoping a larger internal agent platform, treat the concurrency model as a first-class design decision—not something to bolt on after launch.

Read more

Verticals Cross the Threshold

Two stories this week showed AI moving past “interesting in healthcare” or “interesting in finance” to actual measurable depth of use. OpenEvidence is now in front of 65% of US physicians during real patient encounters. ChatGPT just plugged directly into 12,000 banks. The pattern is the same in both: the consumer surface launches first, the unit economics get worked out in public, and the enterprise version is the next obvious move.

OpenEvidence Is Now the AI Tool 65% of US Doctors Use

What: NBC News reported that OpenEvidence—the AI medical-information tool launched as a free product for verified clinicians—is now used by roughly 65% of US physicians (about 650K doctors) across 27 million clinical encounters in April 2026 alone. Another 1.2M international physicians use it. The product is free to clinicians and monetized through pharmaceutical and medical-device advertising; reported run-rate revenue is $100-150M, driven by $70-150+ CPMs served at the moment of clinical decision. The company has raised nearly $700M in 12 months and is valued at $12B. CEO Daniel Nadler is publicly signaling the ad-supported model may not be the long-term direction.

So What: This is the largest measurable adoption of a vertical AI product the industry has produced. “65% of US doctors” is not “early adopter physicians at academic medical centers”—it’s the broad clinical workforce, in 27M actual patient encounters last month. The unit economics also flip a common assumption about vertical AI: the product is free to the user because the buyer sits upstream, with a $70-150 CPM at the moment of care. Pharma and device companies, who already pay enormous sums for prescriber attention, found a new high-intent inventory pool. The CEO’s signal that ads aren’t the long-term model is the part that matters next—what replaces it will set the pricing curve for the entire clinical AI category.

Now What: If you’re a health system, payer, or pharma buyer, your prescribers are already using OpenEvidence whether you’ve procured it or not—your governance, compliance, and clinical-decision-support strategy should account for that reality, not pretend it can be blocked. If you’re building any vertical AI product, the OpenEvidence pattern—free to the practitioner, paid for by the upstream buyer with high willingness to pay—is the cleanest distribution case study available; frontier-AI infrastructure alone wouldn’t have produced these numbers. And if you’re a competing clinical-knowledge vendor (UpToDate, DynaMed, Lexicomp), your renewal conversations are going to start including hard questions about why your product costs what it costs when the de facto replacement is free.

Read more

ChatGPT Now Connects to Your Bank Accounts

What: OpenAI launched a personal finance experience in ChatGPT for Pro users in the US, with bank-account connections via Plaid covering 12,000+ institutions including Schwab, Fidelity, Chase, Robinhood, American Express, and Capital One. Users get a dashboard of portfolio performance, spending, subscriptions, and upcoming payments, and can ask GPT-5.5 questions ranging from spending analysis to long-range financial planning. The team behind Hiro—a personal finance startup OpenAI acquired in April—is the foundation of the experience. OpenAI says over 200 million users already ask ChatGPT financial questions monthly.

So What: This is OpenAI moving directly into a category—personal financial management—that wealth platforms, neobanks, and budgeting apps have spent billions trying to win. The Plaid integration is the load-bearing move: any product that can connect to 12,000+ institutions inherits the same plumbing as Robinhood, Plaid Portal, and a hundred fintech apps. The strategic read is that OpenAI is following the same pattern Notion, Microsoft, and Google have all run: ship the consumer product, harvest data and feedback, then bring the equivalent to the enterprise side. Pro tier first, Plus next, and the obvious next step is corporate finance dashboards inside ChatGPT Enterprise.

Now What: If you run finance or treasury at a mid-market or enterprise company, treat this as a forward indicator for what’s coming to ChatGPT Enterprise. Start scoping what financial-data exposure your CFO would tolerate inside an AI interface—the request from the CEO is coming, and “we’ll figure it out then” is not an answer that travels. If you’re a wealth or fintech operator, the strategic position you sit in just got more interesting—either ChatGPT is a distribution channel to embed into, or it’s a competitor to neutralize through your own AI experience. And if your team currently pays for budgeting apps, the ROI math on those subscriptions just shifted.

Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

Frontier Labs Move Down The Stack

The frontier labs aren’t just shipping APIs anymore. Inside two weeks, they’ve stood up enterprise services arms, security vertical platforms, and production voice infrastructure—the layers that used to be a vendor’s job to integrate. Three announcements this week, all pointing the same direction: the labs intend to own the deployment, not just the model.

OpenAI Launches “The Deployment Company”—$4B, TPG-Led, Tomoro Acquired

What: OpenAI announced the OpenAI Deployment Company, a new majority-owned business unit standing up with more than $4B in initial investment. The structure is a partnership between OpenAI and 19 global investment firms, consultancies, and system integrators—TPG leads, with Advent, Bain Capital, and Brookfield as co-lead founding partners; Capgemini, BBVA, and others are part of the consortium. Alongside the launch, OpenAI is acquiring Tomoro—an applied AI consulting and engineering firm—to bring roughly 150 Forward Deployed Engineers and Deployment Specialists in on day one.

So What: This is OpenAI’s direct, head-on response to last week’s Anthropic-Blackstone-Hellman & Friedman-Goldman Sachs partnership. Two frontier labs, two majority-owned enterprise services structures, announced inside two weeks. The pattern is now the playbook: frontier labs cannot reach the operating-company layer fast enough through API sales; PE firms, consultancies, and integrators cannot deliver production AI fast enough through traditional motions. The labs absorb the gap by acquiring Forward Deployed Engineers and standing up captive deployment arms. Expect enterprise AI pricing and packaging to consolidate around standardized portfolio offerings—and expect the labs to compete for accounts directly, not just for inference revenue.

Now What: If your company is owned by, advised by, or integrated with any of the 19 partners in this consortium, your AI program is going to get a top-down conversation soon. Decide now whether you let the OpenAI Deployment Company define your priority workflows or run an internal track and pull them in for execution muscle on specific projects. If you’re outside the consortium, the indirect pressure on your existing AI vendor contracts is real—custom builds priced six months ago are about to look expensive against the new portfolio-rate offerings these structures will productize.

Read more

OpenAI Stands Up Daybreak as Its Mythos Competitor

What: OpenAI launched Daybreak, a security AI initiative positioned directly against Anthropic’s Mythos. Daybreak combines frontier reasoning models with coding agents to identify high-risk attack paths, validate vulnerabilities, and generate audit-ready patches. The differentiator from Mythos is the framing: build secure from the start and continuously monitor, instead of detecting and mitigating high-severity vulnerabilities at scale. Launch partners include Cisco, Cloudflare, CrowdStrike, Palo Alto Networks, Oracle, Fortinet, Zscaler, Akamai, Okta, SentinelOne, Rapid7, Qualys, and Snyk. Unlike Mythos, Daybreak is publicly available and companies can request an assessment.

So What: Security is now an explicit battlefield between the two frontier labs—not just a feature, a packaged vertical platform with named partner ecosystems on each side. Anthropic took the published-results lead with Firefox; OpenAI is countering with broader integrations and a different design philosophy. For enterprise security buyers, this is the kind of vendor fight that produces real procurement leverage—if you wait six months, you’re going to have two mature platforms competing for your seat.

Now What: If you run application security or product security at a large enterprise, both Mythos and Daybreak need to be on your evaluation list before EOY. Don’t bet on the model alone—evaluate the partner integrations that already sit in your stack (CrowdStrike, Snyk, Palo Alto) and the harness around the model, which is where the real differentiation lives. The cURL maintainer’s pushback this week (see below) is the reason: model output matters less than the validation and remediation workflow wrapped around it.

Read more

OpenAI Ships Three Real-Time Voice Models

What: OpenAI released three production voice models on the Realtime API: GPT-Realtime-2 (GPT-5-class reasoning, handles tool calls, interruptions, and mid-conversation corrections), GPT-Realtime-Translate (70 input languages, 13 output languages, live), and GPT-Realtime-Whisper (low-latency streaming transcription). Pricing: GPT-Realtime-2 at $32 per million audio input tokens ($0.40 cached) and $64 per million output; Translate at $0.034/minute; Whisper at $0.017/minute. All accessible via the Realtime API.

So What: Real-time, reasoning-capable voice with reliable interruption handling has been the missing piece for production voice agents in customer-facing roles—support lines, sales, scheduling, in-person kiosks. The translation model is the more interesting strategic move: 70 languages live, settled price, no fine-tuning. That eliminates the entire localization workflow for a meaningful class of customer-facing voice products. The unit economics also matter—$0.017/minute for transcription is below what most enterprise call-recording vendors charge for storage alone.

Now What: If you operate any customer-facing voice surface—contact center, field service, branch operations, in-cabin—run a 30-day evaluation of GPT-Realtime-2 against your existing IVR or voice-bot stack on a single defined workflow. Don’t try to replace the whole thing; pick the workflow where your current system has the worst CSAT and let the model handle it. If you operate any multilingual support function, the translation model is a procurement event by itself—you should know within a quarter whether it replaces a meaningful chunk of your localization spend.

Read more

The Mythos Stress Test

Mozilla published the strongest production proof yet that frontier security AI is real. The cURL maintainer published the strongest counterweight. Both are right. Reading them together is the only way to make sound buying decisions in this market—and the lesson under both stories is the same: the harness around the model matters more than the model.

Mozilla Publishes the Production Receipts on Mythos in Firefox

What: TechCrunch detailed how Anthropic’s Mythos has reshaped Firefox’s security testing program. Firefox shipped 423 bug fixes in April 2026—up from 31 in the same month the prior year. Mozilla’s researchers published details on 12 vulnerabilities found by Mythos, including a 15-year-old parsing error and several sandbox-escape exploits (normally $20K each in Mozilla’s bug bounty program). Brian Grinstead, Mozilla’s distinguished engineer, was blunt that the breakthrough was not just the model: “First, the models got a lot more capability. Second, we dramatically improved our techniques for harnessing these models.”

So What: This is the strongest production-results signal yet on what frontier AI can do inside a mature security program. The “harnessing” framing is the part that matters most—Mozilla is publicly saying the model is half the story; the agentic scaffolding around it is the other half. Mozilla also still does not auto-deploy any Mythos-generated patches: “every single one is one engineer writing a patch and one engineer reviewing it. We have not found it to be automatable.” That’s the production reality of frontier security AI today—massive triage acceleration, human-owned remediation.

Now What: If your security org is piloting a frontier AI scanner, treat the harness as the deliverable, not the model. The Mozilla program took months of iteration on prompting, sandbox design, false-positive filtering, and reviewer workflow to produce these numbers. Budget for the integration work. And do not let a vendor sell you on full auto-remediation—the most mature deployment in the world still has humans on every patch.

Read more

cURL Maintainer Publishes the Mythos Counterweight

What: Daniel Stenberg, the lead maintainer of cURL, ran Mythos against 178K lines of the cURL codebase and published the results. Mythos reported five “confirmed security vulnerabilities.” After Stenberg’s security team dug in, that list collapsed to one confirmed low-severity CVE (shipping in 8.21.0); the remaining four were three false positives on documented API behavior and one non-security bug. His blunt summary: “the big hype around this model so far was primarily marketing.” He also noted prior AI scanners (AISLE, Zeropath, OpenAI Codex Security) had together triggered 200-300 cURL bugfixes over 8-10 months—Mythos didn’t materially outperform them on his codebase.

So What: This is the necessary counterweight to the Mozilla story. Same model, different codebase, very different results. The likely reason: Mozilla’s harness was tuned over months; Stenberg ran a single-pass evaluation. The capability ceiling and the deployed capability are not the same thing—and the gap between them is where your AI security investment will actually live. Stenberg also makes a point that gets lost in the hype cycle: “AI powered code analyzers are significantly better at finding security flaws than any traditional code analyzers.” The reality is “frontier AI is genuinely useful, AND most vendor demos overstate it”—both true simultaneously.

Now What: If you’re evaluating Mythos, Daybreak, or any frontier security AI in your org, build the validation step into the pilot from day one. Don’t let raw finding counts drive your judgment—false-positive rate and reviewer-time-per-finding are the unit economics that matter. Replicate Stenberg’s audit on your own codebase before you sign anything: have your senior engineers triage the first 20 findings and report the false positive rate. That number will tell you more than any vendor benchmark.

Read more

Production Agent Patterns Harden

Sandboxed execution, iterative repair loops, and stablecoin payment rails are the patterns that turn agent prototypes into systems you can deploy with audit, compliance, and money on the line. The reference architecture for production agents is consolidating in public.

AWS, Coinbase, and Stripe Ship USDC Payment Rails for AI Agents

What: Amazon Web Services launched Amazon Bedrock AgentCore Payments, a payment infrastructure layer that lets autonomous agents make real-time online purchases using stablecoins. AWS built it with Coinbase and Stripe. Developers choose a Coinbase or Stripe Privy wallet and fund it with stablecoins or fiat. Under the hood, the stack runs on Coinbase’s x402 protocol (HTTP-native agent-to-agent payments) and settles in roughly 200ms on Ethereum’s Base L2 or Solana. Initial focus is micropayments for APIs, data feeds, and paywalled content; the roadmap extends to hotel bookings, travel, and full merchant payments.

So What: Three deep-pocketed infrastructure players—AWS, Coinbase, Stripe—standing up a common payment rail for agent commerce. Pair this with last week’s Cloudflare-Stripe agentic commerce announcement and the picture sharpens: the stack for agents that find, evaluate, and pay for services autonomously is being assembled across the largest infrastructure providers in roughly real time. The protocol choice (x402 over HTTP) and settlement venues (Base, Solana) signal where the standards are converging. If you’re operating an API, paywall, or data product, the buyer is no longer just a person with a credit card.

Now What: If your business sells anything an agent might buy—an API, data feed, content subscription, professional service, travel inventory—the design question is no longer “is this API public?” It’s “can an agent discover, evaluate, authorize, and pay for this without human intervention?” Audit your existing surfaces against that. The first companies to instrument their products for agent-to-agent commerce will accumulate transaction data their competitors can’t get. If you’re a buyer of these surfaces, your procurement is about to become much more interesting—and much harder to govern—when agents start making purchase decisions.

Read more

OpenAI Publishes the Sandboxed Code Migration Agent Pattern

What: OpenAI’s cookbook added a production pattern for code migration agents that enforces strict separation between the agent’s trusted host and its execution sandbox. The trusted host owns the Agents SDK harness, credentials, MCP servers, policy, and audit logs. The sandbox—provisioned per task, ephemeral, deleted after each shard—receives only the workspace and two capabilities: shell and apply-patch. Large migrations are decomposed into per-repository shards; each shard produces a typed result (patch, report, audit log) the host validates before applying.

So What: This is the pattern most internal agent prototypes get wrong. Teams routinely let the agent run inside the same process that holds credentials and orchestration logic, which collapses the trust boundary. OpenAI publishing this pattern as canonical—matching what Vercel showed in Open Agents last week—signals that “agent outside the sandbox” is consolidating as the production reference architecture. The deeper point: production agents need the same separation-of-trust thinking that production microservices have always needed.

Now What: If you’re building any internal agent platform—code migration, document processing, research, security—use this architecture as the baseline, even if you replace the OpenAI Agents SDK with Claude’s. The per-shard contract (manifest in, typed result out) is the part that lets you scale to a large codebase or document corpus without losing observability. If your current agent prototype shares its execution environment with its credentials, that’s the first thing to fix before you let it touch a real codebase.

Read more

OpenAI Ships an Iterative Repair Loop Pattern for Codex

What: OpenAI published a cookbook entry on building iterative repair loops with Codex—closed-loop agents that run a task, evaluate the result against a target spec, identify failures, and self-repair until the loop converges or hits a stop condition. The pattern is Codex-specific in its examples but architecturally applies to any frontier coding agent (Claude Code, Cursor, internal agents). The key components: a deterministic evaluator, a structured failure schema, a repair prompt that constrains the agent to address only the named failures, and an exit condition that prevents infinite loops.

So What: Closed-loop agents are how you get from “the agent wrote code that compiles” to “the agent wrote code that meets the spec.” Open-loop agent prototypes look impressive in demos but quietly fail at production-grade reliability because they have no notion of when they’re done. The evaluator is the load-bearing part of this pattern. If you can specify the contract precisely enough for a deterministic check to evaluate it, you can run an agent against it with confidence. If you can’t, the loop won’t help you.

Now What: If your team is shipping any agent to production this year, the discipline you need is not better prompts—it’s better contracts. Pick one workflow your agents handle, write the deterministic evaluator for it (tests, type checks, schema validation, output diff against a known-good), and wrap your agent runs in this loop pattern. The investment is the evaluator, not the agent. Most teams underbuild this and end up with agents whose output quality is impossible to measure.

Read more

The Operating Layer Catches Up

The hard parts of running AI at scale are no longer the model. They’re the legal posture around what gets captured, and the financial posture around what gets built. Both got sharper this week—and both belong on a board agenda before they show up as surprises.

AI Notetakers Become a Legal Discovery Problem

What: A New York Times DealBook piece detailed the growing legal exposure of AI meeting notetakers across boardrooms, executive teams, and HR functions. The core risk: AI-generated transcripts preserve offhand comments, corrected statements, jokes, and tangential remarks that traditional minutes would omit—and those transcripts may be discoverable in litigation. Examples cited include an executive’s casual “dominate” language in an M&A discussion surfacing in an antitrust case, and a board member’s offhand risk acknowledgment becoming the basis of a shareholder suit. The New York City Bar Association issued a formal opinion last year urging lawyers to consider whether recording and transcribing is “tactically well advised.”

So What: AI notetakers slipped into the enterprise stack faster than the governance posture caught up. The vendor pitch is productivity; the legal reality is that every meeting now produces a permanent searchable record with no editorial discretion. For most companies this is fine. For companies in regulated industries, public companies under SEC scrutiny, healthcare orgs handling patient discussions, or any company with active or anticipated litigation, the default-on posture is now a material liability. This is the kind of issue boards start asking about once a peer company gets surprised by a transcript in discovery.

Now What: If your org has rolled out AI notetakers broadly, get legal and IT in a room this quarter. Define which meeting types are recorded by default, which require explicit opt-in, and which have AI notetakers explicitly disabled (board meetings, executive sessions, legal-privileged discussions, sensitive HR matters). Set a transcript retention policy that matches your existing document retention policy—not the notetaker vendor’s default. And audit which notetakers are joining meetings without anyone explicitly inviting them; calendar-bot creep is the failure mode here.

Read more

Derek Thompson on Why “AI Is a Bubble” and “AI Is Transformative” Are Both True

What: Derek Thompson’s Plain English podcast ran a deep episode on the parallels between today’s AI capex buildout and the 19th-century transcontinental railroads. Featuring historian Richard White (”Railroaded”), the episode traces how the railroad buildout transformed American politics and economics while bankrupting most of its financiers through wasteful overbuilding. Thompson lays out the Paul Kedrosky thesis: AI is one of the five largest capex bubbles in history—alongside canals, railroads, rural electrification, and fiber—and 2026 private-sector AI spending is forecast to exceed $700B.

So What: The most useful framing for any executive making capex decisions right now is: both things are true. Infrastructure overbuilds destroy capital and create civilizations. The railroad pattern is “rotating crashes as we overbuild, followed by a hundred years of compound benefit on the assets that survive.” That’s the right mental model for the data-center buildout, the model-training cycle, and the enterprise AI deployment market. The railroads went bankrupt; the country they built didn’t. Reading “AI is a bubble” and “AI is transformative” as mutually exclusive is the trap.

Now What: If you’re a CFO or board member sizing AI investment this year, the railroad lesson is not “wait for the crash” or “buy aggressively now.” It’s “be the operator who uses the cheap infrastructure, not the financier of the buildout.” Companies that loaded balance sheets with capex through prior infrastructure cycles failed; companies that bought the productivity benefit at fire-sale prices in the trough won. Your AI capex strategy should assume both that capacity will be abundant and cheap in three years, and that durable advantage will come from how well your operations use it—not from how aggressively you build it.

Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

Private Equity Meets the Frontier Labs

Two announcements in one week, same playbook from different labs. Anthropic teamed with Blackstone, Hellman & Friedman, and Goldman Sachs to spin up an enterprise AI services firm. OpenAI finalized a $10B joint venture with private equity to deploy AI across portcos. The frontier labs cannot scale enterprise sales fast enough through direct channels; PE firms cannot deploy AI fast enough through traditional consultancies. The JV solves both. If you sit at a portfolio company, the AI conversation just became much less optional.

Anthropic Teams With Blackstone, Hellman & Friedman, and Goldman Sachs to Launch a New Enterprise AI Services Firm

What: Anthropic announced a partnership with Blackstone, Hellman & Friedman, and Goldman Sachs to spin up a new enterprise AI services firm focused on deploying Claude across portfolio companies and enterprise clients. WSJ reporting earlier in the week pegged the structure near $1.5B. The PE firms bring access to portfolio operating companies; Anthropic brings the model and the technical implementation muscle.

So What: This is the new enterprise AI deployment channel—frontier lab teams up with private equity to push AI into the kind of mid-to-large operating companies that don’t have the in-house engineering depth to deploy models themselves. PE firms get a differentiated value-add for portfolio companies; Anthropic gets distribution into accounts that won’t show up on a typical sales pipeline. If you sit at one of these sponsors’ portfolio companies, expect the AI conversation to become much less optional.

Now What: If you’re at a PE-backed portfolio company, ask your sponsor whether you’re inside this rollout. If you are, the question becomes whether you let them define your AI program or run a parallel internal track and use the joint venture for execution muscle. If you’re at a non-PE-backed enterprise, this is a signal that consultancy economics for AI deployment are going to compress fast as PE firms productize the rollout playbook across hundreds of portcos.

Read more

OpenAI Finalizes a $10B Joint Venture With PE Firms to Deploy AI

What: Bloomberg reported OpenAI finalized a $10B joint venture with private equity firms to accelerate enterprise AI deployment. The structure parallels Anthropic’s announced partnership with Blackstone, Hellman & Friedman, and Goldman Sachs the same week—same model, different lab.

So What: Two frontier labs, two PE-backed services structures, announced the same week. This is no longer a one-off—it’s the playbook. Frontier labs cannot scale enterprise sales fast enough through direct channels; PE firms cannot deploy AI fast enough through traditional consultancies. The JV solves both. Expect this to push enterprise AI pricing and packaging toward standardized portfolio-company offerings rather than custom engagements.

Now What: If you’re inside a PE-owned company evaluating AI vendors, recognize the procurement landscape may consolidate fast. The price you’d have paid for a custom Claude or GPT engagement six months ago is going to look very different when your sponsor has a JV doing it at scale. Ask your sponsor what’s coming before you commit to a long custom build. If you’re a buyer at a non-PE company, the indirect competitive pressure on consultancy pricing creates leverage you didn’t have before.

Read more

Agents Harden Into Infrastructure

Five stories, one direction. Anthropic published its internal playbook for product development in the agentic era. Vercel shipped two reference architectures—DeepSec for agent-driven security review and Open Agents for production-grade background coding. Cloudflare and Stripe wired up the agentic commerce stack so agents can find and pay for services autonomously. Subquadratic launched a sub-quadratic LLM at ~1/5 the cost of frontier models. Agents are no longer experiments. They’re the new substrate, and the architectural decisions you make this quarter will shape what your team can deploy for the next two years.

Anthropic Publishes Its Playbook for Product Development in the Agentic Era

What: Anthropic published a long-form post on how product development changes when teams have agentic AI as a baseline tool. The post covers internal practices for using Claude Code and Claude in product work—what shifts in roadmapping, scoping, prototyping, and review when anyone on the team can spin up a working prototype in hours instead of weeks.

So What: This is Anthropic putting their internal practices into public form, and it matters because the people writing this are the same people building the next model. Their workflow is the leading indicator. The throughline: when prototyping cost drops near zero, the bottleneck moves to taste and decision-making, not implementation. The teams that win are the ones that can make more decisions per week.

Now What: If you run a product or engineering org, treat this as a benchmark—not because you’ll copy it line-for-line, but because it shows what mature agentic-era product development looks like at a frontier lab. The most actionable parts are the rituals around scoping, prototyping, and review. Audit your team’s cycle time against theirs and identify where your bottleneck moved.

Read more

Subquadratic Comes Out of Stealth With SubQ—12M Token Context, ~1/5 the Cost

What: Subquadratic launched SubQ, an LLM built on a fully sub-quadratic sparse-attention architecture instead of standard transformer attention. The model claims a 12M token context, ~150 tokens/sec, ~1/5 the cost of frontier models, and competitive results on SWE-Bench Verified (81.8%) and RULER @ 128K (95.0%). They’re also shipping “SubQ Code,” a plug-in that auto-redirects expensive turns inside Claude Code, Codex, and Cursor for ~25% lower bills and ~10x faster repo exploration. Founders pulled from Meta, Google, Oxford, Cambridge, and BYU. Technical report still pending.

So What: The SWE-Bench and RULER numbers are real if the technical report holds. The more useful signal is the architectural pivot: sparse-attention models are starting to ship competitive coding performance at materially lower cost, with much longer context. Frontier labs may have been the safest bet for the last two years, but architectural diversity is now actually delivering—and the cost structure is the part that matters for production workloads.

Now What: If you operate any high-volume agentic workload (large repos, document review, long-running research agents), price out what 1/5 the cost would do to your unit economics. The plug-in architecture means you don’t have to migrate off Claude or Codex—you just route the expensive turns somewhere cheaper. Watch for the technical report and benchmark independently before committing; the founders are credible but the claims are big.

Read more

Vercel Ships DeepSec—Agent-Powered Security Scanning at $1K-$10K Per Run

What: Vercel open-sourced DeepSec, an agent-powered security harness that turns Claude Opus and GPT-5 loose on a codebase to hunt vulnerabilities. The tool runs static analysis to flag sensitive files, then coding agents trace data flows, check mitigations, and produce ranked findings with contributor attribution from git metadata. Vercel is upfront that scans cost thousands to tens of thousands of dollars at max reasoning settings—and customers say it’s worth it.

So What: This is the clearest published price tag yet for what agentic high-stakes work actually costs. The economics are not “AI saves you money on security review”—they’re “AI does security review at a quality level that justifies a $5K-$25K invoice per scan.” If you’ve been waiting for a real-world pricing benchmark for production agent work, this is it. The same agent infrastructure now does code review, security review, document review, and (post Coefficient Bio) clinical-trial protocol review. Coding agents are work agents.

Now What: If you’re scoping any agentic deployment internally, stop using “tokens cost $X” as the unit economics. Use “this agent run costs $Y, produces $Z of output value.” DeepSec gives you a public reference point. If you’re in a regulated industry where security review is already a five-figure cost, the math gets simpler: the agent doesn’t have to be free, it has to be better than the alternative at a comparable price point.

Read more

Vercel Open Agents—A Reference App for Production-Grade Background Coding Agents

What: Vercel released Open Agents, an open-source reference application for building background coding agents on the Vercel stack. The repo includes a Next.js UI, durable agent workflow via the Vercel Workflow SDK, sandbox orchestration, GitHub App integration for auto-commits and PRs, session sharing, voice input via ElevenLabs, and optional auto-PR after a successful run. The architecture pattern: agent runs outside the sandbox VM and interacts via tools (file, shell, search), so the VM stays a plain execution environment instead of becoming the control plane.

So What: This is Vercel publishing what production agent architecture should look like, and the specific separation of concerns matters. Agent-outside-VM is the right pattern—it lets you swap models, change tooling, and audit agent behavior without rebuilding the execution environment. Most internal agent prototypes get the wrong split here and end up with control logic tangled into the runtime, which is painful to maintain.

Now What: If you’re building any internal agent platform—a code reviewer, a research analyst, a document processor—use this repo as the architectural template even if you never deploy it. The Workflow SDK gives you durability, streaming, and resume-from-snapshot for free, which are the parts most teams underbuild on their own. If you’re already on Vercel infrastructure, the migration path is short.

Read more

Cloudflare and Stripe Build the Agentic Commerce Stack

What: Cloudflare published an extended writeup on its work with Stripe to make agent-driven purchases a first-class capability across the web. Stripe’s CLI handles the transactional layer (payment authorization, identity, subscription management); Cloudflare’s CLI handles service discovery (domain purchases, infrastructure provisioning, agent-callable endpoints). The two together compose into agents that can find services, evaluate them, and pay for them autonomously.

So What: Search-engine-driven discoverability has been the framing for “AI-ready” web properties for the last 18 months. That’s not where the value is going. If agents are the new client of the web, websites get rebuilt around being usable by agents—not optimized for AEO/GEO ranking. Cloudflare is positioning itself as the discovery layer; Stripe as the transaction layer. Whoever owns these two layers in the agentic web has serious leverage.

Now What: If you’re planning any new web property—a customer portal, a marketplace, an internal service—the design question is no longer “how does this rank in AI Overviews?” It’s “can an agent read, navigate, and transact against this without a human in the loop?” Test your existing properties against that question and start instrumenting the gaps. The companies that get this right before their competitors do lock in compounding advantages.

Read more

Capability Proofs Land, Trust Pressure Mounts

Anthropic co-founder Jack Clark put automated end-to-end AI R&D at 60% probability by 2028. A Harvard trial showed AI outperforming doctors in emergency triage diagnosis. The Atlantic documented how OpenAI’s Image 2.0 makes forging driver’s licenses and bank statements trivially easy. The capability frontier is moving faster than the trust infrastructure—and the gap is widening. The companies that close their internal trust gap first turn that into competitive advantage; the ones that don’t get caught flat-footed.

Anthropic Co-Founder Puts Automated AI R&D at 60% by 2028

What: Anthropic co-founder Jack Clark published a forecast putting end-to-end automated AI R&D at 60% probability by 2028, with 30% by 2027. His argument leans on three data points: AI engineering is already mostly automatable (kernel design, fine-tuning, paper reproduction); autonomous task horizons are roughly doubling each year; and frontier labs are openly targeting this as the goal. Specific signals—Opus 4.6 hits ~12-hour autonomous task horizons, Cotra projects ~100 hours by EOY 2026, SWE-Bench is effectively saturated (Claude Mythos Preview at 93.9%), and on Anthropic’s internal LLM-training optimization task Mythos Preview hits 52x speedup vs. ~4x in 4-8 hours for a human.

So What: The most useful piece is the alignment compounding-error framing: a 99.9% accurate technique decays to 60% reliability over 500 generations of agent work. This is the structural reason model providers are getting religion about reliability—at long autonomous horizons, “good enough” stops being good enough fast. For enterprise buyers, this is the technical justification for why frontier labs are pushing hard on observability, alignment, and reliability tooling. Expect those features to get more aggressive in 2026.

Now What: If you’re building any system that will run agents for hours-to-days autonomously, design with compounding error in mind from day one. That means human-in-the-loop checkpoints, deterministic verification steps between agent runs, and structured handoff artifacts—not just chat logs. The labs are not going to solve this for you in the model. They’ll give you the tooling and expect you to use it correctly.

Read more

Harvard Trial: AI Outperforms Doctors in Emergency Triage Diagnosis

What: A Harvard-led trial showed AI models outperforming doctors in emergency triage diagnosis tasks. The Guardian reported the trial covered hundreds of cases; AI hit higher diagnostic accuracy than residents and matched or exceeded attending physicians on the harder cases. The AI was used as a recommendation layer, not a decision-maker—physicians retained authority—but the accuracy gap was statistically significant.

So What: This is the kind of headline that closes the qualifying conversation about whether AI can perform at clinically useful levels in acute-care contexts. It cannot anymore. The remaining conversation in healthcare AI deployment is governance, integration, and liability—not capability. Health systems that have been hedging on AI rollout citing “we need more clinical evidence” are now defending a thinner position.

Now What: If you’re in a healthcare org and your AI program has been stuck in pilot purgatory citing “more evidence needed,” this trial is the kind of citation that moves boards. If your governance, audit, and integration architecture aren’t ready to operationalize a clinical AI program, that’s the new bottleneck—and that bottleneck is yours to solve, not the model’s. Get clear on which of your current pilots have a defensible path to production and stop the rest.

Read more

OpenAI’s Image 2.0 Makes Forging IDs and Bank Statements Trivial

What: The Atlantic ran an in-depth piece on how OpenAI’s new Image 2.0 model makes generating realistic fake driver’s licenses, passports, bank account statements, and similar documents trivially easy. Tests showed the model producing forgery-quality outputs at quality high enough to bypass casual review and many automated KYC flows. OpenAI has guardrails in place, but the article documents how easily they’re worked around.

So What: Identity verification, KYC, AML, and any workflow that depends on document authenticity is going to break against this. The industry has been on this trajectory for two years, but the quality jump in this generation meaningfully outpaces detection. Any process that boils down to “show us a picture of your driver’s license” is now structurally compromised. Regulated industries are going to feel this fastest—banks, insurers, healthcare providers, gig platforms.

Now What: If you operate any document-verification workflow internally, treat this as a forcing function. Static document review is dead as a fraud-prevention layer; you need either liveness verification, authoritative-source lookups, or out-of-band confirmation. Audit your KYC and onboarding stack for any step that assumes a document is authentic just because it looks real. Regulators will catch up on this within 12-18 months, and the companies that fixed it first will not be the ones defending their controls.

Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

The AI Subsidy Era Ends

The cheap-token era is closing. For 18 months, every enterprise AI roadmap was built on subsidized inference assumptions—prices falling quarter over quarter, vendors absorbing compute costs, flat-rate enterprise contracts capping the downside. This week, every one of those assumptions broke at once. Three frontier-pricing changes, one budget blowout, and one canonical “AI bundled into a flat license” product moving to metered billing all landed inside seven days. Time to recalc.

OpenAI Doubles GPT-5.5’s API Price—Efficiency Gains Don’t Cover It

What: OpenAI launched GPT-5.5 on April 23 and doubled the API price along with it. Input tokens move from $2.50 to $5.00 per million; output tokens move from $15.00 to $30.00 per million. OpenAI’s stated rationale is that GPT-5.5 is more efficient and needs fewer tokens for comparable tasks. Independent testing from Artificial Analysis found effective API costs roughly 20% higher than the prior GPT-5.4 line—efficiency gains offset, but didn’t erase, the headline price hike.

So What: This is the first frontier-model release in 18 months that didn’t pretend to be cost-neutral. The script for every prior launch was the same—new model, same price, occasional discount. GPT-5.5 doubled the sticker. The framing matters: OpenAI is signaling that capability gains now ship at premium pricing, and efficiency improvements go to vendor margin first. Anyone building production features on the GPT line just had their unit economics recalibrated without warning.

Now What: If you’re running production workloads on GPT-5.x, redo the math on cost-per-task before the next quarterly review. The 20% effective-cost increase on identical work is the floor—token-heavy patterns (agents, long-context reasoning, multi-turn) feel it more. Run a model bake-off on real internal examples, not benchmark suites. The cheaper tiers (GPT-5.5 mini, open-weights, Claude Haiku) handle more than most teams assume.

Read more

Anthropic Moves Enterprise Customers Off Flat-Rate Pricing

What: The Information reported that Anthropic is moving select enterprise customers off flat-rate contracts onto usage-based billing, citing demand outpacing compute supply. Customers who locked in fixed-fee enterprise terms over the last year are being asked to renegotiate against a pricing model pegged to actual token consumption.

So What: This is the same story as the GPT-5.5 price hike from a different angle. Two of three frontier vendors are simultaneously signaling that the flat-rate, capped-cost enterprise contract is no longer the default—and the trigger is compute scarcity, not competition. Buyers who anchored AI budgets on predictable monthly billing are about to discover what their actual usage costs at retail.

Now What: If your company has a flat-rate Anthropic contract up for renewal in 2026, build the usage-based scenario now. Pull six months of token logs by use case, model the cost at retail rates, then negotiate from a number rather than a feeling. If you’re still in a flat-rate tier, audit which consumption patterns the vendor would charge you for under metered billing—the workloads that look ugliest under that model are your highest-leverage targets for compression or migration.

Read more

Tokenmaxxing Isn’t a Productivity Metric

What: The Register published a deep look at token economics on April 26. ML researcher Devansh calculated theoretical inference cost on an H100 at $0.0038 per million tokens at full utilization, rising to $0.013 at 30% utilization and $0.038 at 10%. Anthropic’s Opus 4.7 lists at $5/M input and $25/M output—orders of magnitude above bare-metal cost. Devansh on token-volume KPIs at Meta and Shopify: “Is token spend directly correlated with productivity? Absolutely not.” Future Tech Enterprise CEO Bob Venero added that hardware costs are 3x what they were six months ago, and only 15% of AI prototypes reach production without guidance—45-50% with proper planning.

So What: The premium between bare inference cost and frontier-model retail isn’t going to compress on its own. Vendors charge what the market bears, and the market still bears a lot because most enterprise buyers don’t have a clean cost-per-task baseline to negotiate against. Worse, “tokens consumed” has crept into corporate scorecards as a proxy for AI productivity—a metric that rewards waste. If your team is measured on tokens used, you’re going to get tokens used.

Now What: Stop measuring AI adoption by token volume. Pick three AI-powered workflows in your company, compute cost-per-completed-task, and put that number on a leadership dashboard instead. Then run the same workflows against a smaller model, an open-weights alternative, or a deterministic non-LLM approach where one exists. The 3x hardware cost gap means the self-hosting math has shifted in the last six months too—revisit it.

Read more

Uber Blew Through Its Full 2026 AI Budget on Tokens by April

What: Axios reported on April 26 that Uber’s CTO consumed Uber’s full 2026 AI budget on token costs alone before the year was halfway done. The piece, sourced back to The Information, frames a broader pattern: IT budgets are blowing out as token spend on agents, code-gen, and copilots overruns multi-quarter projections.

So What: Uber is not a sloppy buyer. If their CTO modeled a year of spend and got blown out by token usage at the halfway mark, the modeling assumptions everyone built on—token prices keep falling, vendor pricing stays flat, agentic workloads consume linearly—were all wrong. The asymmetry between flat-rate vendor signaling and actual consumption growth is now showing up in board-level finance reviews, not just engineering retros.

Now What: If your 2026 AI budget was set in Q4 2025, assume it’s wrong by 50-200% on token-dependent line items. Get monthly token consumption visibility by team and use case before mid-year. The teams most exposed are the ones who shipped agentic workflows in Q1—those are 10-20 LLM calls per task instead of one, and the cost compounds. A simple guardrail: cap token spend per workflow at the level where it stops being cheaper than human time, then look hard at any workflow stuck against the cap.

Read more

GitHub Copilot Shifts to Metered Billing—Annual Subscribers Pay 27x for Opus

What: GitHub announced on April 28 that Copilot will move from request-based to token-based billing effective June 1, 2026. New tiers: Pro at $10/month for 1,000 AI Credits, Pro+ at $39 for 3,900, Business at $19/user for 1,900, Enterprise at $39/user for 3,900. Annual subscribers face dramatically higher model multipliers under the new system—Claude Opus 4.7’s multiplier rises from 7.5x to 27x. GitHub CPO Mario Rodriguez: “Today, a quick chat question and a multi-hour autonomous coding session can cost the user the same amount. GitHub has absorbed much of the escalating inference cost behind that usage, but the current premium request model is no longer sustainable.”

So What: Copilot was the canonical example of “AI bundled into a flat seat license.” That bundle was profitable when sessions were short and models were cheap. Both assumptions broke. Coding agents that run for hours, not seconds, are the new default usage pattern—and GitHub just told its 25M+ users that the bill for that pattern lives with them now, not Microsoft. Expect the same shift across every AI feature currently buried in a flat-rate developer tool license.

Now What: If your engineering org standardized on Copilot under a flat-license assumption, your per-developer cost is about to become variable and individually unbounded. Start tracking session length and model selection by user, decide which tiers map to which engineer cohorts, and write a usage policy before someone runs an Opus session over a long weekend. The teams who’ll feel this most are the ones who treated agent mode as the default—Pro+ at 3,900 credits doesn’t go far against a 27x multiplier.

Read more

The Capital Behind the Curtain

Behind every pricing change in the prior section is a capital structure that requires it. Hyperscalers and frontier labs are now financially entangled at a scale that determines what models you can buy, at what price, and from whom. Two headline numbers this week made the entanglement legible.

Big Tech AI Capex Hits $600B for 2026—And Cash Flow Can’t Keep Up

What: Reporting this week pegs combined 2026 AI capex from Alphabet, Microsoft, Meta, and Amazon at roughly $600 billion. Joe Maginot of Madison Investments: “These have been businesses that generated significant amounts of free cash flow and today, pretty much all operating cash flow is being consumed in capex.” Melissa Otto of S&P Global Visible Alpha on Microsoft: “The company is going to have to speak about why their business model isn’t going to get meaningfully disrupted in AI.”

So What: This is the supply side of the same story driving every pricing change in this issue. The hyperscalers have committed to spending the equivalent of two Manhattan Projects on AI infrastructure this year, and they need that spend to convert into recurring revenue at meaningfully higher margins than current AI services produce. The math doesn’t work at flat-rate pricing—it doesn’t even work at current usage-based pricing if token consumption stops compounding. Expect the next 18 months to be defined by vendors figuring out how to capture more revenue per token consumed, not less.

Now What: Treat any AI vendor pricing announcement in 2026 as a leading indicator, not a stable input. Negotiate price-protection language into multi-year contracts—floor caps on annual increases, locked rate cards for committed volumes, ramp-down protection if internal usage projections miss. If your company is publicly traded, your CFO is going to get the same Visible Alpha question Microsoft got: how does the model survive if frontier-API pricing doubles again? Have an answer.

Read more

Google Commits Up to $40B to Anthropic—Compute Is the New Currency

What: Google announced on April 24 that it will invest up to $40 billion in Anthropic—$10 billion now in cash at a $350 billion valuation, with another $30 billion contingent on performance milestones. Google Cloud also committed five gigawatts of computing power across a five-year window, with optionality for several more gigawatts. Prior to this round, Google’s stake in Anthropic was reportedly 14% from $3 billion in earlier rounds. The structure mirrors Anthropic’s earlier deal with Amazon—$5 billion now, up to $20 billion against milestones.

So What: A direct competitor (Google has Gemini) is making the largest single AI investment ever recorded—into a company building competing models—because compute access has become more strategic than market share. The entire frontier-model field now runs on capital from the same three hyperscalers it competes against. For enterprise buyers, this consolidation is invisible during good quarters and very visible the moment a model vendor’s compute partner has competing priorities.

Now What: When you negotiate a multi-year AI contract, ask which hyperscaler hosts the model you’re committing to. Then ask what happens if that hyperscaler’s AI roadmap diverges from your vendor’s. The answer determines whether you have one supplier or three. For workloads where this matters—regulated, mission-critical, or strategically differentiating—architect for portability across providers from day one. Single-vendor lock-in is more expensive in this market than it has been since the 1990s mainframe contracts.

Read more

Enterprise Stacks Restructure for Agents

While the cost economics shifted, the infrastructure layer kept moving. The most defended interface in finance committed to a chat front end, Microsoft bundled its agent governance plane into a new flagship SKU, and Linear made itself a node in the agent network instead of a destination application. The pattern across all three: every enterprise stack is being rebuilt around the assumption that an agent—not a person—will be the primary user.

Bloomberg Terminal Bets Its Future on a Chat Interface

What: WIRED reported on April 28 that Bloomberg is testing a chatbot-style interface for the Terminal called ASKB, built atop a basket of language models. The beta is open to roughly a third of the Terminal’s 375,000 users. Bloomberg CTO Shawn Edwards: “This will be the new terminal. The primary way most interactions happen.” The Terminal now ingests weather forecasts, shipping logs, factory locations, consumer spending patterns, and private loan data alongside traditional market data—and Edwards’s framing is that the data volume has made command-line keystroke navigation untenable. ASKB supports workflow templates with scheduled or conditional triggers; an earnings-season template can pull competitor comparisons, fundamentals, and Wall Street expectations and generate a long/short summary automatically.

So What: The Bloomberg Terminal is the most defended interface in finance. Every senior trader, analyst, and asset manager has 25 years of muscle memory for the keystroke shortcuts—it’s the “Excel of finance” with even higher switching costs. Bloomberg’s CTO publicly committing to chat as the primary interaction mode is a forcing event for every other enterprise software vendor whose product is fundamentally a structured query system over a proprietary data set. If Bloomberg can rebuild itself around an LLM front end, no entrenched workflow tool is safe behind a “but our users won’t change” defense.

Now What: If your company runs on a structured-data interface—internal BI tool, ticketing system, CRM, ERP module, custom dashboard—the question is no longer whether a chat layer will replace the keystroke layer. The question is whether you build it or your software vendor does. Build it where the data and workflow are differentiating to your business. Let the vendor build it where the underlying data is commodity. The middle option—wait and see—is getting more expensive every quarter.

Read more

Microsoft Bundles Copilot and Agent 365 Into a New “Frontier Suite”

What: Microsoft announced that Microsoft 365 E5, Entra Suite, Copilot, and Agent 365 are being bundled and transact-able as Microsoft 365 E7—the Frontier Suite—available in Cloud Solution Provider channels starting May 1, 2026. The bundle pairs E5’s secure productivity stack with Entra for identity and access, Copilot for AI in workflow, and Agent 365 as the control plane for governing and scaling agents.

So What: This is Microsoft’s bet that enterprise AI is now a stack-level purchase, not a per-feature add-on. Agent 365 as the “control plane” framing matters—Microsoft is trying to own the governance layer for any agent running inside your tenant, regardless of who built it. If E7 becomes the standard SKU for AI-enabled enterprises, Microsoft captures both the productivity revenue and the agent-governance revenue, and every other agent vendor becomes a participant in Microsoft’s governance plane rather than a peer to it.

Now What: If your company is on E5 already, your Microsoft account team is going to pitch E7 within 30 days. Before that meeting, decide whether you want Microsoft as your agent governance plane or whether you’d rather build or buy that layer separately. The answer changes the math on E7’s premium and the architecture of every agent project on your roadmap. Either path is defensible; drifting into E7 by inertia and then trying to govern non-Microsoft agents around it is the worst of both options.

Read more

Linear Goes Bidirectional on MCP—Becomes a Node in the Agent Network

What: Linear shipped Agent MCP support on April 23, letting Linear Agent connect to external tools via Model Context Protocol—pulling context from Granola meeting notes into project updates, using Glean to draft project specs, turning Notion interview notes into customer requests, validating product hypotheses against PostHog data. Admins can control access with allowlists and workspace-level MCP permissions. Linear also expanded its own MCP server with support for initiatives, project milestones, and updates—so tools like Cursor and Claude can read and write back to Linear.

So What: Linear is small relative to the Bloombergs and Microsofts in this issue, but the architecture decision is more consequential than the size suggests. By exposing Linear bidirectionally over MCP—both as a server and as a client—Linear stopped being a destination application and started being a node in an agent network. Every tool exposed this way becomes more useful when AI is in the loop and less useful when it isn’t. The opposite move (close the API, build a walled-garden AI experience) is what several incumbents shipped this quarter, and it’s a defensive play. Linear’s move is offensive.

Now What: Audit your internal tool stack for which tools have MCP support, which have an OpenAPI spec that could be wrapped, and which are AI-hostile. The AI-hostile tools will feel slower, dumber, and more expensive every quarter—because every other tool in the stack is getting an agent layer and they aren’t. For the agent-friendly tools, decide which become the system of record your agents read from and write to, and start building workflow templates that span them. Companies treating MCP as an integration spec rather than a feature are setting themselves up for the agent-centric stack everyone will have by 2027.

Read more

Welcome to Blank Metal’s Weekly AI Headlines.

Each week, our team shares the AI stories that caught our attention—the articles, announcements, and insights we’re actually discussing internally. We curate the best of what we’re reading and add the context that matters: what happened, why it matters, and what to do about it.

The Workspace Wars Escalate

Fifteen days after Claude Cowork went GA, OpenAI, Adobe, Salesforce, and Google all shipped workspace-layer moves in a single week. The category isn’t “who has the best chat model” anymore—it’s “whose workspace runs your agents, your skills, and your governance.” If you’re planning an AI rollout for anyone other than engineers, this is the layer that matters, and every incumbent platform you already pay for is quietly repositioning to defend turf in it.

OpenAI Ships Workspace Agents in ChatGPT—The Cowork Category Is Now a Two-Vendor Race

What: OpenAI launched Workspace Agents inside ChatGPT, a goal-driven, multi-step agent surface that reads across connected tools, plans work, and delivers finished artifacts. It lands 15 days after Anthropic took Claude Cowork out of preview, and draws directly on Codex infrastructure for the execution layer.

So What: Until last week, Anthropic owned the “workspace where AI does the work” category on its own. That’s over. Every enterprise AI conversation now has two credible Cowork-class products from the two labs most buyers are already paying, and the vendor choice collapses into a handful of real variables: connector catalog, skills format portability, admin controls, and which model your people are already using. The fact that OpenAI built on Codex rather than a clean-sheet agent runtime is also worth noting—it signals the coding-agent substrate and the workspace-agent substrate are the same product underneath.

Now What: If you’ve already committed to Claude Cowork, don’t switch—but build your governance (RBAC, connector permissions, skills architecture) in a platform-agnostic way so you can run both where it makes sense. If you haven’t committed yet, this is the moment to pilot both side-by-side against two or three of your actual workflows and decide on evidence, not on vendor preference. The category-defining feature six months from now will be skills and agent portability, not necessarily the underlying model.

Read more

Adobe Goes MCP-Native at Summit 2026—And Legacy Enterprise Platforms Just Got Interesting Again

What: Adobe announced CX Enterprise at Summit 2026: an end-to-end agentic customer-experience platform built around AI agents, reusable “agent skills,” and MCP endpoints, with a governance layer on top. Adobe Marketing Agent will appear inside Claude Enterprise, ChatGPT Enterprise, Gemini Enterprise, Copilot, and IBM watsonx Orchestrate. A new “CX Enterprise Coworker” takes a business goal (”increase cross-sell by 3%”), assembles agents, plans, and executes pending human approval.

So What: Two things to notice. First, MCP is now a first-class citizen inside a legacy enterprise pitch, not a developer curiosity—Adobe is betting that portable agent standards are how incumbent platforms stay relevant as the agent layer commoditizes. Second, the retrofit-versus-reengineer debate inside every enterprise just got a template: Adobe kept AEP as the contextual layer and wrapped agents around it rather than rebuilding. That’s the pattern most of you will end up following.

Now What: If you run a legacy platform of record—CRM, ERP, marketing, finance—stop waiting for the vendor to ship a “real” AI strategy. Start asking now whether they’ll expose MCP endpoints, whether their agents will run inside Claude Enterprise or ChatGPT Enterprise, and whether their skills are portable across your agent runtimes. A vendor that can’t answer those three questions by end of Q3 is a vendor you’re going to replace.

Read more

Salesforce Launches Headless 360—Your Platform of Record Is Now Infrastructure for Agents

What: Salesforce unveiled Headless 360, which exposes the entire Salesforce platform as infrastructure for AI agents: data, business logic, workflows, and policy all available programmatically to any agent runtime, any model, any orchestration layer. It’s the first major CRM repositioning itself not as a destination app but as a system of record agents operate on top of.

So What: This reframes the most expensive software purchase in most enterprises. If Salesforce is infrastructure, then the value question moves from “which CRM do we pick” to “what agents sit on top of it and who controls them”—and the answer to that second question is increasingly you, not Salesforce. The deeper signal is that the incumbents have now absorbed the agent thesis: they’re not fighting it, they’re repositioning around it. Expect the same move from ServiceNow, Workday, Oracle, and SAP over the next six months.

Now What: If you’re a Salesforce customer, get ahead of this. Ask your account team where Headless 360 fits in your license, what the governance model looks like across multiple agent runtimes, and how skills and agents built against your instance survive a vendor change. If you’re evaluating CRM alternatives, the new decision criterion is: which platform will be easier to operate on top of a year from now.

Read more

Gemini Gets a Next-Generation Deep Research Agent—Research-as-Workflow, Not Research-as-Search

What: Google launched a next-generation Deep Research agent inside Gemini. It runs multi-hour investigations across the open web, synthesizes findings into structured reports, and interleaves reasoning, citations, and cross-checks instead of returning a ranked list of links.

So What: This is the first credible move from Google that positions Gemini as more than a search box with a model attached. Deep Research is a workflow product, not an answer product—the same architectural bet Claude and ChatGPT made with their respective research and agent modes. For enterprise buyers, it also forces a real choice: if your analysts start using Deep Research for diligence, market scans, or regulatory reviews, you need governance around it before it becomes the de facto research tool on your team.

Now What: If you have analysts, researchers, or consultants spending hours per week on web-synthesis work, pilot Deep Research against one of them for a week and measure the delta. If the gains are real, your next question is governance: source control, citation audit, data residency, and whether the research output can be trusted in a regulated workflow. Don’t let this diffuse through your org ungoverned—treat it like you’d treat any new research tool with internet access.

Read more

The Model Race: Coding and Life Sciences

The frontier model race kept moving on two fronts this week. Google publicly conceded Anthropic is ahead on coding and stood up a strike team to catch up. Moonshot’s open-weights Kimi K2.6 put a credible open model inside the frontier envelope for the first time. And OpenAI shipped the first vertical frontier model—GPT-Rosalind for life sciences—with named pharma customers. Two signals for enterprise buyers: vendor leadership swaps faster than your procurement cycle, and vertical frontier models are the next GTM pattern.

Google DeepMind Spins Up a Strike Team to Close the Coding Gap With Anthropic

What: The Decoder reports Google DeepMind has stood up a strike team led by Sebastian Borgeaud (formerly Gemini pre-training) focused on long-horizon coding tasks. Sergey Brin’s internal memo calls “turning our models into primary developers” the final sprint, and Google is tracking team-level usage of its internal coding tool “Jetski”—similar to Meta’s token leaderboard. Training runs on Google’s proprietary codebase.

So What: Two signals for enterprise buyers. First, Google publicly concedes Anthropic is ahead on coding—which validates most engineering teams’ current experience and shortens the “we should wait and see what Google ships” conversation. Second, the internal-tool-first strategy (Jetski) is telling: frontier labs are now treating their own engineers as the leading pilot cohort, and what ships publicly lags what’s running inside. That pattern will hold across every model family.

Now What: If you’re picking a coding model or agent platform today, pick based on what works in your team’s actual workflows now, not on vendor roadmap slides. Re-evaluate quarterly—the leader-of-the-month dynamic is real, and Google catching up is now the explicit goal. For teams running on Gemini, ask your account team directly what Jetski’s usage looks like and when those capabilities ship externally.

Read more

Moonshot’s Kimi K2.6 Puts an Open-Source Model at the Frontier—For Long-Horizon Coding

What: Moonshot released Kimi K2.6, an open-weights coding model benchmarking neck-and-neck with GPT-5.4, Claude Opus 4.6, and Gemini 3.1 Pro on agentic and coding tasks. Vercel reports 50%+ gains on their Next.js benchmark. Demonstration runs include a 12-hour, 4,000-tool-call Zig inference optimization and a 13-hour autonomous rewrite of an 8-year-old matching engine (185% throughput gains). Agent Swarm now scales to 300 sub-agents across 4,000 coordinated steps.

So What: This is the first time open weights sit inside the frontier envelope for long-horizon agent work. The implications go beyond price. Open weights mean you can host the model inside your own compliance boundary, run it offline in regulated environments, fine-tune on proprietary code without sending it to a vendor, and avoid per-token pricing on the workloads that burn the most budget. The benchmarks are vendor-run—take them with salt—but the customer quotes from Vercel, Fireworks, Baseten, Ollama, and others converge on one point: long-horizon reliability is now real on open weights.

Now What: If you operate in a regulated environment or have workloads where data can’t leave your perimeter, re-open the build-versus-buy conversation on agent workloads. The calculus from a year ago—frontier models are only available as closed API products—is no longer true. Pilot K2.6 alongside your existing closed-model stack on one high-value, long-horizon workflow and compare on reliability, cost, and governance posture.

Read more

OpenAI Ships GPT-Rosalind—A Frontier Model for Life Sciences, With Named Pharma Launch Partners

What: OpenAI launched GPT-Rosalind, a frontier reasoning model for biology, drug discovery, and translational medicine, available in research preview through ChatGPT, Codex, and the API via a “trusted access program.” Launch customers include Amgen, Moderna, the Allen Institute, and Thermo Fisher. OpenAI is framing capabilities as muted today—synthesis, experimentation planning, research compilation—with autonomous scientific progress “several technical milestones away.”

So What: This is the first vertical frontier model shipped by either major lab. OpenAI is betting the next phase of enterprise AI is specialized models with curated tool access, not general-purpose models doing everything. Life sciences is the first domain because the economics are obvious and the customer list was ready—expect similar vertical frontier launches in legal, finance, and clinical care over the next year. Notably absent from the launch customer list: payers, providers, and any non-pharma healthcare organization.

Now What: If you’re in pharma, biotech, or translational medicine, ask OpenAI directly about the trusted access program—the published customer list tells you exactly who’s in the room. If you’re in adjacent regulated industries (healthcare payer/provider, legal, financial services), watch the trusted-access pattern carefully: this is likely the GTM template for every vertical frontier model that follows, and getting in early matters more than the model’s current capability ceiling.

Read more

The Enterprise Realities

The same week three vendors reframed the workspace layer, three stories from the field reframed how you should actually buy and build. Proprietary formats are becoming liabilities as AI-native tools route around them. SpaceX on Cursor puts a reference customer on the table that answers the hardest security objection in any AI coding tool RFP. And a clean Tensorzero analysis shows that most enterprise AI budgets are built on list-price comparisons that are off by 2-5x. Your AI cost, tool choice, and vendor audit all need a refresh this quarter.

Anthropic Ships Claude Design—And Figma’s Locked Format Has an Agentic-Era Problem

What: Anthropic launched Claude Design as part of Claude Labs—a generative design workflow that takes prompts to production-quality UI and interactive prototypes without leaving Claude. A widely-shared analysis from Sam Henri argues Figma’s largely-undocumented, hard-to-work-with-programmatically file format accidentally excluded Figma from the training data that would make it relevant in the agentic era.

So What: The pattern matters beyond design. Every proprietary file format that’s hard to parse programmatically is now at risk of being routed around by AI-native tooling. Claude Design didn’t beat Figma on features—it made Figma’s closed format a liability instead of a moat. The same dynamic will play out for any vendor whose lock-in depends on an opaque format: BIM, CAD, proprietary PM tools, specialized ERP schemas. Open or interoperable formats gain value; closed formats become tech debt.

Now What: If you maintain internal tools or vendor contracts that depend on a closed format, audit them. Ask whether the format is machine-readable, whether it’s documented, whether an AI agent could roundtrip through it. If the answer is no, start planning the migration now—not because AI replaces the tool tomorrow, but because the tool’s value compounds against you every quarter the agent layer gets better.

Read more

SpaceX Picks Cursor—Enterprise IDE Adoption at Scale

What: The New York Times reports SpaceX standardized on Cursor for engineering. Details on team size and license counts aren’t public, but SpaceX is one of the largest and most security-conscious software engineering organizations in the world, and the pick validates Cursor as an enterprise-grade tool rather than a startup productivity play.

So What: This is the most significant enterprise reference for any AI coding tool to date. SpaceX’s security posture, classification requirements, and engineering culture make it an unusually strict buyer—the fact that Cursor cleared the bar tells you that enterprise-ready features (SSO, audit logs, IP protection, custom model routing, offline modes) have caught up to what large orgs need. Expect this reference to show up in every AI coding tool RFP this quarter.

Now What: If you have engineers evaluating AI coding tools, the SpaceX reference gives your security team an answer to the hardest objection: “no one at our scale runs this yet.” That’s no longer true. If you’re at the enterprise buyer stage, ask each candidate vendor what their largest production customer looks like, what SOC 2 Type II evidence they can share, and what their model-routing and IP-protection story is. The answers have gotten meaningfully better in the last 90 days.

Read more

Stop Comparing Price Per Million Tokens—Tokenization Can Make Claude 5x More Expensive Than the List Price Suggests

What: A Tensorzero analysis shows that because different models tokenize text differently, real-world cost can diverge sharply from list price. On some workloads, Claude tokens end up costing 5x more than GPT tokens despite Claude’s list price being only 2x. The gap is driven by how each tokenizer splits text—code, structured data, and non-English content all produce different token counts per byte.

So What: Most AI budgets in enterprise are built on list-price comparisons that are off by 2–5x. That’s not a rounding error—it’s the difference between a model being affordable at scale and being cost-prohibitive. The broader point is that the economics of AI workloads aren’t legible from vendor pricing pages alone. Real cost depends on your actual text, your actual prompts, and your actual workflows—and it requires instrumentation to see.

Now What: Before your next model-selection decision, run a representative 100-prompt sample through each candidate vendor, count tokens on both the input and output sides, and multiply by each vendor’s list price. Do this for every workload shape (code, structured data, long documents, conversational). You’ll almost certainly find that the “cheaper” model on the sticker is not the cheaper model in practice. Also: this is the single strongest argument for model-routing architecture—the right model for the workload beats the cheapest model by list price, every time.

Read more

I listened to Nikhyl Singhal on Lenny’s podcast this week. It’s the most salient take I’ve heard in months on what’s actually happening in tech, and if you lead a company, hire product/design/tech people, or are trying to figure out what to do with the org you built over the last five years, you should listen to the whole thing before you read what follows.

His argument in one paragraph: the product management role is splitting in two. “Information movers,” whose day is framing and shuttling information up and down the org, are becoming dinosaurs. “Builders” who ship, prototype, and have direct product instincts are in a renaissance. Half the current PM population is in the first camp. The next 12–24 months will be the most chaotic period in PM history, with massive shedding and rehiring. Companies will let thousands of people go and rehire thousands of others, all AI-first, radically different skills, higher comp, everything different. The only way through is to cross a personal reinvention threshold and find a moment of joy in the new way of working.

Go listen. I’m not going to recap it. What follows is what it unlocked for me.

The split is happening in every function

Nikhyl was talking to PMs. I work with CEOs, COOs, and CPOs across the enterprise, and the builder / information-mover split isn’t a PM problem. It’s a knowledge-work problem.

The same split is showing up everywhere: marketing, sales ops, finance, HR, legal, customer operations, service delivery. Every function has a population of builders, people whose instinct is to ship, prototype, automate, and own outcomes, and a population of information movers, people whose value was routing, reframing, and coordinating. AI is eating the second group’s job description first, because that’s where the leverage is highest and the risk is lowest.

PMs are the canary. If you lead a non-product function and you’re watching this happen in product thinking “glad that’s not me,” then you’re not paying close enough attention.

Companies have the same threshold to cross

The most important idea in the episode is the reinvention threshold. Nikhyl’s point is that every knowledge worker right now has to make a very specific internal decision: I am going to reinvent my craft, and I’m going to put that above the other things I’ve been protecting. It’s not a training program. It’s not a mindset session. It’s a conscious reordering of priorities, and until you cross it, nothing else works. You can consume all the AI content you want and still be on the wrong side of the line.

What nobody is saying out loud is that companies have the exact same threshold. And most of them haven’t crossed it either.

What I see in enterprises right now is a lot of activity that looks like change and isn’t. AI strategy decks. Copilot pilots. Innovation sprints. Center-of-excellence PowerPoints. Real effort, almost none of it touching the thing that actually has to change: how work gets done, who does it, what gets paid for, and what gets measured.

Strategy without operating model change is theater. The companies that win the next two years are the ones whose CEOs look at their org chart, their process library, their vendor stack, and their job architecture and say “we are going to rebuild this,” not “we are going to layer AI on top of this.”

That’s the company-level threshold. It’s as scary as the individual one, because it means admitting that a lot of what got you here is what’s holding you back. Nikhyl calls this the “shadow superpower” — the skills and systems that made you successful in the last era are the exact thing blocking you from the next one. Shadow superpowers don’t just belong to senior ICs. They belong to entire operating models.

The equal disappointment algorithm scales up

Before the how-to: a word about the weight of the ask, because I don’t want it misread.

Nikhyl has a line about mid-career professionals in their “power years,” the decade or so when you’ve finally figured out your craft and the people around you demand the most of it, having eight hours of supply and twenty hours of demand: work, partner, kids, aging parents, health, friends. His framing is that your only workable strategy is to equally disappoint everyone, because you can’t meet full demand from any one constituency.

That’s the individual version. It’s also the CEO’s version. Every enterprise leader I talk to is running an equal-disappointment algorithm across their board, their customers, their employees, their regulators, and their own family.

But the algorithm already has a hierarchy built in. Your kids aren’t negotiable. Your partner isn’t a line item next to a quarterly review. Your health isn’t optional. The question isn’t who to disappoint to make room for reinvention. It’s which work actually matters, and which doesn’t.

You don’t steal hours from your kids. You steal them from the steering committee, the status report, the stakeholder tour, the deck review, the meeting that could have been an email. Most leaders never make that move because they’ve never explicitly ranked their work against itself. Everything at work feels load-bearing until you force yourself to look.

The reason most CEOs stall at the threshold isn’t that they don’t see it. It’s that they’re already maxed out keeping the current system running, and reinvention feels like one more thing to add on top. It isn’t. Trade work that doesn’t matter for it. That trade is hard, it’s political, and it’s the only one that actually works.

One more thing worth holding onto here: this chaos has an end. Nikhyl estimates about two years before the industry settles into a new operating equilibrium, with new rituals, new roles, new expectations. That’s the tunnel. It’s loud, it’s exhausting, and it ends. Companies that try to keep every work constituency happy through it are the ones that end up shedding thousands of employees without the newly shaped people rehired.

What crossing the threshold actually looks like at scale

If you run a 40,000-person enterprise, “walk into the tunnel” is not a plan. You can’t weekend-hack your way across this threshold. But the mechanics exist, and they’re more concrete than most transformation programs admit.

Four moves I see actually working at scale:

Rewrite the job architecture, not just the training plan. Most enterprises are running AI upskilling programs against a job architecture designed for the information-mover era. You cannot reskill your way out of a structural mismatch. The work is to redefine what roles exist, what outcomes they own, and what “good” looks like in each, then reskill against the new architecture. Do it in the other order and you train people for jobs that don’t exist.

Change what gets measured and what gets promoted. Your people read the signals you send through comp, promotion, and visibility. If your top performers are still the ones who ran the best steering committee, you’re telling the organization that the old game is still the game. Promote builders. Compensate for shipped outcomes. Make the signal impossible to miss.

Put builders in the room where decisions get made. Most enterprises have builders, they’re just three layers below where strategy happens. Crossing the threshold means restructuring who’s in the room. The CEO’s staff meeting should include people who shipped something this week, not just people who manage people who manage people who shipped something.

Pick one high-stakes area and rebuild it in public. Not a pilot. Not an innovation lab. A real function, real P&L, real customers, real stakes, rebuilt from the operating model up, inside twelve months. It gives the rest of the organization a proof point they can touch, and it forces your executive team to confront the actual mechanics rather than debate them in the abstract.

None of this is easy. All of it is more concrete than “do AI transformation.” If you’re running a big company and you’re looking for where to start, start with one of these four.

What I believe right now

Six things I believe with more conviction after listening to this episode.

Builders are the only hire that makes sense. For every seat: PM, engineer, marketer, ops leader, consultant, analyst. If the person you’re hiring can’t point to something they built in the last 90 days using modern tools, they are the old model. Don’t hire them.

Hiring builders is the easy part. Keeping them is the real work. “Hire builders” is now conventional wisdom. The next failure mode, the one I’m watching play out in real time, is companies that hired builders and then dropped them into an information-mover operating model. Weekly status decks. Three-week PRD review cycles. Approval chains requiring four directors to sign off on a prototype. Builders in that environment quit inside a year. They don’t send a note; they just ship their resume to the next place. If your org has started hiring builders but hasn’t changed its rituals, measurement, or decision rights to match, you’re running the most expensive revolving door in the market.

Young talent is a cheat code, and most companies are ignoring it. I came up in an apprenticeship culture, and I think the industry forgot how valuable that is. The people with the least to unlearn are the ones who never learned the old way. A 23-year-old who came up building with modern tools, who doesn’t know what a PRD review cycle is supposed to look like, who treats Claude Code the way my generation treated email: that person has an aptitude advantage no amount of senior pattern-matching can replicate. Diversity isn’t just gender, race, and geography. It’s age. Companies only hiring fifteen-year-vets with the “right” logos are missing the single most obvious arbitrage available to them. Pair young builders with senior judgment and you get a team that moves at a pace the old model physically cannot produce.

Joy is the unlock. Nikhyl’s “moment of joy” framing is the single most useful piece of practical advice I’ve heard on how to get people through this, and it’s more specific than it sounds. He’s noticed that every person who crosses the threshold has the same kind of story: they built a small thing with modern tools and it worked. A chief-of-staff app for their inbox. A script that controls their house lights. Helped their spouse test-market a business idea. Stayed up too late one night getting something to run. Small, personal, concrete, theirs. And from that moment forward they’re hooked. You cannot think your way across the reinvention threshold. You have to build something small, have it work, and catch the bug. Every leader, every team, every person has to have that moment. Enablement that doesn’t engineer it is wasted money.

Pace is retention. Nikhyl calls it “fire in the belly.” Year-one energy, not year-five. Leaders who still operate at enterprise cadence in an AI-era market aren’t just slow; they’re actively signaling to their best builders that this isn’t the place. Your best people leave for pace before they leave for comp.

The consulting model that built the last era doesn’t fit this one. Big decks, slow engagements, armies of juniors producing frameworks: that model was built for information movers, and it’s going to get gutted. The consulting that matters now is small teams of builders embedded alongside client teams, shipping working systems in weeks. That’s the Blank Metal bet, and I’m more certain of it this week than I was last week.

Where I land

Toward the end of the conversation, Lenny drops a line that’s been in my head since: chaos is a ladder, from Game of Thrones. That’s what this moment is. The people and companies most stressed right now are the ones clinging to the old shape. The people and companies having the most fun are the ones who crossed the threshold, caught the bug, and are climbing.

Whether you’re a CEO with 40,000 people, a founder of fifteen, or one person sitting at your desk wondering if you’re already behind: the tunnel is two years. Walk into it. Find your moment of joy. Build something this weekend that would have taken you a month a year ago. Trade work that doesn’t matter to make time for it.

It’s worth it.

That’s why I’m naming this moment the Great Reinvention: the work isn’t AI adoption, it’s reinvention of how people and companies operate.

Welcome to the Great Reinvention.

Nikhyl’s episode is Why half of product managers are in trouble on Lenny’s Podcast. If you only have 95 minutes this month, spend it there.