The New Wave of Agent-Native Applications (ANAs)

We are witnessing the beginning of the most significant transformation in software since cloud and mobile: Agent-Native Applications (ANAs). This shift will fundamentally reshape the SaaS landscape even more rapidly than previous computing revolutions. Tools like LangChain Platform are making it easier than ever to build this new and exciting type of application.

“I anticipate massive adoption of agent native applications across enterprise and consumer applications, I’m excited about this category!”

-Harrison Chase, CEO LangChain

ANAs are maturing at a significantly faster pace than previous waves of innovation. Having the domain depth, transparency, and controllability of an application, and the autonomy of an agent is a powerful pattern. The result of this marriage is an application that is easy to use and significantly more sticky. While the pattern is still early, it has already gained traction in developer tooling, and is picking up traction in back-office copilots by the day, and may soon take over every SaaS vertical on the market.

The World Is Converging on a New Pattern

Copilots

Early copilot solutions, such as GitHub Copilot, introduced the idea of context-aware suggestions. But these copilots were limited to providing guidance or recommendations without really participating in the work.

Agents

There has been a lot of hype around fully autonomous agents that promised hands-off productivity, but these have proven to much more effective when there is a human-in-the-loop.

Agent Native Applications

Increasingly, product teams are converging on a middle ground: an Agent-Native Application. These ANAs integrate the agent directly into an application’s core functionality, enabling a user and an AI system to work together in a continuous feedback loop. Rather than fully autonomous, the agent takes guided action in close collaboration with the user. This approach offers the adaptability of a human-expert team member combined with the speed and intelligence of advanced AI models.

Canaries in the Coal-Mine: Developer Tools

Replit

Any discussion of this design pattern has to start with Replit Agent. Replit’s Agent goes beyond code suggestions to work alongside the user. It can navigate development tasks, spin up servers, refactor code, and manage processes—all while remaining fully transparent and interruptible. Users can interject, redirect, or refine the agent’s steps at any point. This is a best in class product and is a product of a large team using tools like LangSmith.

We’ve seen thousands of builders from all backgrounds ship amazing apps with Agent and Assistant. They’ve changed the way we think about programming—today, anyone can build and deploy an app. We’re calling these new builders “AI-native developers.”

Matt Palmer @Replit Developer Advocate

Cursor

Similarly, Cursor provides an integrated coding experience where the agent does more than just assist—it makes context-driven changes that the developer can oversee and adjust as needed. Built on a fork of VS code, Cursor is  In the example above McKay Wrigley shows how to build an entire dashboard using only his voice in under five minutes.

v0 by Vercel

v0 has also adopted these principles, reflecting a clear pattern emerging within the developer ecosystem. While the user experience is similar to Cursor and Replit, v0 is focused on building front end components, even including a built-in component library for quick scaffolding.

All of these applications take a slightly different approach. v0 is focused on front end scaffolding to further Vercel's goals of making React & Next.js the default. Cursor is attempting to replace the traditional IDE to appeal to more serious developers. Replit agent has created an all in one solution to achieve it’s goal of making “one billion code creators” a reality.

These applications integrate a transparent Agent UI, enabling users to observe the agent’s reasoning and actions. They also incorporate a human-in-the-loop approach, allowing users to approve or adjust agent-generated plans, and leverage a specialized agent dedicated to solving a specific problem.

What Are the Features of Agent-Native Applications?

ANA’s are already making an impact beyond just coding. Everyday we’re meeting with teams who are building this workflow into their applications. Sometimes it’s a wholesale rewrite of their application, other times it’s a POC being built to get buy-in from leadership. Another pattern we’re seeing a lot of is “back office” copilots, these are tools that help internal employees get more done. What’s common is that it’s touching every industry faster than anyone realizes. What’s also common is the core features of these applications.

1. Domain-Specific Agents:

ANAs are designed with a deep understanding of the underlying product’s domain. They leverage domain-specific data, user history, and workflow details to provide tailored support rather than generic advice. This context extends far beyond code; it can include financial data, recruiting workflows, project timelines, and more.

2. Embedded Within Applications:

Instead of existing as stand-alone tools, ANAs integrate directly into an application’s user interface and backend systems. By working with the application state, they offer more meaningful suggestions and can take well-informed actions that fit the user’s current task. This augmentation of the application also means that users have little to no learning curve. Often the improved UX means that users are spending more time in the product and getting more done.

3. Human-in-the-Loop Collaboration:

A defining feature of ANAs is user oversight. Rather than running fully autonomously, the agent checks in with the user as it progresses, showing intermediate steps and justifications. The user can intervene at any time, ensuring that the AI’s actions remain aligned with business goals and user expectations. This also serves as a way to fight the perception of latency. It can be true that the experience of using an agent is almost magical, that doesn’t stop users from being annoyed if they don’t think anything is happening.

4. Agentic UI/UX:

While chat interfaces are a common entry point, ANAs leverage a variety of UI elements to convey agent reasoning, highlight changes within the application, and maintain transparency. This richer form of interaction makes it easier for users to trust and effectively guide the agent. Often times there is also a need for in-context agent interaction beyond the chat window. v0’s “magic wand” is a great example of this type of tooltip 2.0 that is appearing in ANA’s around the internet.

Beyond Developer Tools: Agent-Native Applications for All SaaS Verticals

Developer tooling is just the canary in the coal mine, developers build for themselves first but this pattern is coming to other industries fast. For example, Hedgeineer is applying the same principles to hedge fund analysis. Its agent-driven experience can streamline complex investment evaluations, allowing analysts to explore data and refine hypotheses through iterative dialogue. These tools have been available to the largest hedge funds with internal development teams, but now Hedgineer is leveraging LangGraph, CopilotKit and others to bring this to every fund on WallStreet.

Athena Intelligence is taking a similar approach for business analysis. Users can bring in diverse data sources, query them conversationally, and generate detailed reports—all while maintaining control over the agent’s direction. They’ve built a rich canvas on which the user and agent can collaborate on reports, content editing and more. Athena has also built in the ability for a user to create case specific workflows, this means that the next time that work needs to be done an analyst can simply invoke that workflow it’s already trained the agent to do.

This patterns of work exist in domains such as recruiting, construction management, and project oversight, where an ANA can manage intricate tasks and coordinate multiple stakeholders more efficiently than traditional interfaces. The question

The Tools Are Ready

While building a robust, domain-aware ANAs might seem challenging, the infrastructure to build them is production ready today. Advanced models from providers like OpenAI and Anthropic serve as the foundation. Agent orchestration frameworks like LangGraph power the reasoning and tool calling. LLM first tools like Taviliy and Letta manage things like memory and search. Finally state management and UX frameworks like CopilotKit tie it all together.

The problem for development teams isn’t that these tools don’t exists, it’s merely the awareness of what they are an how to use them. The only thing holding back adoption of ANA’s in production is the learning curve of how to build them.

So, what are you going to build?

Now is the best time in the history of the internet to be a web developer. All the SaaS businesses that have dominated their verticals over the last twenty years are vulnerable to competition from agent native applications. Teams need less money and less time to be able to exceed the features offered by the incumbents.

Now is the time to build. Not only can you build a superior product, there are also a multitude of ANA tools to help you prospect, create content, nurture leads and support customers.

If you’re looking for inspiration check out our latest demo, building a travel agent with LangGraph and CopilotKit