AI Agents: Who Holds the Front Door?

In short

• General-purpose agents (Copilot, Gemini) are becoming a common entry point for enterprise users, alongside business applications rather than replacing them.
• Two responses combine: exposing your software properly as an API-first module (structured API, standards like MCP), and targeting one or two touchpoints where the publisher holds a genuine advantage (a regulatory validation, for instance).
• This article details the mechanics of this shift, the degrees of disintermediation, what remains defensible for a publisher, and the limits of the scenario.

The new entry point: the agent, not the application

General-purpose agents are becoming the daily entry point for enterprise users. An employee opens Copilot or Gemini before opening their ERP or CRM, and asks it to act on their behalf. For a business software publisher, this shift raises a simple question: who keeps contact with the end user, the software or the agent that invokes it? Anticipated well, this shift opens a chance to become indispensable in a different way. Anticipated poorly, it relegates the software to the rank of a silent executor.

The word publisher applies just as much to someone who publishes a book as to someone who publishes software, and the parallel with Amazon sheds light on what’s at stake. Readers buy from Amazon, not from their publisher. Self-publishing even lets authors sell without a publisher at all. Business software is living an early version of a comparable shift today.

Enterprise users are opening their business applications directly less and less. They go through a general-purpose assistant built into their workstation or their inbox, and ask it to act. Microsoft pushes Copilot as a single entry point sitting above the Office suite and connected applications, to the point of merging its consumer and enterprise Copilot apps into a single interface in mid-2026. Google follows a similar logic with Gemini in Workspace, integrating the assistant app by app (Gmail, Docs, Sheets, Meet) rather than claiming a single entry point the way Microsoft does.

Business software, ERP, CRM, HRIS, doesn’t disappear in this shift. It becomes a component invoked behind the scenes rather than the screen opened every morning. For a publisher, this change goes beyond ergonomics. It shifts who owns the moment of contact with the end user, and therefore who captures attention, trust, and the opportunity to sell more.

This shift takes nothing away from the software’s technical value, but it changes how customers perceive it.

What actually changes for a business software publisher

A publisher’s natural instinct is to assume their data stays protected, so the topic doesn’t concern them directly. That’s technically correct, and yet three distinct channels bring the agent all the way to the software, without any data needing to be exposed in the usual sense of the term.

The first is the official connector. Many publishers are building one toward Copilot or another agent to stay visible in that ecosystem, a sound decision in itself. Once the connector is in place, the agent holds authorized access to the software’s data and functions, opened by the publisher itself for good reasons.

The second doesn’t even go through an API: an agent capable of browsing, like Claude for Chrome (in beta since late 2025) or the auto browse feature in Gemini for Chrome (in preview, limited to Google AI Pro/Ultra subscribers in the US), opens the software in a browser, logs in with the credentials it was given, clicks and fills in fields on the person’s behalf. These agents remain limited in availability today, but the principle they illustrate isn’t: no connector built by the publisher is needed here, and software closed to any integration remains just as operable this way.

The third comes down to orchestration more than access. A perfectly siloed system can still end up invoked without ever appearing on screen: the user asks their agent to run payroll, the HRIS executes the task behind the scenes, and its suggestions, its prompts to activate an extra function, stay invisible that day.

What’s at stake here has little to do with data security. The moment of contact with the user is shifting, the moment that usually builds the brand, the relationship, and the opportunities for additional sales. Reclaiming that moment of contact becomes the challenge.

Three degrees of disintermediation

Three levels help place where a piece of business software stands in the face of this shift, from lightest to most advanced.

The higher the degree, the more the software’s brand fades behind the agent that invokes it.

At the first degree, the agent plays the role of a copilot alongside the software. The user keeps their ERP or CRM open, and asks an assistant in parallel to summarize, prepare, or check something. The software’s interface remains the main place of work, the agent is just an occasional reinforcement.

At the second degree, the agent becomes the sole interface to the software. The user no longer reopens the screen: they drive the function from the agent, which invokes the software in the background at each request. The software keeps its role and its brand in the exchange, but loses the screen.

At the third degree, the agent recomposes the workflow itself, without ever naming the software that executes it. It orchestrates several systems to accomplish a broader business objective, and the user has neither the need nor the occasion to know which software did what. The software becomes one part among others, interchangeable in theory.

At the first degree, the publisher loses a bit of attention. At the third, the customer loses the very ability to name the brand as the solution they use, something that remains avoidable with the right choices.

All three degrees already coexist today, depending on the function and the customer. Nothing points to a sudden, uniform tipping point: the progression happens function by function, which leaves time to choose a response rather than suffer it.

What remains defensible

Four strengths continue to weigh in favor of business software, even in a world where the agent becomes the primary point of contact.

The first is proprietary data and its history. A general-purpose agent can orchestrate an action, it doesn’t recreate ten years of customer history, business configuration, or accumulated management rules baked into the software.

The second is fine-grained knowledge of the business and its exceptions. A collective bargaining agreement, a sector-specific accounting rule, a validation process unique to the company stay coded into the software, not in the agent that invokes it.

The third is compliance and legal responsibility for the action. Payroll, an accounting entry, a contract carry liability. Today it’s the business software that bears it, not the general-purpose agent that triggers the action.

The fourth is reliability over time. A general-purpose agent excels at a well-scoped, one-off task. Management software must guarantee repeated reliability, at scale, over months.

These four strengths hold given the current state of technology, but they need to be actively maintained and highlighted, rather than treated as a given.

Two strategic postures

Two options open up for a publisher who takes this shift seriously, and they combine more than they exclude each other.

The first, becoming the best API-first module, means properly exposing your functions, via a structured API or standards like MCP, now a Linux Foundation project with over a billion cumulative downloads, so that any agent, whichever it is, prefers to invoke this software over a competitor that’s less well exposed. It’s the default option, accessible to any publisher, regardless of size.

At Agora, this question connects to work already underway with HRIS, ERP and CRM publishers: properly exposing business functions via MCP, without letting a probabilistic model alone decide which actions to trigger. We detail this architecture in a dedicated article.

The second, winning a precise touchpoint, means targeting a specific moment where the publisher holds a genuine structural advantage: a regulatory validation, a high-perceived-value step, a use case where its proprietary data makes the difference. The goal isn’t to compete head-on with Copilot, but to build an anchor point that wins on a specific ground.

The example of an automotive supplier like Valeo sheds light on this choice. The group doesn’t try to compete with Renault or Volkswagen on the whole vehicle, it wins on lighting, where it claims to be the world leader, and on driver assistance, and draws a solid, profitable position from it. The same move is available to a mid-sized publisher: win on a specific function rather than on the whole screen.

A logical combination follows: applying the first option everywhere across the product, and reserving the second for one or two carefully chosen functions, rather than the entire offering. The temptation to avoid is widening posture B beyond that targeted scope, by trying to cover the whole product with an in-house agent: on functions where the publisher has no particular advantage, that agent rarely does better than Copilot, which pushes the user toward the general-purpose agent, including on the function where the publisher could have won by staying focused.

The limits of the scenario

The prevailing narrative is sometimes more radical than the current situation. Claiming that general-purpose agents will make business software invisible assumes these agents already know how to handle regulated or specific workflows entirely on their own. That isn’t the case today, and the strengths detailed above still count.

A general-purpose agent orchestrates tools, it doesn’t replace the business expertise baked into the code. Disintermediation shifts the user interface, it doesn’t remove the need for software that carries the business rule.

Even an ambitious, well-funded posture finds its limits over time. Nike stopped selling directly on Amazon in 2019 to regain control of its customer relationship, before returning in May 2025 as a direct seller. A brand with that much power didn’t manage to sustain a total break with the platform over time. For a mid-sized publisher, targeting a focused touchpoint remains a more sustainable ambition than a total break with the agent ecosystem.

The most likely risk, then, isn’t a sudden shift, but a gradual relegation of the software to invisible plumbing, without the customer formally having left the publisher. It’s a risk to margin and visibility, the same dilemma that paralyzes publishers today over their agentic AI pricing models, one that a timely, well-built response can likely address rather than a foregone conclusion.

The place of contact, not the disappearance of the software

The starting point fits in one sentence: the place where the user interacts is shifting from the screen to the agent, more than business software is disappearing.

Two responses exist, and they combine far more than they oppose each other. Becoming the best API-first module everywhere in your product remains the baseline option, accessible to any publisher. Winning a targeted touchpoint on one or two carefully chosen functions completes that baseline, without trying to compete with a general-purpose agent across the entire product.

Proprietary data, fine-grained business knowledge, and compliance remain solid strengths, provided they’re actively maintained and highlighted rather than treated as a given.

Much remains uncertain about the speed and shape this shift will take. The most reasonable stance is to stay flexible, keep testing the market, and build expertise on these topics. Publishers who move early on this ground will have a head start once usage patterns settle.

Published by Agora Software, which helps ERP, CRM and HRIS publishers properly expose their functions to general-purpose AI agents instead of just enduring this shift.