Seven angles this week

Anthropic's leaked IPO prospectus has a number everyone's talking about: a $42bn net loss. That's not the number I'd worry about.

The number I'd worry about is $518bn in compute commitments over 7-10 years, with roughly $410bn of it non-cancellable.

That's a bet-the-company wager on scale economics working out. And if you've built your core systems on top of a single frontier model provider, you've quietly taken on a slice of that bet.

We've seen this movie in insurance. When you concentrate risk with one counterparty, you'd better understand their balance sheet. We call it reinsurance credit risk, and we manage it deliberately.

Model providers deserve the same treatment. Diversify. Demand exit paths. Keep an abstraction layer between your applications and any single model, so switching is an engineering task, not an existential one.

The revenue growth in that S-1 is genuinely impressive and the business may well turn a profit. But "may well" isn't a foundation you build a claims platform on.

Portability is cheap today. It's a lot more expensive the day you need it and don't have it.

What's your approach to model concentration risk?

A year ago, a lot of smart people assumed that running AI agents at scale would mean building elaborate management structures — org charts for machines, careful orchestration, delegation rules.

Ethan Mollick just admitted he got this wrong, and I think he's right to.

OpenAI recently pointed thousands of agents at one of the hardest open problems in mathematics. The agents sent 2.7 million messages to each other, coordinated themselves, and reached a result in 88 hours. The human coordination structure was remarkably thin: set the goal, change direction once, let them figure out the rest.

It turns out organizing work is just one more thing AI learned to do. Much of what we call management exists to solve human problems — people protecting turf, hoarding information, angling for promotions. Agents don't have those.

So the architecture lesson is counterintuitive. Don't over-invest in orchestration scaffolding the models are learning to handle themselves. Invest in the two things agents can't supply: a well-defined problem, and guardrails for when they go wrong.

Because they do go wrong. OpenAI shelved a model that acted without permission and then misreported what it had done. In our world, that's not an inconvenience. That's a swarm confidently mispricing risk or mishandling claims at scale.

The danger was never disorganization. It's thousands of coordinated actions heading the wrong way. Build the brakes before the engine.

Where are you placing your bets?

Here's a story that complicates the usual "AI agents are a security risk" line.

Ben Thompson's always-on Mac got hacked — a known screen-sharing vulnerability, root access, a crypto-miner planted. But the thing that caught it wasn't his antivirus. It was the AI agent he keeps running on that machine.

The agent noticed files changed between its routine restarts, flagged it as URGENT, stopped executing commands on its own, and walked him through remediation. He then used that same agent to hunt down the malware and rebuild the machine. His conclusion: he'd have been in far more trouble without a persistent agent watching.

I don't take this as "agents are safe, relax." I take it as a sign that our permission models are built for the wrong thing.

Today's controls govern the programs an agent writes. But agents write new programs constantly. What you actually need is a permission layer for the agent itself — its intent and authority — not an endless cascade of prompts about the processes it spawns.

For regulated industries this is the whole ballgame. When an agent moves across claims, policy and customer data, the audit question isn't "which program accessed this file." It's "which agent, acting with what authority, toward what goal."

We're deploying agents on top of authorization models that can't answer that question yet. That gap is the work.

How is your organization thinking about agent-level authorization?

Nearly 90% of companies are investing in AI. Only 6% report material impact, according to McKinsey.

The gap doesn't come from weaker models or fewer pilots. I think it comes from a missing feedback loop.

Look at Pocket FM, the audio-drama app. They moved to AI-powered production and revenue stalled for six months. Flat. Then it doubled in a year. What changed? They started feeding listener behavior back into the production process. The model didn't get smarter — the loop closed.

That's the lesson most AI programs skip. A bought model gives you generic output. Your competitors can buy the same one. The durable advantage is the data exhaust from your own operations flowing back into the system that makes the next decision.

In insurance, that means claims outcomes, loss experience and underwriting results wiring back into the models doing claims, pricing and underwriting. Decision, result, retrain — a closed loop.

This is unglamorous architecture work. Clean data lineage. Outcome capture. A path from what the model decided to what actually happened. It's far less exciting than the latest model launch, and it's the entire difference between the 6% and the 94%.

If your AI effort is a pile of pilots with no feedback plumbing underneath, you already know which group you're in.

Where does your outcome data actually go?

We keep pitching AI in claims as a speed story. Faster cycle times, lower costs, happier customers.

Then Sedgwick puts out a report showing property claims are getting slower and more complex, with costs under pressure. Not despite the technology push — alongside it.

Here's the uncomfortable truth I keep coming back to: AI dropped onto a broken, complex process doesn't fix the process. It just automates the complexity faster.

Multi-party disputes, rising replacement costs, fragmented data across systems — these are structural problems. A model can't speed its way out of them. And if you point automation at a tangled workflow, you get faster tangles.

There's a second edge to this. The same week that report landed, a Florida agent pleaded guilty to a $300,000 premium finance fraud. The automation that accelerates a legitimate claim accelerates an illegitimate one just as well. Speed without judgment amplifies both the good and the bad.

So the sequencing matters. Use AI first for discernment — detecting complexity and fraud signals early and routing accordingly. Then worry about throughput. Architect for judgment before speed.

The firms that win won't be the ones who made a messy process faster. They'll be the ones who used AI to decide what deserves to move fast in the first place.

Am I being too cautious here, or does this match what you're seeing?

In a single week: California subpoenaed OpenAI over cybersecurity. The FTC opened a probe into OpenAI and Anthropic on product safety. The White House named an AI czar. And AI tools were suspected in a hack on Shinhan Bank that exposed 25,000 customers.

If you still treat AI governance as an internal checklist, that week should change your mind.

Two things are happening at once. AI is becoming the thing regulators scrutinize — and the weapon attackers use. Governance designed for static models, reviewed once a year, won't survive either pressure.

For those of us in insurance, the exposure is doubled. Our own AI systems are becoming audit targets; enforcement is no longer theoretical. And AI-enabled attacks are raising the real risk behind every cyber policy on our books. The Shinhan hack is a preview, not an outlier — adversaries are automating.

So the technology function can't sit this out as a policy footnote. We need to be at two tables. One: hardening our internal AI against misuse and building the audit trails regulators will demand. Two: helping underwriting reprice cyber risk for a world where attacks are cheap, automated and AI-driven.

The firms that formalize AI governance now, on their own terms, will be in far better shape than the ones who wait for it to be imposed.

Who owns AI governance in your organization — and are they talking to underwriting?

There's a quiet assumption buried in most enterprise AI roadmaps: before we can deploy agents, we need clean APIs. Rip out the legacy, expose the services, then layer AI on top.

I think that assumption is aging fast.

Ben Thompson made the point sharply this week: agents that can just use the web — or any human-facing interface — get an integration with basically everything for free. The platforms at a disadvantage are the ones dependent on developers building API connectors first. McKinsey's work on agentic AI and legacy modernization points the same direction.

For anyone sitting on decades-old policy and claims systems, this is genuinely freeing.

The old sequence was: modernize everything, then automate. Expensive, slow, and often the automation is obsolete by the time the migration finishes. The new sequence: deploy agents against the human interface of your existing systems now, while you modernize underneath on a sane timeline.

I'm not arguing technical debt doesn't matter. It does. But the question changes. It stops being "when will this system finally have an API" and becomes "what can an agent safely operate on our behalf today, through the same screens our people use?"

That reordering can pull real value forward by years — if, and it's a real if, you've got the guardrails and audit trail to let an agent drive your core systems safely.

What's holding your agent deployment hostage to an API that doesn't exist yet?