Nobody wants your in-app crapbot

2026-11-02

Every application seems to be getting an AI assistant. A chat button appears in the corner. The vendor's agent knows the application's data, understands its features, and can supposedly help us operate it.

But what if this is fundamentally the wrong approach?

My agent knows me. Your agent knows your application. Which of those is more important?

An application might know its own data and workflows intimately, but it knows relatively little about the person using it. My own agent potentially knows my projects, preferences, commitments, history, and what I'm trying to achieve across many applications.

Why should I abandon all that context whenever I open another application?

Perhaps what I really need isn't another agent. It's a way for my existing agent to use your software.

This is a contentious proposition, but the evidence is starting to support it.

1. Users are choosing independent agents

Shopping: 74% prefer independent assistants

In June 2026, PSE Consulting published research involving 4,250 consumers across the US, UK, France and Germany who already used AI for online shopping.

The results were striking:

• 74% preferred independent AI assistants for shopping discovery: 41% favoured general-purpose assistants such as ChatGPT or Gemini, and 33% favoured independent specialist assistants.
• Only 10% preferred an assistant embedded in a merchant's platform.

The explanation is fairly intuitive. Shoppers want to compare products across competing merchants. An assistant representing one merchant has access to its own inventory, but that isn't necessarily what the customer needs.

The shopper's objective extends beyond the merchant's application.

Interestingly, respondents still valued established marketplaces for completing purchases, handling payments and managing fulfilment. They wanted independent intelligence for discovery, while continuing to use specialist services for execution.

That sounds rather like an emerging architecture for agent-mediated software.

Customer support: third-party AI wins three to one

A Gartner study published in July 2026, surveying 3,566 customers, found that people were approximately three times more likely to use third-party generative AI than a company-provided chatbot when resolving customer service issues.

Use of third-party AI for customer service had nearly doubled over the preceding year, while use of company-provided chatbots had remained statistically unchanged since 2022.

This is particularly interesting because customer support is an area where the company's own assistant should have substantial advantages. It can potentially access account information, internal procedures and transaction systems.

Yet customers are increasingly starting their support journeys elsewhere.

Gartner also found that 58% of customers using generative AI had used it to complete tasks on their behalf, rather than merely retrieve information.

People increasingly expect their agents to do things, not just answer questions.

Assistants are starting to replace applications

An October 2025 TELUS Digital survey of 1,000 American adults who used AI assistants at least monthly found:

• 32% had replaced at least one traditional app with an AI assistant in the preceding year.
• 83% believed AI assistants completed tasks faster than traditional apps.
• 71% believed assistants adapted better to their preferences over time.

That last number is especially relevant.

Personalisation is something that accumulates through a relationship. An agent that works with me across different activities has opportunities to understand my preferences that an isolated application doesn't.

Of course, these are self-reported preferences and experiences, not controlled measurements of task performance. But they point towards a changing relationship between people and software.

2. Embedded assistants are struggling to demonstrate their advantage

The evidence goes beyond people simply adopting independent AI.

A May 2026 study reported by PYMNTS Intelligence, based on a survey of 2,111 US adults, found that embedded AI had lost ground as respondents' most helpful AI option in six of eight task categories.

Dedicated AI platforms gained ground in health and wellness, everyday planning, shopping, and finance.

An application might know its particular domain very well, but users often need discovery, comparison and broader context before interacting with a specific service.

Even deep application integration doesn't guarantee success.

The Australian Government's evaluation of its Microsoft 365 Copilot trial produced mixed results.

Only around a third of post-trial survey respondents used Copilot daily. Among the 16% who also used other generative AI products at work, 44% thought those alternatives met their needs better, compared with 24% who preferred Copilot.

Embedded features weren't uniformly successful. Excel and Outlook disappointed expectations, although Teams and Word applications performed better.

This was not an outright failure: 86% of post-trial respondents wanted to continue using Copilot. But it illustrates something important.

Being built into the application does not automatically make an agent the best choice for its users.

3. Others are reaching similar conclusions

This argument is appearing independently in several places.

In August 2026, Thierry Gilgen published The Last Interface, arguing for Bring Your Own Agent. Instead of giving every software product another assistant, vendors should expose their capabilities to the agents customers already use.

The distinction is between supplying a useful capability and insisting on owning the interface through which people access it.

In September 2026, Boston Consulting Group published The New Front Door, describing what it calls the Human Context Layer: the accumulated understanding of a person's preferences, priorities and circumstances that allows a trusted agent to act meaningfully on their behalf.

The implication is significant. An agent's competitive advantage may come less from its access to a particular application's internals than from its access to the human context surrounding the task.

And Rolf Bäck's August 2026 position paper, AI Agents Are Users, Not Features, argues that enterprise software needs to treat agents as independently identifiable, authorised actors, rather than features embedded within the application.

These are not all the same argument, but they point towards a common architectural direction.

The application provides capabilities. The user's agent provides intelligence, context and orchestration.

4. Developers got there first

Software developers have already demonstrated much of this pattern.

Rather than adopting one agent for GitHub, another for AWS, another for their issue tracker and another for their development environment, developers increasingly use coding agents that operate across all these systems.

Cursor, Claude Code and GitHub Copilot are examples.

These agents may be embedded in an editor, run in a terminal, or operate in the cloud. But they're not primarily agents for the editor or for GitHub. They're agents that developers use to accomplish their own goals across many tools and services.

The distinction matters.

The important question isn't where an agent runs. It's whom the agent represents.

A coding agent may understand the current codebase, the project's architecture, the developer's instructions and the work underway. Through command-line tools, APIs, MCP servers and other integrations, it can operate multiple applications without forcing the developer to switch agents.

GitHub's October 2026 Octoverse report found that 55% of GitHub Copilot's monthly active users were using agentic features, up from 35% a year earlier.

Coding agents aren't proof that independently chosen agents always outperform embedded ones. But they demonstrate the viability and adoption of user-directed agents operating across application boundaries.

Developers have an advantage here: their software has long been accessible through command lines, APIs, files and other programmable interfaces.

What happens when ordinary users can do the same thing with ordinary applications?

5. Context may matter more than privileged access

An application-specific agent has an obvious technical advantage: privileged knowledge of the application itself.

But that advantage is not necessarily sufficient.

Consider a travel application. Its agent might know every flight, hotel and booking option available within the service.

My agent might know why I'm travelling, whom I'm meeting, my budget, my calendar, my preferences, and the other commitments that affect the trip.

Which agent is better positioned to plan my travel?

The ideal arrangement might be for my agent to use the travel application's booking capabilities, combining the application's specialist knowledge with my own context.

The same principle applies to financial software, project management, healthcare administration, shopping, and potentially almost every other category of application.

This is not an argument that applications should surrender their business logic, permissions or authoritative data to general-purpose agents. Quite the opposite.

They should expose reliable, well-defined capabilities, with appropriate authentication, authorisation, approvals and audit trails.

The application knows how to perform its specialised operations. My agent knows why I want them performed.

Both kinds of knowledge matter, but they don't have to live inside the same agent.

6. Should applications stop building agents?

Not necessarily.

An embedded assistant can be extremely useful for a specific, well-defined task. Summarising a meeting in Teams, explaining a complicated screen, or helping someone who doesn't already have an agent are all reasonable applications.

And the evidence is not universal. The TELUS survey also found that consumers trusted traditional apps more than AI assistants to protect their personal data. Trust, security and reliable execution remain important advantages for established applications.

Nor do the available surveys establish that general-purpose agents consistently achieve better outcomes in controlled comparisons.

But they do challenge a widespread assumption: that adding a conversational AI feature to an application is necessarily the best way to make that application agent-friendly.

Perhaps the more valuable investment is an API, an MCP server, a plugin, or another interface through which the user's preferred agent can securely discover and operate the application's capabilities.

An application can still offer its own agent as one of several interfaces. It just shouldn't assume that its agent must own the relationship with the user.

For decades, application developers have competed to attract people into their interfaces and keep them there. In an agent-mediated world, the value of software may increasingly depend on how useful it is to an agent that the application vendor doesn't control.

The next great application feature might be the decision not to build an AI assistant at all.

This suggests a different competitive strategy for software companies:

Applications should compete to be useful to the user's agent, rather than competing to own the user's agent.