Table of Contents
We are living through a massive paradigm shift in software development. At Ramp, we have spent the last year exploring the limits of AI-driven productivity, moving from simple one-shot automations to sophisticated, agentic workflows. As we refine our approach, we have learned that the true power of artificial intelligence doesn't come from building thousands of disparate tools. Instead, it comes from creating a single agent with a thousand skills, supported by a robust infrastructure and a culture that prioritizes high-leverage decision-making.
Key Takeaways
- Shift from multiple agents to a single platform: Consolidate your conversational UX into an "Omni-hat" to provide a unified experience rather than fragmenting your AI stack.
- Embrace the iteration cycle: AI products cannot be "oneshotted." Start with simple, constrained problems, use live internal data to provide context, and build ground-truth data sets to iterate toward perfection.
- Prioritize auditability over black-box speed: As systems grow more complex, you lose transparency. Implement rigorous offline and online evals to ensure the agent's logic remains consistent, regardless of the underlying model.
- Cultivate an "AI-Native" culture: Leverage tools like automated coding agents to handle routine tasks, allowing your engineering team to focus on high-judgment, high-impact work rather than low-level implementation details.
The Paradigm Shift: From Tasks to Agents
Traditionally, software focused on the end of the process: buttons, tables, and human-inputted data. In the new AI paradigm, we have moved toward an autonomous system of action. An agent today takes an event (like an incoming invoice), applies prompt instructions, navigates strict guardrails, pulls necessary context, and uses defined tools to act—all without requiring constant human intervention.
Consolidating the User Experience
We initially built five different conversational interfaces across our platform. We realized this created friction, so we consolidated them into a single Omni-hat. By making the AI ubiquitous across all surfaces of the product, we allow users to interact with our software using natural language while still providing traditional UI elements, like tables and buttons, for when visual control is necessary.
Building the Policy Agent
One of our most successful deployments is the Policy Agent. Instead of writing endless deterministic code to handle every edge case, we treated our expense policy documents as the rules themselves. As one of our lead developers noted:
English is the new programming language. By turning the expense policy into the rules themselves, we move away from brittle, hard-coded logic toward an adaptable, reasoning system.
The Importance of Context and Iteration
One of our most significant learnings was that AI failures are rarely due to the model itself. Instead, they are usually a result of poor context. We discovered that simple variables—like an employee’s specific title or their department level—made the difference between an accurate approval and a false rejection. We learned to feed this context directly from our existing HRS fields into the LLM.
Building a Ground-Truth Dataset
Early on, we assumed we could just rely on user behavior to determine if an action was "correct." We were wrong. Users are inconsistent; they are sometimes lazy or simply uninformed about their own policies. To solve this, we held weekly cross-functional labeling sessions to build a gold-standard ground-truth dataset. This gave us a baseline to test against, ensuring that every code change we merged maintained our standards for compliance and quality.
Infrastructure: The Backbone of Applied AI
To scale, we built an Applied AI Service. At a high level, this functions as an LLM proxy, but it includes critical extensions: structured output, consistent SDKs across providers, and advanced batch processing. This allows our product teams to switch between models—like Gemini, GPT, or Opus—with a single config change, rather than rewriting dozens of call sites.
The Power of Tool Catalogs
The safety and efficacy of our agents rely on our internal tool catalog. By building reusable tools—such as "Get Policy Snippet" or "Fetch Recent Transactions"—engineers can quickly prototype new ideas without reinventing the wheel. We currently have hundreds of these tools, and we expect that number to reach into the thousands as our agentic capabilities expand.
Reframing Engineering Culture
The rise of coding agents like Ramp Inspect has changed how our team operates. By automating routine PRs, bug fixes, and logic tweaks, we have freed up our engineers to focus on high-level judgment. When an AI can handle 50% of the daily merge volume, the value of an engineer shifts from "how fast can you write code" to "how well can you architect systems and see around corners."
We don't need more people to write code; we need better judgment. The most important skills in an AI-native future are the ability to define the problem, manage stakeholders, and execute with an obsession for the end-user experience.
The future of software is not about "vibing" through code or trying to achieve perfection on day one. It is about building sustainable systems that learn from their mistakes and provide leverage to your customers. By investing in rigorous evaluation, a unified infrastructure, and a culture that prioritizes business impact over code nitpicking, companies can build products that were once deemed impossible. The work is never truly finished; it is simply evolving into a faster, more autonomous, and more impactful cycle.
