The Interface of Software Will Be the AI
How MCP changes the collaboration between systems, agents, and humans
Many discussions about AI currently revolve around a seemingly obvious question: How do we integrate AI into existing systems as quickly as possible?
CMS vendors add chat features, monitoring tools introduce “AI insights,” and almost every product suddenly includes a prompt field somewhere in its interface. We followed a similar path at first. In our TYPO3 extension ai_filemetadata, for example, we connect TYPO3 to external LLMs to automatically generate image descriptions.
That approach works well and solves a real problem. But it may only be an intermediate step.
With the Model Context Protocol (MCP), the relationship between systems, AI, and people is beginning to change.
Instead of integrating AI into systems, systems themselves become interfaces for AI.
Software becomes capability, not surface
Today, people work directly inside applications:
- Editors in the CMS.
- Developers in monitoring tools.
- Marketing teams in the analytic platforms.
Each system has its own interface, its own workflows, and its own logic. To complete a task, users need to know which tool is responsible and how to operate it.
With MCP, this role shifts.
Systems will no longer only provide a user interface. They will also expose their capabilities through an MCP server.
A CMS, for example, might offer capabilities such as reading content, creating new pages, managing media, or modifying structures. All accessible to an AI agent.
The interface remains important for humans.
For agents, however, the interface becomes the API.
The shift becomes clearer when looking at how systems integrate with AI today and how that changes with MCP.
Agents become conductors
At the same time, the role of large language models is evolving.
LLMs are often still perceived as chatbots or text generators. Many discussions focus on how well they can create texts, generate code, or answer questions.
But their role is moving in a different direction. Increasingly, LLMs are embedded within agent systems.
These agents can use MCP to access the capabilities of different applications and combine them.
An agent might research information, generate content, publish it via a CMS, check monitoring data, and evaluate analytics results.
In this model, the agent becomes the conductor of various systems.
The agent becomes the conductor of various systems.
The role of users changes as well
This shift inevitably changes how users work.
Today, users operate tools directly. They navigate forms, menus, and dialogs, moving information between systems.
With agent-based workflows, this activity increasingly shifts towards briefing:
The user describes the task. The agent does the work.
This can begin with very simple tasks:
“Check all texts in the CMS for spelling errors.”
“Replace the product name across the entire site.”
Or something more extensive:
“Place the content from this Word file structured in the CMS, add an SEO description, and suggest possible SEO optimizations.”
Even more complex tasks can be formulated in this way. For example, an editor could brief:
“Create a landing page for topic X, reuse relevant sections from the last three articles, add a short introduction, and optimize the text for SEO. Use keyword insights from analytics and optimize for the best possible CTR.”
The agent can combine information from various systems: It researches the content, creates the text, checks the analytics data, and places the page in the CMS. The tool itself fades into the background. What matters is not where the work happens, but which capabilities the agent can access.
The interface of software will be the AI
If you follow this idea to its logical conclusion, the architecture of software begins to change.
- Systems provide capabilities.
- Agents use and combine these capabilities.
- Humans define the task.
- The traditional user interface becomes less central.
Put simply:
The interface of software becomes the AI.
This does not mean that existing applications will disappear. A CMS, an analytics platform, or a monitoring system will continue to exist. But their role is changing.
They become structured interfaces that agents can interact with.
One aspect is particularly important here: the structure of the data.
The more structured a system’s data and capabilities are, the better agents can use them. Systems that model their data cleanly and expose clear capabilities are far easier to automate than systems that primarily rely on unstructured content or WYSIWYG interfaces.
In the CMS world, this discussion is not new. For years we have argued that content should be structured instead of being treated as free-form text fields. With agent-based systems, that idea gains a new level of importance. Structured content is no longer just about reuse or multi-channel publishing.
It becomes a prerequisite for agents to reliably interact with a system.
A new task for software vendors
For software vendors, this shift has clear implications.
Remaining relevant will not depend on adding yet another chat interface. The real question will be how well a system exposes its capabilities to agents.
This is exactly where MCP comes into play.
Systems that provide structured and reliable MCP servers can become part of a broader ecosystem where agents combine multiple tools.
For users, the central question will no longer be which application they use, but which capabilities their agent can access. Systems without such interfaces will struggle to remain part of these workflows.
Why it makes sense to explore this now
This development is still at the beginning. Many MCP servers are experimental, agents do not always work reliably, and new workflows still need to evolve.
Nevertheless, it is worth exploring now.
Because the real shift is not a new protocol or another technical standard. It is a change in how we interact with software.
Today, people operate applications directly. They move through interfaces, click through masks, and transfer information between different systems. With agents, this work shifts toward defining tasks. Humans describe the objective, while agents execute the work by combining the capabilities of different systems.
The tools remain. But their role changes.
They become structured interfaces that agents can use. And that is exactly why it is worth experimenting with it now.
Please feel free to share this article.
Comments
No comments yet.