my companies are building a stack of business software right now: an HR system, a project tracker, an accounts and clients manager, a marketing platform, a business management suite, an EHR. every one of them is scheduled to get a face: screens, dashboards, settings pages, an onboarding tour nobody finishes. and lately i can’t stop asking a question that sounds dumb until it doesn’t… who are all these screens for, if the first user of everything we ship is increasingly an agent?
everyone is fighting over the chat box
watch the industry from a distance and you see two groups of companies building toward each other.
the software companies are pulling chat into their products. Salesforce has Agentforce, HubSpot has Agent Hub, formerly Breeze, Intercom has Fin, SAP has Joule. Gartner expects 40% of enterprise apps to embed task-specific agents by the end of 2026, up from under 5% in 2025. the logic is simple: if people are going to talk to software, make them talk to it inside your walls.
the AI labs are pulling software into chat. Claude has a connectors directory (july 2025), ChatGPT has an apps directory (december 2025), Grok has connectors, Gemini is wiring them into its enterprise product. and under every branded name sits the same two-part architecture: an MCP server exposing tools, plus, increasingly, a skill file teaching the model how to use them. MCP shipped in november 2024 as an Anthropic project. OpenAI adopted it in march 2025, Google in april 2025, and when Grok added bring-your-own-MCP in may 2026, every major assistant spoke the same wire format, under eighteen months after it existed. standards almost never move that fast.
new startups, mine included, hedge between the two camps. we build our own UI, and our own agent harness. Mercury ships a conversational command layer over its banking product, Apollo gives Apollo MCP away free on every plan, ZoomInfo wired its data straight into Claude. hybrid AI-native is the respectable default of 2026.
flowchart LR
saas["SaaS companies"] -->|bolt chat onto the app| meet["same architecture underneath:<br/>MCP tools + a skill file"]
labs["AI labs"] -->|pull tools into the chat| meet
meet --> hybrid["hybrid AI-native:<br/>UI + harness + tools"]
meet --> headless["headless software:<br/>tools only, no frontend"]
style headless fill:#e8f5e9,stroke:#2e7d32both camps are converging on the same wire format. the third category just skips the part where you build a face.
here’s what the hybrid position costs, though, because i pay it every month. you build the UI. you build the harness. and to be reachable from the assistants at all, you need the tool surface too. all of them have to stay in feature parity, because a capability that exists on screen but not in the tool layer is invisible to agents, and one that exists in tools but not on screen confuses the humans. three surfaces, one product.
the third category
the thing i keep circling is that the meeting point of those two camps isn’t a chat panel inside your app. it’s your app becoming a tool inside someone else’s chat.
follow that to the end and you get a category that mostly doesn’t exist yet. i’ve been calling it headless software: a product with no frontend at all. a backend, a database, an MCP server, a skill file. it authenticates real users through OAuth, runs on serverless infrastructure, and its interface is whatever surface the customer already lives in: Claude, ChatGPT, Copilot, Gemini, a voice assistant, an IDE. you don’t run inference or build a harness, and onboarding stops being your problem. the model’s maker pays for all of that at a scale you could never match. you ship capability.
take our HR product. headless, it’s maybe thirty tools and a skill file. create_job_posting, update_policy, run_review_cycle, query_time_off. a recruiter tells whatever assistant their company uses “open a senior backend role, our standard responsibilities, comp band c,” the agent calls three of my tools, and the posting exists. nobody ever saw my UI because there isn’t one. what i maintain instead is business logic, permissions, and an audit log… which, if i’m honest, was always the part that mattered.
flowchart LR
agent["the user's agent<br/>Claude, ChatGPT, Gemini, Grok"] -->|OAuth 2.1| mcp["your MCP server<br/>tools + skill file"]
mcp --> logic["business logic<br/>scopes, audit, metering"]
logic -->|row-level security| db[("Postgres")]
mcp -.->|only where a view earns it| ui["optional components<br/>rendered inside the chat"]
style mcp fill:#e8f5e9,stroke:#2e7d32everything you own sits behind the OAuth line. the interface is somebody else’s headache.
i should be clear about what’s mine here and what isn’t, because the observation that software is losing its head is not original. Satya Nadella was arguing on a podcast in december 2024 that business applications as a category probably collapse in the agent era. Mathias Biilmann coined agent experience in january 2025, and Netlify shipped netlify.ai, a front door built for agents rather than people. by spring 2026 the word itself went mainstream: a16z published is software losing its head?, Team8 wrote headless was only the beginning, and Salesforce, the same company that spent 2025 locking Slack’s API away from rival AI, announced Headless 360 under the tagline “our API is the UI.” (the word has baggage: a headless agent already means the inverse, an agent without a UI. i sometimes say faceless software instead, which nobody seems to have claimed.)
but notice what all that prior art describes: incumbents unbolting heads they already own, or infrastructure for other people’s tools. i went looking for the pure case, a venture-scale company that launched with zero frontend, tools and skills only, distribution entirely through the assistants’ directories. i couldn’t find one. even the analysts studying what MCP does to software value only catalog incumbents layering tools onto what they already had. so headless software is still a prediction, not an observation. i’d rather build toward it early than write about it once it’s obvious.
the questions that decide whether it works
billing first, because it’s the obvious question. seats make no sense when the “user” is an agent. the market already moved: Bessemer’s pricing data has pure seat pricing falling from 21% to 15% of SaaS companies in twelve months while hybrid usage pricing jumped from 27% to 41%. the protocol is cooperating too… the july 2026 MCP spec added HTTP headers that name the tool being called, so a gateway can meter and bill without parsing a single payload. my working answer is boring on purpose: per-tenant subscription plus usage meters on the expensive tools, billed through Stripe like any API company. the exotic stuff is real but early: x402 micropayments moved on the order of $28k a day of actual commerce this past march. watch it. don’t bet payroll on it.
moats. a tool schema is self-describing JSON served to any client that asks, so a competitor can copy my entire surface in an afternoon. the moat was never going to be the interface, and in SaaS it never really was. what’s left is what was always underneath: the tenant’s accumulated data, workflow depth encoded server-side, the integrations, the audit trail a compliance officer will sign off on. the analysis that convinced me frames it as systems of record giving way to clearinghouses: lock-in migrates from holding the data to being the governed, permissioned path agents must go through to act on it.
reliability is the number the pitch decks skip. on LiveMCPBench, realistic tasks across many MCP servers, most models still land between 30 and 50% task success, and the best topped out just under 79%. connect enough servers and tool definitions alone can run to hundreds of thousands of context tokens before any work happens; Anthropic cut one workflow from 150K tokens to 2K by having the agent call tools from code instead. headless means you don’t manage inference, but you absolutely own evals now. the eval suite is the new QA department, and a tool described too vaguely to be picked correctly is a bug even though nothing crashed.
security is worse than most people building this want to admit. Asana, a mature SaaS company, ran an MCP server with a tenant-isolation bug that exposed cross-org data for 34 days. prompt injection remains unsolved, and Simon Willison’s lethal trifecta (private data, untrusted content, an exfiltration channel) describes nearly every business tool an agent touches. none of the fixes are model-level. they’re the old ones: least-privilege tokens, row-level security as the last line, read-only defaults, human confirmation on destructive calls. Supabase shipped the pattern i like most: its auth layer now acts as the OAuth server for MCP, so the same RLS policies that protected your web app apply to the agent automatically.
and the UI comes back, just not as an app you own. some interactions genuinely want pixels: sorting a table, scanning a dashboard, a bulk edit you’d never trust to prose. the ecosystem has already conceded the point. MCP Apps, ratified in january 2026 as the first official MCP extension, lets a tool return an interactive component that renders inside Claude or ChatGPT, and Shopify ships product carousels and checkout through it. headless doesn’t mean no interface ever. the interface becomes a component your tools return instead of a product you host, staff, and redesign every two years.
our EHR is my own stress test, and it fails the naive version of this essay. consumer chat surfaces aren’t HIPAA-eligible; Anthropic and OpenAI sign BAAs on their APIs and enterprise tiers, not the free app your users already have. “use whatever assistant you like” collapses, in healthcare, to “the enterprise surface your compliance team approved, with a BAA on every hop.” still headless. just not frictionless, and anyone selling frictionless healthcare AI is lying about at least one hop.
which leaves platform risk, the strongest objection i know. distribution through a directory means the platform owns the customer relationship, can rank you into invisibility, and will eventually want a cut. aggregation theory has never missed. OpenAI alone has churned through plugins (dead inside thirteen months), a GPT store whose promised revenue share never generally shipped, and an apps directory that, six months after apps launched, was per Bloomberg mostly hidden from users. the difference this time is structural: an MCP server is portable. the same endpoint serves Claude, ChatGPT, Gemini and Grok, which is precisely the insurance iOS developers never had. the app store analogy holds right up until that clause. that clause is why i’m willing to build anyway.
what we’re doing about it
i’m not deleting our frontends. screens still win the customers who don’t live in agents yet, and dense workflows still earn them. but the order flips.
new products at my companies are going to start headless: schema, business logic, MCP server, skill file, evals. that is the product. a UI, where a workflow earns one, is a projection over the same tool layer we were going to build anyway, and MCP Apps components cover most of what we would have projected. the hybrid tax won’t vanish, but it stops compounding. one capability surface instead of three.
i dictated this essay into a chat box, and an agent researched it against primary sources and filed it in my repo. no writing app involved. the screens aren’t dying, but they’re already optional in places that would have sounded absurd two years ago. i think the first born-headless company at scale gets founded, if it hasn’t been already, before the frontends we’re building today are due for their first redesign.
sources not linked inline: MCP joins the Linux Foundation’s Agentic AI Foundation · the official MCP registry · Anthropic’s Claude connectors, mid-2026 state · tau-bench, the earlier reliability baseline