When we started building agentic applications, we thought our biggest challenge would be getting the AI to reason better. Like many teams, we obsessed over prompts, models, orchestration frameworks and tool chains. We spent hours debating which models performed best, how to structure workflows and how to improve reasoning accuracy. The user interface barely featured in those conversations. Looking back, that was our first mistake.
As our applications became more sophisticated, we realized that the intelligence was improving faster than the experience of using it. The agent could perform increasingly complex tasks, but users were still interacting through what was essentially a glorified chat window. The gap became impossible to ignore. Here are some of the lessons we learned while building agentic applications and, eventually, Agent-to-User Interfaces (A2UI).
Lesson 1: Users Don’t Want Answers. They Want Outcomes.
One of our early use cases involved helping users review loan applications.
The workflow worked exactly as designed. A user could request pending applications; the agent would retrieve the information and a detailed response would appear within seconds.
From an engineering perspective, it was a success. From a user perspective, not so much.
During testing sessions, we noticed that people weren’t really reading the response. They were scanning for the next thing they needed to do. They wanted to sort applications by risk. Filter by amount. Open supporting documents. Approve, reject or escalate cases. The information was there. The action wasn’t.
That was a pivotal moment.
We realized users weren’t interacting with AI because they wanted better answers. They were interacting with AI to complete tasks faster.
Practical takeaway: Whenever you design an agent, ask yourself: What action will the user want to take immediately after receiving this information? Then make that action part of the experience.
Lesson 2: The Best UI Is Often the One That Wasn’t Design in Advance
Traditional software assumes developers can predict user journeys.
You build screens, menus and workflows upfront. Users follow the paths that have been created. Agentic systems don’t behave that way. A user investigating an operational issue may need a dashboard. Another investigator investigating the same issue may need a table. A third may need a workflow approval screen.
We found that trying to anticipate every possible path quickly became unsustainable. The more dynamic the agent became, the less effective static interfaces felt.
The breakthrough came when we stopped thinking of the UI as a fixed layer and started treating it as something the agent could assemble dynamically. Instead of building every screen upfront, we gave the agent the ability to generate the experience required for the task at hand.
Practical takeaway: Design for adaptability, not completeness. It is impossible to predict every interaction path. Focus on giving agents a toolkit of UI components they can compose dynamically.
Lesson 3: Every Extra Token Eventually Shows Up on Your Bill
After solving the interface problem, we encountered another challenge.
Not infrastructure cost, but token cost.
Initially, we didn’t pay much attention to it. A few additional tokens here and there didn’t seem significant.
Then we started measuring. Tool outputs were verbose. Database payloads contained information the model didn’t need. UI definitions were larger than expected. Prompt assets kept repeating the same instructions. None of these decisions looked expensive individually. Together, they created a surprising amount of overhead.
The result was higher latency, increased costs and reduced throughput. What surprised us most was that the problem didn’t stem from the model. It stemmed from the architecture surrounding the model.
Practical takeaway: Start measuring token consumption long before production. Most optimization opportunities sit outside the model itself.
Lesson 4: Treat Tokens Like Engineers Treat Compute Resources
Cloud-native development taught us to think carefully about how we use infrastructure. Agentic systems require a similar mindset.
Every token entering or leaving the model should justify its existence. Once we started reviewing our architecture through that lens, inefficient patterns became obvious. Large JSON payloads were moving through the system unchanged. Prompt instructions were duplicated across interactions. Schemas prioritized readability over efficiency.
We weren’t dealing with AI problems. We were dealing with classic engineering problems: redundancy, inefficiency and unnecessary complexity.
Practical takeaway: Make token efficiency part of architecture reviews. Do not wait until performance issues emerge.
Lesson 5: Optimize the Entire Pipeline, Not Just the Model
One mistake we see repeatedly is teams focusing exclusively on model optimization. In practice, the model is only one component of the experience.
Data retrieval matters. Prompt design matters. Interface generation matters. Validation matters. Rendering matters.
The largest improvements often came not from changing models but from rethinking the flow of information across the system. For example, compressing tool outputs, reducing payload sizes and streamlining interface definitions consistently delivered improvements in both responsiveness and operating cost.
Practical takeaway: Follow the data. Identify where information is created, transformed, duplicated and discarded. Optimization opportunities usually reveal themselves quickly.
Lesson 6: Users Judge the Experience, Not the Architecture
Perhaps the most important lesson we learned is that users don’t care how sophisticated the underlying architecture is.
They care whether the experience feels effortless. They don’t care about orchestration layers. They don’t care about token optimization. They don’t care about prompt engineering. They care whether the right information appears at the right time and helps them make decisions faster.
When an agent automatically surfaces a dashboard instead of a paragraph, users notice.
When an approval workflow appears exactly when needed, users notice.
When the application responds instantly rather than making them wait, users notice.
Those moments ultimately determine adoption.
And adoption is what turns AI experiments into business value.
The Lesson We Didn’t Expect
The biggest lesson from building agentic applications wasn’t about prompting, model selection or orchestration. It was that intelligence alone doesn’t create great experiences. An agent may be capable of remarkable reasoning, but if users have to wade through walls of text to accomplish a simple task, most of that intelligence goes unused.
Conversely, when the right interface appears at exactly the right moment when data becomes a dashboard, when recommendations become actions, when reasoning becomes interaction, the experience feels fundamentally different.
That’s the direction enterprise AI is heading. Not toward bigger chatboxes, but toward systems where agents and interfaces evolve together.
The organizations that succeed won’t necessarily be the ones with access to the most powerful models, but the ones that build the most effective collaboration layer between humans and those models.
Because as agents take on more responsibility, the conversation is no longer just about artificial intelligence.
It’s about designing digital experiences that can keep pace with it.
What exactly is A2UI
At its core, A2UI is a declarative protocol that allows AI agents to generate rich, interactive user interfaces natively across web, mobile and desktop environments, without executing arbitrary code.
Think of it as a universal UI language. Instead of asking an agent to write raw HTML or React components, A2UI lets it express a standardized schema of intent that the client device can interpret and render natively.
Key Characteristics of A2UI
- Just-in-Time (JIT) Rendering: Components such as sliders, forms or maps are instantiated exactly when the workflow requires them.
- Context-Awareness: The UI morphs based on the semantic task. If a user is booking a flight, the agent projects a seat selector; if they are analysing a budget, it projects a dynamic chart.
- Native Performance: Because the backend instructions are interpreted by the client’s native widgets, the UI remains highly performant, accessible and visually consistent with the rest of the application
Ready for the Next Generation of Enterprise AI?
The question is no longer whether AI can perform complex tasks. The question is how effectively humans and AI can collaborate to complete them.
At Persistent, we are exploring how Agent-to-User Interfaces (A2UI), adaptive experiences and token-efficient architectures can help enterprises move beyond chat-based interactions and unlock greater value from their AI investments.
Get in touch to build better collaboration between people and intelligent systems.
Author Profile
Riddhi Siddarkar
Lead Software Engineer, CTO AI Research
