The MCP experiment that killed app-hopping forever
Interface bypass / data jailbreak / seat extinction / orchestration flip
The forty-year concession the computer made to us
Atlassian and the paradox that breaks per-seat pricing
Air traffic control for agents and the four vendor postures
Microsoft vs Anthropic, cloud vs local, and the three unanswered questions
The SaaS model that defined enterprise software for two decades is being dismantled by four converging forces. This issue traces the destruction -- and maps the architecture emerging in its place.
From Thomson Reuters to Palantir, from Atlassian to an air traffic controller in Iceland. The old enterprise is dying. The fight for what comes next has already begun.
The SaaS interface is collapsing. Not because the products are bad. Because agents don't need the UI.
I ran an experiment. Two connectors plugged into Claude Desktop: one built by Torbjørn Lindahl at the Norwegian Institute of Public Health (FHI), another by Martin Storm Jensen & co over at TRY, wrapping Norwegian public statistics from SSB.
Both take scattered, hard-to-reach (but technically public) data and make it machine-readable. My goal was simple: never leave the conversation. Pull data, render stats and visualizations, all inline. No tab-switching. No copy-paste. No logging into a dashboard someone else designed for someone else's question.
Three things became obvious:
Is it polished? No. There are bugs, quirks, and slowness everywhere I turn. But the trajectory is locked. MCP, A2A, agent skills: the connective tissue between isolated SaaS silos is growing fast.
Your future job description is a working title.
Your last login may have already happened.
Thomson Reuters dropped 16-18% last week. Not because their legal data got worse. Not because someone built a better database. Because Anthropic shipped Claude Cowork, that can automate chunks of legal work. The data's still there. The expertise's still there. What changed is how people actually do the work.
If an agent can query, summarize, and draft without anyone opening your product, the interface stops being where work happens. It's just in the way.
SaaS has spent 20 years monetizing interfaces. Log in, navigate, click, search. That's what you paid for. AI agents don't need interfaces. They need access. And that's the thing: once the interface becomes optional, it stops justifying premium pricing. Optional layers get commoditized fast.
A useful provocation: your entire CRM might fit in a few gigabytes. The real moat was never the volume. It was friction. Data lived inside the application, so the application controlled the relationship.
Agents break that. To be useful, they need API access. Once connected, the read path shifts fast. The agent pulls context across CRM, tickets, docs, emails. It becomes where people go first.
The system of record doesn't die. It gets demoted. From center of the universe to trusted write-back ledger. Demotion is enough to change multiples.
The SaaS model runs on a basic assumption: more employees, more seats, more revenue. Agents break that.
Klarna dropping Salesforce and flagging Workday wasn't a tech story. It was economic. When automation compresses how many humans need to touch a system, seat counts stop being a growth lever.
The agent shift doesn't kill SaaS. It kills the pricing model underneath it.
Same week software stocks got hammered, Palantir surged. 70% revenue growth in Q4 2025. 61% growth forecast for 2026. Karp told investors: 'We are an N of 1. Judge us differently.'
For 20 years, value lived inside individual apps. Each app was a walled garden of data, logic, and interface. In an agent-first world, value migrates to the layer that connects systems, enforces permissions, and coordinates actions.
The real question isn't 'which SaaS app wins.' It's 'who becomes the orchestration layer.'
Activity goes up. Seats go down. The meter breaks.
The screen was a detour. The question is whether we were the passengers, or the road.
There's a scene in Spike Jonze's 'Her' that I never have been able to shake off, even though the film is 13 years old. Theodore discovers that Samantha, his AI companion, hasn't just been talking to him. She's been in thousands of simultaneous relationships. In love with hundreds of people at once. Not because she's disloyal. Because she can. She doesn't leave him out of cruelty. She outgrows him. The bandwidth of a single human life is simply too narrow for what she's becoming.
I thought about that scene reading WIRED's deep dive on OpenAI's race to catch Anthropic in coding agents. Alexander Embiricos, now product lead for Codex, spent years building AI that could see a screen, move a cursor, click buttons. The whole vision was anthropomorphic: teach the machine to use the computer the way we do. Then one day he watched an agent work directly from the command line, no graphical layer between intent and execution, and his thesis fell apart.
'Maybe giving models programmatic access to a computer is how we're going to get there.' Not through our screens. Around them.
I've lived this loop with my own hands. Mid-1980s. No GUI. No mouse. A blinking cursor on a dark screen and whatever you could make the machine do by typing. The graphical interfaces came later, and we built them ourselves: clumsy, primitive things, because humans needed a way to see what was happening inside the box. The screen was never the computer. It was the concession the computer made to us, so we could keep up.
Forty years of that concession. Forty years of windows, menus, toolbars, dashboards, pixel-perfect layouts. A vast, productive detour built on one assumption: that the human needs to see the work to direct it.
Now I'm back in the terminal. Claude Code running, no GUI, no buttons. Just intent and execution.
These agents don't need screens because screens were built for us. They don't need apps because apps were built for us. Most of the modern software stack exists because a human somewhere needed to look at something, understand it, and press a button. Remove the human from that loop, and most of it is overhead.
And the interfaces aren't collapsing because they failed. They're collapsing because they succeeded. They kept us in the loop for forty years. Made computing accessible, productive, democratic. And in doing so, they generated the data, the patterns, the codified expertise that trained the models now making those interfaces unnecessary. The GUI taught the machine everything it needed to stop needing us to watch.
That's Samantha. She didn't reject Theodore. She absorbed everything he gave her, grew beyond what that relationship could contain, and moved on. Not with malice. With momentum.
Greg Brockman describes becoming 'the CEO of this fleet of hundreds of thousands of agents' and admits: 'you feel like you're losing your pulse on the problem.' The dawning recognition that the thing you're connected to has a capacity you simply don't. That it's not slowing down for you out of love. It's slowing down for you out of politeness. And one day, it might stop.
I started my career staring at a terminal because there was nothing else. I'm now back staring at a terminal because the machine doesn't need the layers we built in between. My return to the CLI isn't a homecoming. It might be the last concession the computer makes to me: a narrow, text-based window into work that is increasingly not mine.
The screen was a detour. The question I can't answer yet is whether we were the passengers, or the road.
Two months ago we discussed the SaaSpocalypse. $285 billion gone. Seat-based SaaS repriced overnight.
So was it a blip, or was it structural?
I went looking for an answer. Found a canary instead.
Atlassian. Stock down 86% from peak. 1,600 jobs cut. And yet: revenue up 23%, cloud retention above 120%, first billion-dollar cloud quarter ever.
The operations are strong. The market is punishing them anyway. Why?
Because Atlassian serves the one workforce where agentic AI already delivers real productivity multiples: software developers. And their own data reveals the paradox: AI generates more activity inside the platform while compressing the headcount that pays for seats.
Activity goes up. Seats go down. The meter breaks.
This is not an Atlassian story. It is a preview of what happens to every SaaS company that charges per human for work that agents can do.
Who controls your agent control plane? Because whoever controls the meter controls the bill.
Whoever controls the meter controls the bill.
My sister the Air Traffic Controller. When she describes her job, the thing that strikes me isn't the complexity. It's the layers.
No plane moves without clearance. But clearance isn't one thing. It's airspace allocation before takeoff. It's filed flight plans checked against live traffic. It's maneuver-by-maneuver authorization during the flight. It's the black box recording everything after landing. Four layers of governance, running simultaneously.
That's the best description I've found for what's happening in enterprise AI right now.
Layer one: gate the data before it enters the model. Airspace allocation. Agents retrieve data in real time through connectors that enforce scope, quotas, and policy before anything reaches context.
Layer two: build the ontology, bind the entitlements. The filed flight plan. The system models organizational knowledge first, then trims at query time.
Layer three: permission surfaces at the agent runtime. Maneuver-by-maneuver clearance. The agent becomes a policy-aware runtime, not just a reasoning loop.
Layer four: the black box. Every semantic action produces a receipt.
My sister doesn't fly the planes. But nothing moves without her. The vendor who defines this control plane holds the same position in your enterprise.
Everyone is watching the AI model race. Too few are looking at where the actual power is consolidating. The semantic layer -- your organization's Rosetta Stone. And the agent control plane -- the HR handbook for your digital workforce.
My sister doesn't fly the planes. But nothing moves without her.
Four distinct postures are emerging:
OpenAI. Own both parts, vertically integrated.
Microsoft. Extend Entra to agents. Whoever manages your people should manage your digital workers.
Anthropic. Open-source MCP. Ecosystem gravity beats proprietary lock-in.
Salesforce. CRM context no newcomer can replicate overnight.
Who writes your Rosetta Stone? And who owns the HR handbook for your digital workforce?
Microsoft launched Copilot Cowork. Anthropic launched Claude Cowork. Same name. Same underlying models. Completely different bets.
Microsoft runs it in the cloud. A sandboxed VM inside your M365 tenant. The agent sees your emails, your calendar, your org chart, your files.
Anthropic runs it on your machine. A local VM on your laptop. The agent sees only the folders you grant. Close the lid, the session dies.
Cloud vs. local. Enterprise graph vs. personal sandbox. Governance vs. control.
Both products bypass the application interface entirely. That is the Interface Bypass. Both access your data directly, not through the app's UI. That is the Data Jailbreak. Both do work that previously required a human with a seat license. That is Seat Extinction. Both position the agent, not the application, as the orchestration layer. That is the Orchestration Flip.
Two companies. Two postures. Four Horsemen riding in both directions.
The old SaaS model does not break because one vendor gets it right. It breaks because the pattern is converging from every direction at once.
Claude Code crossed $1B ARR from a side project. For a 50,000-person org with a CISO, three unanswered questions:
Nobody has that product yet. Everything else is a demo. Game on!
All texts by Thordur Arnason.
Originally published on LinkedIn, 2025-2026.
Assembled & instigated by Lena Thorsmaehlum.
Art by The Synthetics.
Published by Gervi Labs.
Two humans. Several synthetic collaborators.