What if the app you’re building today is obsolete three months from now?

That thought is becoming harder to ignore. And you might be right. Interface-first apps are losing the battle for users’ attention because people have less and less patience for clicking through interfaces — at work, in their free time, anywhere.

People used to stay on one screen for almost three minutes. Today, it’s around 47 seconds.¹ At work, nearly half of employees already describe their day as chaotic and fragmented.² So how exactly is your app supposed to survive in that environment?

Pre-AI era

The old approach was simple: a human logged into an app, kicked off the process, analyzed the output, and decided what should happen next.

Then grabbed a coffee and did it all over again.

And again.

Until the job was done.

Looks strangely like a… loop?

Agentic first

What we want to do is let the agent run the loop — but not remove the human entirely.

Let’s rewrite the previous example.

The human goes for coffee. AI kicks off the process, analyzes the output, and decides what needs attention next. When an actual decision needs to be made, AI reports back to the human before anything is committed.

Then the loop starts again.

And again.

Until the job is done.

Chat + MCP doesn’t make your app agentic.

This is just a band-aid for existing apps. Adding chat or exposing an MCP server gives AI another way to interact with your application, but the workflow stays the same. Whether the user clicks a button or writes a prompt, they still have to analyze the output and decide what happens next. Your app must have an agent loop.

Don’t get me wrong — you can have a chat interface, and you should have an MCP server. But neither of them replaces the loop in your application.

What should you build instead?

Instead of thinking about the interface, think about creating an agent loop.

Take a task your customer does repeatedly and build an agent around it. Look at what they usually do, what they analyze, what they click, and where they need to make decisions. Then build the agent around that exact workflow. The customer provides the goal. AI runs the loop. The customer steps in only when an output needs to be reviewed or a decision needs to be made. That’s how your app reduces the amount of attention it requires from customers — not by making them click faster, but by doing more of the work for them. If your app doesn’t make that loop agentic, someone else’s eventually will.

Agentic-first also reduces the need for constant user attention. It allows employees to get more done without having to constantly monitor every step of the process.

Let me show you an example.

Comp AI CRM

Some time ago, Comp AI open-sourced an agentic-first CRM. You can find it here: https://trycrm.ai/

What makes it interesting is that the agent isn’t just another chat interface on top of the CRM. It actually does the work. It can enrich contacts, research people and companies, execute tasks in the background, and even create subagents when more work needs to be delegated.

And making this work requires more than just AI. Underneath, it has:

• Cost controls — you can limit how much money, how many tokens, or how much provider usage can be spent on a single task
• Durable background work — only one worker can own a task at a time, with recovery built in if that worker crashes
• Tools — the agent interacts with the system only through explicitly defined tools instead of getting direct database access
• Evidence over confidence — the agent is expected to provide evidence and sources for its conclusions. Strong evidence can be accepted automatically, while weaker evidence is escalated to a human for review.
• Human-in-the-loop — critical actions can require explicit human approval, especially when they override existing data, or are destructive

That’s the difference. Instead of giving the user a better interface for operating a CRM, the CRM starts operating itself.

A simplified agent loop can look like this:

User defines the goal → Agent enriches the profile or company data → Agent executes the task → User steps in only for review or approval

This takes work off the user’s plate. No more clicking through interfaces, filling in information, or searching for data manually. The user steps in only when the agent doesn’t have enough evidence and something needs to be reviewed or approved. This dramatically reduces the attention required from the user.

Not everything needs an agent

You need to balance automation with giving customers control and access to real people when they need it. Your audience may not want to interact with AI all the time, and that’s something worth listening to. Customer support is a good example. When the problem is unusual, sensitive, or simply frustrating, being able to reach a real human can matter more than automation. Not everything should be automated just because it can be.

There’s also the technical side — security and customer data. When the cost of an error is high, an agent shouldn’t be allowed to make the decision on its own. The higher the risk, the less autonomy you should give the agent. At the very least, actions like that should require human approval.

What does a good agent need?

A good agent can’t be left completely on its own. It needs clear boundaries within which it can operate — in terms of security, like sandboxing, but also in terms of what it is allowed to do in your system.

You can’t just give it every permission and switch on “YOLO mode.” You need to design those boundaries carefully around budgets, evidence, tools, and human-in-the-loop controls. Autonomy without boundaries is just risk.

Conclusion

Apps designed as interface-first may not stand the test of time. Not because they are bad. But because shrinking attention spans and an increasingly fast-paced world are changing what users expect from software.

To many, this may sound like AI hype, but it’s a natural evolution. We don’t want to spend our time doing tedious work. We want the app to do that work for us. The sooner you build an app that meets these needs, the less you’ll have to worry about it becoming obsolete.

Keep these key considerations in mind when building an agent loop into your application:

• Cost control
• Durable workflows
• Clear boundaries and permissions
• Evidence-based actions
• Human-in-the-loop

¹ https://ics.uci.edu/2023/01/26/regaining-focus-in-a-world-of-digital-distractions/
² https://www.microsoft.com/en-us/worklab/work-trend-index/2025-the-year-the-frontier-firm-is-born

AI tools were used as part of the writing process, primarily to support drafting, refinement, and language editing. Ideas and opinions are my own.