Why I started Headless Systems | Petr Pátek

I spent seven years building web automation infrastructure at Apify. Crawlers, data pipelines, API integrations, systems where machines were the only users. No human sat at a dashboard watching these run. The APIs were called by orchestration layers, scheduling systems, and automated workflows. For every human interaction, there were thousands of machine-to-machine calls.

For a long time, I thought this was unique to automation. Then I noticed the same pattern everywhere. And when AI agents arrived, it became impossible to ignore.

This is the story of why I started Headless Systems, and what we are researching here.

The pattern that keeps repeating

Stripe processes over a trillion dollars in annual payment volume. The vast majority never involves a human looking at the Stripe dashboard. It flows through APIs called by e-commerce platforms, billing systems, and payment orchestration layers. Stripe built one of the best dashboards in SaaS. It accounts for a fraction of their actual usage.

Twilio processes billions of messages. Mostly through APIs called by automated systems. Cloudflare handles a significant share of global internet traffic. Programmatically configured, programmatically monitored.

The pattern is consistent across every successful infrastructure company: the dashboard exists, but the API is the product. Most software interactions are already machine-to-machine. We just have not fully internalized what that means for how we build systems.

Engineers have been building API-first architectures for years. That is not the insight. The insight is what happened next.

AI agents changed the equation

In late 2023, OpenAI shipped function calling in GPT-4. It was a quiet release compared to the chatbot hype, but it changed the trajectory of software architecture. For the first time, an LLM could reliably call external APIs as part of its reasoning process. Not through prompt hacking or fragile workarounds. Through a typed, structured interface.

Anthropic followed with tool use in Claude. Google shipped function calling in Gemini. Within 18 months, every major LLM provider had converged on the same capability: letting AI models consume software through APIs.

Then came the Model Context Protocol. Anthropic launched MCP in November 2024 as an open standard for connecting AI assistants to external systems. One year later, the numbers told the story: nearly 2,000 servers in the MCP registry, 97 million monthly SDK downloads, 2,900+ Discord contributors with 100+ new contributors joining weekly. OpenAI, Google, Microsoft, AWS, Stripe, Notion, and GitHub all adopted it. The MCP registry grew 407% in its first quarter alone.

MCP did not just gain traction. It became the de facto protocol for agent-to-software communication in under a year.

The broader numbers confirm the acceleration. The AI agents market grew from $5.4 billion in 2024 to $7.9 billion in 2025, a 46% year-over-year increase. Akamai reports AI bot traffic surged over 300% in 2025. By 2028, Gartner projects 33% of enterprise software will have built-in agentic capabilities. 51% of surveyed organizations already have AI agents deployed in production today.

This is not a future prediction. It is a present reality that most architecture decisions have not caught up with.

What machines teach you about software design

Building systems that serve machine consumers for seven years taught me principles that now apply to all software, not just automation.

Systems built without UI assumptions work best for everyone. When you design an API for programmatic access first, adding a dashboard later is straightforward. When you design around the dashboard first, making it work for machines is always a painful retrofit. The headless approach is not a constraint. It is a multiplier.

Machine consumers expose every design flaw. A human user will work around a clunky API. They will read the docs, figure out the quirks, and adapt. An AI agent will not. It needs predictable response schemas, explicit error codes, and discoverable capabilities. If your API was designed for humans clicking through a UI that happens to have an API endpoint, agents will find every inconsistency.

The ratio only goes in one direction. In every system I have worked on, the share of machine-to-machine traffic increased over time. Never the reverse. Once programmatic access exists, it compounds. More integrations, more automated workflows, more agent-driven operations. The dashboard usage stays flat while API usage grows exponentially.

These are not theoretical principles. They are patterns I observed in production systems, and they are now playing out across the entire software industry as AI agents become primary software consumers.

Why this publication exists

After years in automation, I co-founded Bitvea, a custom software development company where we build API-first platforms, custom CRMs and ERPs, and AI integrations for businesses outgrowing their off-the-shelf tools. Building these systems reinforced the same observation: the most valuable part of any system is not its interface. It is the API surface that lets other systems, and increasingly AI agents, interact with it programmatically.

I started Headless Systems because nobody is connecting these dots in one place.

There are excellent engineering publications. Stripe's blog is the gold standard for API design communication. The Pragmatic Engineer covers how real systems work. Stratechery frames technology shifts as business strategy. Nordic APIs covers the API ecosystem.

But nobody is tracking the specific convergence I keep seeing: headless architecture becoming the default, AI agents becoming the primary software consumers, and monolithic SaaS being unbundled into composable, API-first services. These are not three separate trends. They are one shift, viewed from different angles.

UI is becoming optional. In the age of AI agents, build backends that machines can control.

That is the thesis of this publication.

What we research here

Headless Systems is a research publication. Every piece we publish is grounded in real evidence: benchmarks, protocol analysis, case studies, adoption data, and observable shifts in how software gets consumed.

Our primary focus is AI agents as software consumers. We track how LLM function calling, MCP, and tool-use frameworks are making agents the primary users of software systems. We document this shift as it happens, with specific data, not vague trend claims.

We also research headless architecture and why decoupled systems consistently outperform their monolithic alternatives. We document the unbundling of SaaS, tracking real migrations from platform lock-in to composable services. We study API design for machine consumers, examining how design priorities change when agents are your primary users. And we analyze the infrastructure and protocols, from MCP to event-driven architecture, that make machine-consumed software possible.

Every piece contains original insight or analysis. We do not write listicles. We do not churn out keyword-targeted content. If a piece could appear on any SaaS company's blog with the logo swapped out, it does not belong here. If a senior engineer would not bookmark it or reference it in an architecture discussion, it is not ready to publish.

The thesis, stated plainly

The software industry is undergoing a structural shift. The primary consumers of software are no longer humans clicking through interfaces. They are machines calling APIs: automated pipelines, orchestration layers, and AI agents that discover and invoke tools autonomously.

This shift has been building for years. API calls have outnumbered human clicks for a long time in most systems. What is new is that AI agents are making this universal and visible. Every API is now a potential tool for an autonomous system. Every SaaS dashboard is a thin layer over functionality that machines can access directly.

The implication for anyone building software: design for machines first. Make your system headless by default. Treat the API as the product and the interface as optional. The systems that follow this principle will be more flexible, more testable, more composable, and more valuable than their dashboard-first alternatives.

This is what Headless Systems will document, argue, and provide evidence for. Not breathless futurism. Engineering research, grounded in what is already happening.

If you are an engineer, architect, or technical leader making decisions about how to build systems in the age of AI agents, subscribe to the newsletter. No fluff, no spam. Just evidence-based analysis of the shift toward machine-consumed software.