If AI agents do the work, why open the app?

I was listening to a podcast today and a HubSpot ad came on. The pitch: instead of you updating the CRM, the CRM updates you.

That line is supposed to sell HubSpot. I think it argues a bigger point than the ad intended. If the CRM can keep itself current and tell you what matters, why open HubSpot? Why open Salesforce? Why open any CRM?

I did not get here from a strategy memo. I use HubSpot at work. Lately I open it less, and email less. What I do more is talk to an AI: what happened, what I need, what to remember, what to do next. The filing and updating happen behind that conversation.

The CRM as an app was a workaround for a time when humans had to be the interface to a database. If an agent becomes the interface, the app in the middle becomes optional. And once you ask that about CRM, you have to ask it about the rest of SaaS.

The stack collapses toward two parts: AI that decides, and a system of record that enforces.

How a SaaS app is usually built

People often describe a business app the way textbooks describe three-tier or layered software: a presentation layer (the UI you log into), an application or business-logic layer (the workflow the vendor encoded), API and backend services, and a data layer. That is a common way to talk about the stack, not a law of physics. In a real product the backend and the business logic often overlap. A Salesforce validation rule, a Jira workflow, and a HubSpot automation all sit somewhere between “application” and “data,” depending on who is drawing the boxes.

For a long time the UI and the workflow-encoding layer were the product. You paid per seat because a person had to learn the screens and push work through the path the vendor designed. Admin certifications and implementation consultants exist for the same reason.

That is the part I think is thinning. Not because databases got smarter. Because an agent can take a requirement and compose the workflow on the fly: find the record, apply the rule, write the field, ask a person only when it should. You do not need a permanent screen for work that was always translation.

How it's usually described          What I think thins

Presentation / UI
Application / business logic        AI that decides
API / backend services              (intent, orchestration)
  (backend and logic often overlap)

Data                                System of record
                                    (rules, permissions,
                                     definitions, audit)

Those layers are doing three jobs in one product.

1. A system of record. Data lives somewhere: contacts, deals, messages, files, tickets, tasks, transactions.
2. A system of work. Humans translate intent into the record’s language. Open the app. Search for the record. Find the field. Type the thing you already know. Set the status. Attach the file. Move the card.
3. A system of representation. Fixed views: pipelines, inboxes, folder trees, dashboards, boards. Someone designed them in advance, and everyone lives inside them whether or not they match today’s question.

Only the first job is fundamental. The second existed because a database cannot understand “they pushed to next quarter, procurement is involved now, chase them Thursday,” and a person in front of a form can turn that sentence into five field updates. The third existed because, once the person was already in the app doing data entry, the app was also the only place to look.

Translation between human intent and structured data is something current models are good at. That is the whole opening.

The interface test

A simple test, including for the apps you used today:

1. Is its core value stored data: records, messages, files, events?
2. Do humans spend real time translating intent into the app’s mechanics: clicking, typing, filing, tagging, searching, formatting, reconciling?
3. Are its screens mostly fixed views of that same data: lists, boards, inboxes, dashboards someone configured earlier?

If all three are yes, the permanent interface is exposed. Not because the data stops mattering. The data matters more than ever. The defensible replacement is interfaces generated on demand, not no interface at all.

If the value is creation (designing, editing, composing), real-time collaboration, precise visual manipulation, or a network of other people, it is more durable. Payments and marketplaces belong here: the app is the network.

Logic doesn’t vanish. It moves.

The cheap version of this argument is that the app dies and you talk to a chatbot. That is not what I mean.

Business logic still has to live somewhere. Some of it belongs with the agent: what the person intended, which tools to call, how to sequence a follow-up. Some of it belongs below, in the data layer, where a model should not get a vote. Constraints. Permissions. Approval thresholds. Governed definitions. The audit trail.

The stack does not disappear. It collapses toward two parts. AI that decides. A system of record that enforces what is true and what is allowed.

I am not saying screens disappear. I am saying the app you log into every morning is optional. A view can be generated when you need to glance, then go away.

CRM was the ad that triggered the thought. It is not a special case. It is the same layered product with a pipeline on top.

The same stack, past the CRM

Email. An inbox is a message store plus a human who files every row. Reading, prioritizing, moving to folders, writing the short reply, copying the one date into a calendar: that is the UI and the application layer. An agent can watch the stream, surface the three messages that need you, draft replies, extract commitments, and file the rest with a summary you can query later. You ask: what came in that I need to know, and what are you handling? Sending in your voice still needs a gate. Drafts are cheap. Sends are not.

Drive and docs. Google Drive, SharePoint, Dropbox: object stores with a human-maintained index called folders. If you can ask for the proposal where the pricing changed and get the document, the passage, and the diff, you no longer need to remember which of the seven “final” versions is real. Who can see the file stays in the record. The files become more important, not less. They are the evidence. The browse tree stops being the product.

Calendar. Scheduling used to be pure interface work: open the grid, find a gap, add guests, move the conflict. The interaction is already conversational: find 30 minutes with her next week, not Friday, and prep me before it. I rarely open the grid anymore. It appears when I want to see the week. Finding a time across several people is still a negotiation. The agent can propose slots. The agreement is still between humans.

Spreadsheets. Take the counterexample seriously. A sheet is a place people think: model a scenario, drag a formula, watch the number move. Most work sheets are not that. They are a lightweight database someone pasted, pivoted, formatted, and emailed. That usage is exposed. What survives is the scratchpad. The transient, generated spreadsheet lasts. The maintained weekly ritual does not.

Jira and Linear. Asana, Trello, and Notion boards have the same problem: the board is only as true as the last time someone paid the status tax. The work happens in code, calls, and threads. An agent that can see the merged pull request or the meeting decision can answer what is blocked, who is waiting, what will slip? Calls, chats, and private repos are often invisible, so an agent that only sees tickets will keep a confident, incomplete board. A shared screen in a sprint review is still useful. That is a glanceable view, not a reason the tracker has to be a destination.

Dashboards and BI. This is the case I know best from work. The valuable part was never the chart grid. It was the governed metric definitions underneath. An agent asking questions against a metrics layer makes those definitions more important, and the frozen page less important. Building a trustworthy answer still takes someone who can turn “how are we doing?” into numbers a company will stand behind. That work does not go away. The semantic layer is the record. The page is a view you generate for today’s question, with the numbers traceable to their source.

Support, HR, finance. Zendesk, an ATS (a CRM for candidates), expense tools: different domains, same skeleton. The rules are real: who may approve what, what evidence is required, what an automated screen is allowed to decide. Rules are not a screen. They become policies the agent enforces. Humans handle the judgment calls.

Slack and Teams. The hard test, because chat is both the interface and the place the work happens. Catching up on a thread is filing. An agent can summarize overnight and put the decision in the shared record. The live argument is collaboration, and that stays. A pipeline review on one wall is a group committing to the same next step. I am not claiming the client vanishes. I am claiming the scrollback stops being the product.

What replaces the permanent app

Under the permanent app I expect five unglamorous components, most of which already exist:

• A structured database for exact facts: names, amounts, stages, dates, owners. Forecasts, billing, and compliance need exact answers.
• A way to recall by meaning, often a vector index: have we seen a customer like this, a clause like this?
• An object store for raw evidence: recordings, emails, contracts. Summaries can be regenerated. The source cannot.
• An event log for provenance: what changed, when, who or what changed it, and from which source. Audit trail and undo button.
• An agent with skills and tools, exposed through interfaces like MCP: capture, summarize, enrich, draft, follow up, forecast. Under the skills sit policies: permissions, approval thresholds, process rules as code.

Two principles sit under that. Schema on read: the world arrives as conversations and documents, and structure is extracted when needed, instead of forcing a person to pre-fill a form when they understand it least. Provenance over faith: every AI-written value carries a source and a confidence, and high-stakes changes wait for a human yes. Better than a tired person mistyping a field nobody can trace.

Representation becomes temporary. A pipeline for this morning’s question. A one-page brief before this call. A board-ready summary at quarter end. Interfaces become outputs, not homes.

What this does to SaaS

If people stop living in the app, per-seat pricing starts to look like a tax on a habit that is fading. Finance notices when the bill stays and the logins do not. I expect pricing to shift toward usage or outcomes, because a seat makes less sense when the person is no longer the one operating the product.

The moat moves to the data: the record, the integrations, the permissions, the history you cannot rebuild from a prompt. Trust is the product more than the theme.

The new front door is a tool interface. MCP is one way to expose the record and the actions so an agent can work without opening the vendor’s screens. The vendors that last will look like platforms or plumbing. Destinations are a weaker place to stand.

The honest objections

That stack is still a CRM. Fair. A database with rules, permissions, and an audit trail is the valuable part of HubSpot or Salesforce. My claim is not that the system of record goes away. It is that the per-seat app on top of it becomes optional. The vendor can survive as the backend. It gets paid like infrastructure.

AI will write wrong data. Sometimes, yes. That is why the event log, sources, confidence, and approval gates are architecture, not extras. Today’s CRM data is rotten because updating it is unpaid, resented labor. Capture with evidence attached is how the data gets better.

A team needs one shared truth. Correct. Nothing here implies twenty private agents. The record stays shared. Every person’s agent reads and writes the same record under the same permissions, instead of each person keeping a corner of an app and exporting a spreadsheet to reconcile.

Regulated industries need process and audit. They need it more than anyone. An enforced policy with a complete event log is a better audit story than “our reps are trained to click the right status.” Regulation slows the transition. It does not reverse it.

Agents will cost more, and they will be slower. Maybe. Token cost, tool-call latency, and the need to re-read large histories are real. This is not “AI is free.” The comparison is whether asking a model stays cheaper than paying every person to be the interface. If it does not, the app stays.

You are just moving the lock-in. Yes. If the agent holds the skills and the write path, lock-in shifts to the model vendor and the glue around it. That is a different dependency, not a smaller one. I would rather pay for a model and a database I can export than for a destination I have to live in.

Prompt injection. If an agent can read mail and also write the record or send as you, a hostile email is an instruction. Treat inbound content as untrusted. Keep a tight tool surface. Leave a person accountable for what gets committed. Provenance tells you what happened after the fact. It does not stop a buried instruction.

People still want a glanceable view. Yes. A pipeline on one wall, a week on a grid, five hundred rows when you are hunting an anomaly. Screens win at that. Those views do not have to be a product you log into all day.

People will not give up tools they know. They never do, all at once. That is why this happens in phases.

How it unfolds

Phase 1. AI writes into the app. Where we are now. Copilots summarize calls and draft updates inside the CRM, the inbox, the tracker. It helps, and it trains people to expect the app to maintain itself.

Phase 2. AI becomes the interface. The app becomes a backend. People stop opening it. The company keeps paying, because the data and integrations still live there. Finance starts asking what the per-seat bill is buying.

Phase 3. New teams skip the app. A company starting today can begin with the record, the evidence store, the log, and an agent with skills, and never buy the monolith. Categories break when incumbents stop winning new customers.

Phase 4. Enterprises unbundle slowly. Permissions, metric definitions, approval policies, retention, and audit survive, bought from vendors who accept becoming infrastructure or rebuilt on open components. The permanent app as a destination does not come back.

Where this lands

The data matters more, not less. Judgment does not disappear. It concentrates in the exceptions, the approvals, the calls only a person should make. Accountability does not disappear. It gets a better log. Interfaces do not disappear. They stop being destinations and become answers.

What disappears is a historically brief arrangement: skilled people spending a slice of every day as unpaid data-entry clerks for the databases their employers bought, because for decades there was no other translator.

The app was how humans reached a database. If an agent can decide and a system of record can enforce, the app is optional.

---

Disagree? Reply on X/Bluesky or email me.