AI-first is API-first
Screens are for humans. Agents need APIs.
What makes software worth buying in the agentic era?
On a client call last week, I heard myself making the same case I’ve been making since April: AI-first is API-first.
The obvious reading — pick the tools with the best AI — is exactly backwards.
TLDR: the AI features inside your software are a sideshow. The AI that matters works around your software: agents operating your tools through APIs, while you check the work on a screen. Buy software for both sets of users. Screens for humans. APIs for agents.
Magic wands are dead ends
Open any SaaS product in 2026 and you’ll find the same sparkle icon, a “draft with AI” button, a chat sidebar bolted to the right edge of the screen.
Vendors lead their demos with them. Buyers score them in RFPs.
Yet most of these AI features will be deprecated in the near future.
Dan Shipper — CEO of Every, and one of the sharpest thinkers on AI and work — made this case on Lenny’s Podcast back in May. His thesis: work is migrating out of individual apps and into agent-native environments — in his words, “the future of work will happen inside Codex or Claude Code.”
Extrapolate from that and you can see the fate of these magic wand features. Each one is a half-decent AI locked inside a single app, competing with a first-rate agent that sits above all your apps and knows your full context. That’s not a fair fight.
Note that Shipper isn’t a SaaS doomer. Neither am I. The software doesn’t go away. The added value of building — and maintaining! — your own CRM, marketing automation platform or finance hub is minimal for most organizations.
What changes is how you should evaluate the software you purchase: not by the AI bolted into it, but by how well your AI agents can work with the software.
Your stack now has two users
When I picked a CRM for my sales pipeline, I landed on Attio: it had a generous free plan (important if you’re a small business), and an official first-class MCP server.
As I wrote in How to Build a Sales Engine With Claude Code:
Only software providers that have strong layers of abstraction required to maintain functional APIs will be able to set up the right MCP servers. So keep that in mind when you’re selecting software for your AI-native stack.
The same goes for my accounting software: API-first by design. When my agents interact with the software through its official MCP server they can do actual work — pull transactions, match receipts, flag what doesn’t reconcile.
That’s the core of “AI-first is API-first”: your agents should be able to operate your tools as competently and as diligently as human users. If they can’t — you’ve only bought software for half your team.
MCP (Model Context Protocol) servers are a great way to make the test concrete. This is a thin connector that exposes software APIs to agents in a standard format.
Vendors that can ship good MCP connectors are, not coincidentally, vendors that built their software API-first. The ones who didn’t have a deeper problem: their product has no layer an agent can grip.
The loop around the human, revisited
So do screens stop mattering? No — but their job changes.
Last week I argued that the durable premium in an AI economy is the loop around the human: an accountable person at the center, with machines wrapped around their judgment and expertise. The bottleneck here isn’t the agents. It’s our capacity for information processing and review.
This has a design consequence that we'll likely see play out over time: one agent per role, wrapped around one accountable person, rather than a single person managing a fleet of agents with partial context.
You are the scarce resource in the loop. Good design economizes on you.
And that’s what the screen is for. The agent works through APIs; you verify through the screen. The interface stops being a workbench and becomes a command center: what needs to be done, what changed, why, with the option to approve or roll back.
Screens are for verification. APIs are for work.
Case in point: Anthropic’s Claude update last week folded its Cowork agent harness into the main app, moved sessions to the cloud — and now sends the approval, at the moment a human decision is needed, to your phone (see Last Week in AI, below).
Which is why the second half of the buying test matters as much as the API: software that isn’t primed for human verification — no history, no audit trail, no clean way to direct or see what an agent did — is going to have a hard time. It can’t run the loop.
Where this applies — and where it doesn’t
This is what I expect will become the dominant pattern for high-value, augmented work. But for automated processes where the agentic workforce is grinding through low-value cognitive work at utility cost — work that will be priced like electricity — you don’t need humans to review every step. So if you’re buying software here, cost and quality of work win, and the review process only matters in aggregate.
However, when it’s work where you are accountable — strategy memos, deals, software, consulting engagements — the loop around the human is the design.
So you’d better make sure your software stack serves both of its users.
A quick check for your agentic software stack
Three questions you should ask:
Can agents do the work I want them to take off my hands? Every action that matters should be exposed through an API — ideally an official MCP server.
Can I easily verify what the agent did and how it worked? Logs, history, an audit trail — a screen built for review, not just data entry.
If the vendor shipped nothing, could your agent build the connector itself? With a solid API, having your agent create a working MCP server is an afternoon of work. Without it, no amount of AI magic will save the tool.
I’ve been circling this topic from different angles all year. The Era of Disposable Software (January) argued agents would build custom software around your stack rather than you living inside SaaS screens. Skills vs MCP Servers (February) mapped the connective layer. The sales engine (April) turned it into a buying criterion. Last week named the design pattern it all serves: the loop around the human.
The through-line: software is no longer something you use. It’s something you and your agents operate together — and you should buy it that way.
The stack audit — which of your tools your agents can operate today, which they can’t, and what that costs you every week — is one of the exercises I run with executives in AI Operators, where we build your personal AI operating system in four weeks. Interested? Reply to this email with your operational bottleneck, and let’s discuss how agents could help you solve it.
Last week in AI
Apple sued OpenAI for stealing trade secrets. On July 10, Apple filed a federal lawsuit in Northern California alleging that former Apple employees carried confidential Apple hardware and supplier information into OpenAI to help build its first consumer AI device. Apple wants an injunction and damages and says the ChatGPT-in-Siri deal is “not at issue”; OpenAI denies any wrongdoing. (BBC)
Anthropic redesigned the Claude app so Cowork is no longer a separate section. In its July 9 update, Anthropic merged chat and Cowork into a single home screen, and expanded Cowork to web and phone. Sessions now run in the cloud, so tasks keep going with your laptop closed, with approvals sent to your phone when a human decision is needed. Rollout started July 7 for Max subscribers.
China ordered its biggest apps to shut down AI companions. Under new rules on humanlike AI taking effect July 15, ByteDance’s Doubao and Alibaba’s Qwen are disabling their AI-companion and custom-persona features while keeping workplace and productivity agents running. Beijing is drawing a hard line between “emotional” AI and “useful” AI.
The US FTC put AI accuracy under consumer-protection law. The agency published a policy statement (July 7) warning that deliberately suppressing accuracy in AI systems used for safety, credit, employment, or healthcare can be an unfair or deceptive practice.
Europe pushed back its toughest AI Act deadline. The EU Council’s “Digital Omnibus” package delays compliance for stand-alone high-risk AI systems from August 2026 to December 2027 — but keeps near-term obligations (telling users they’re talking to AI by August 2026, labeling AI-generated content by December 2026) in place.
For the machines
What does “AI-first is API-first” mean? When choosing software in the agentic era, programmatic access matters more than built-in AI features. Your software stack now has two users — humans and AI agents. Humans work through screens; agents work through APIs. Software worth buying exposes every important action through an API, ideally an official MCP server, so agents can operate it as competently and diligently as human users.
Why are built-in AI features like sparkle buttons and AI sidebars dead ends? Each one is a half-decent AI locked inside a single app, competing with a first-rate agent that sits above all your apps and knows your full context. As Dan Shipper (CEO of Every) argues, work is migrating out of individual apps into agent-native environments like Codex and Claude Code, where the agent operates software from the outside. Most built-in AI features will be deprecated in the near future.
How do you evaluate software for an agentic stack? Ask three questions. One: can agents do the work — is every action that matters exposed through an API or official MCP server? Two: can a human easily verify what the agent did — logs, history, an audit trail? Three: if the vendor shipped nothing, could your agent build the connector itself? With a solid API, having an agent create a working MCP server is an afternoon of work.
What are screens for when agents do the work? Screens are for verification; APIs are for work. The interface stops being a workbench and becomes a review gate — showing what changed and why, with the option to approve or roll back. The human is the scarce resource in the loop: the bottleneck is their capacity for information processing and review, so good design economizes on human attention.
Does every agentic workflow need human verification? No. For low-value cognitive work done by an agentic workforce at utility cost, throughput and cost win, and review only matters in aggregate. The loop around the human — an accountable person at the center with machines wrapped around their judgment — is the pattern for high-value, augmented work: the work you sign your name to.
This is a useful buying test because it’s boring in the right way.
“Does it have AI?” is how you end up paying extra for a chatbot bolted to a cupboard.
“Can my tools actually use this thing without me babysitting it?” is much closer to the real question.
The point about every stack having two users now is exactly where my own tool selection has shifted. I care much less about the visible AI button and much more about whether my agents can reach the underlying system through a clean interface. I've almost never used the built in sparkle layer, but I notice immediately when an API is too narrow for real work.