How to Build AI Agents That Don’t Suck: Lessons from Ramp

There’s a quiet reckoning happening in the world of AI agents. For all the noise about copilots and assistants, most of them are a mess, half-baked, unreliable, and often more frustrating than helpful. You’ve seen it. You ask a smart assistant to book a flight, it does. Then you say, "Change my seat," and it fails. Not because it's a hard request, but because it's not "on the list."

That’s the failure point. Not in NLP, not in compute, but in product design.

I’ve seen this play out repeatedly in enterprise software. The AI gets shipped as a feature demo, not as a product. Teams build a few API endpoints for it to call, give it a nice UI, and call it an "agent." But beneath the surface, it’s a patchwork of isolated capabilities. Rahul Sengottuvelu at Ramp calls this out perfectly in his talk and what Ramp is doing instead is a masterclass in product strategy for AI.

The Mirage of Intelligence

Let’s start with the problem. Agents today are not "intelligent" in any practical sense. They are tool users. Their intelligence is bounded by the tools they can call and the instructions they are given. And here’s the kicker: in most companies, these tools cover maybe 5% of the product’s actual feature set.

What you get is a hollow shell of your own product. You spend years building a powerful front-end, packed with edge cases, configurations, and deeply considered UX. Then, your AI agent shows up with a toy hammer trying to do a grown-up’s job.

The result is a second-class user experience. It's not just bad. It's worse than not having an agent at all. Because it builds trust and then breaks it.

The Common Trap: Parallel Tooling

The typical approach goes like this: you define a set of backend endpoints for the agent to call. Want to "change billing address"? Build an API. Want to "adjust limits"? Another API. Before you know it, you’re reimplementing your product in slow motion, feature by feature, just so the agent can do what the front-end already does well.

Worse, you’re duplicating the complexity. You’ve already solved all this logic in your UI with validations, conditional flows, user permissions. Now you're re-solving it under a new interface. It’s a treadmill, not a roadmap.

Ramp's Insight: Let the Agent Use the Product Like a User

This is where Ramp flipped the model. Instead of giving the agent a narrow slice of backend APIs, they gave it access to the full front-end. Through a headless browser, the agent can "see" and "click" just like a real user would.

Think about that. The agent isn’t calling a bespoke API to change a card’s branding. It’s loading the actual settings page, navigating with the user’s credentials, and performing the same steps a human would. To the user, it just works. To the system, it’s indistinguishable from a power user moving fast.

This approach does something profound. It removes the need to prioritize and expose features one by one. Every feature your product supports is now instantly available to the agent, because the agent is using the same UI that was built to be complete, resilient, and intuitive.

From Feature Parity to Leverage

What I love about this is that it's not just a technical shortcut. It’s a strategic bet. Ramp decided not to play catch-up with its own front-end. Instead, they decided to make the agent a better user of their own product.

In my experience, this is the right lens to build enduring systems. Don’t build a new product for your AI agent. Give it the same tools that made your product great in the first place. Of course, it’s not trivial. You have to deal with authentication, user context, provisioning. But these are solvable problems. Reinventing your entire feature set for AI is not.

Scaffolding, Not Reinvention

Ramp also introduces the idea of "scaffolding", adding lightweight layers to make the front-end more navigable by agents. Think of it as internal DOM heuristics, simplified component libraries, or CLI overlays. You make the front-end a friendlier environment for the agent to operate in. But you don't rebuild the cathedral.

It’s reminiscent of how successful developer platforms evolve. You don't throw away the old API. You wrap it, document it, abstract it. Same principle here.

The Broader Lesson: Don’t Outsmart Your Own Product

If there’s one lesson here for founders and PMs, it’s this: your AI agent is only as smart as the tools you give it. And the best tool you already have is your front-end. You’ve invested years making it fast, robust, and usable. Let your agent benefit from that work.

I’ve made the mistake of building agents from scratch, only to discover they were always chasing the tail of the real product. Ramp showed that the path forward isn’t to reinvent the wheel. It’s to teach your agent to drive.