Inside Ramp's software factory
Four engineers plus one part-time PM built an in-house background agent that now authors 3 of 4 merged pull requests, and gave it the same tool access as a human engineer.
Ramp at a glance
The company
| Sector | "An all-in-one spend management platform" 9 |
|---|---|
| Employees | Not disclosed as a discrete, source-confirmed count |
| Customers | 70,000+ businesses 8 |
| Revenue | $44bn valuation (June 2026); $1bn+ annualized revenue; $200bn+ annual purchase volume 8 |
Third-party employee-count aggregators disagree by more than 3x with each other; none is a primary disclosure, so the row is left unstated rather than guessed 8.
The engineering organisation
| Engineering size | About 5 people own Ramp Inspect directly; 150+ engineers have contributed to its codebase 1 |
|---|---|
| AI tooling since | November 2025, Inspect v2 launch 1 |
| Tool policy | Built in-house (Ramp Inspect, on OpenCode) rather than bought 2 |
| Agents in the SDLC | Background coding agent; automated first-pass PR review; staged-autonomy risk agent 1,2,4 |
| Reported adoption | ~75% of merged PRs authored by Inspect as of May 2026, up from ~30% at launch 1 |
| Published metrics | PR-authorship share, session count, integration cost and count 1,5 |
The ~75% figure measures merged-PR authorship specifically. A separate, less-sourced claim ("50% of code, probably 80% soon") measures something else and is not directly comparable 1,6.
People
What they set out to solve
Ramp built rather than bought, and that decision created three narrower problems it then had to solve.
The starting point was a wager that owning the tooling would beat renting it: "Owning the tooling lets you build something significantly more powerful than an off-the-shelf tool will ever be. After all, it only has to work on your code," as the engineering blog frames the decision to build Inspect on top of OpenCode rather than adopt a vendor product outright 2. That bet paid off quickly enough to create a problem of its own: once Inspect could turn out near-complete pull requests, human review became the bottleneck, so a separate model now runs automated first-pass review on every PR, cutting the wait for substantive feedback from hours to minutes 2.
Two more problems sat outside the coding pipeline entirely. Financial-risk decisions couldn't be handed to an agent all at once — Ramp's risk-operations write-up frames it as a trust-calibration problem, where an agent's outcome distribution and its alignment with human operators have to be measured before its decision volume is allowed to grow 4. And writing new payment-provider integrations by hand didn't scale, so the integration-writing agent exists specifically to compress work that used to take weeks or months down to hours 5.
Maturity level
Assigned by testing published facts against fixed criteria, and capped by what the sources state.
How Ramp's software factory works
At the core of Ramp's software factory sits Inspect, a background agent built to close its own loop: it writes code, then uses the same context and tools to prove that code works, rather than leaving verification entirely to whoever reviews the pull request. Version 2 launched in November 2025; by May 2026 it was authoring roughly 75% of merged pull requests, and it crossed one million total sessions by July 1.
That level of trust only works because Inspect gets the same tool access as an engineer would, deliberately, not as an oversight. It's wired into Sentry, Datadog, LaunchDarkly, Braintrust, GitHub, Slack, and Buildkite, and can query a sanitized, read-only production database replica and Snowflake directly, because Ramp's stated position is that agents need the same context as software engineers, not a restricted subset 1,2.
That access, in turn, only works because every session runs in a full, disposable environment. A sandboxed VM mirrors the same Postgres, Redis, Temporal, and RabbitMQ stack engineers run locally, alongside a VS Code server and a VNC stack with Chromium for visual verification. Filesystem snapshots refresh on a 30-minute cron cycle, so a new session starts working on a prompt within seconds instead of waiting on a cold build 3.
Work reaches Inspect from wherever it starts: tagged in a Slack thread it can read for context, pointed at live UI through a Chrome extension, or opened through a hosted web console with embedded VS Code. All three routes converge on the same multiplayer session, so a designer, a PM, and an engineer can hand off one piece of work without starting over 3.
Once Inspect finishes, it hands off to a second agent that runs first-pass review, so a human reviewer gets substantive feedback in minutes rather than hours on a PR that's often already near-complete 2.
A third agent solves the integrations problem directly. It reads a provider's API documentation, works out call sequencing (that a background-check provider needs a candidate record created before it can send an invitation, for example), and writes and threads together "recipes" into a working connector. Test credentials stay in encrypted storage embedded at runtime, so the LLM's context never contains a raw secret, and each generated PR carries every endpoint touched, the exact request and response pairs, and screen recordings of the connector's tests running, evidence for the human reviewer 5. Seventy-five integrations have shipped this way, the first at a compute cost of under $15.
An AI coworker for every employee
None of this was limited to the engineering org. By early 2026, Ramp had already hit 99% AI tool adoption company-wide, and still ran into the same wall most companies do at that point: most people were stuck at the starting line, not because the models were weak, but because getting an environment properly wired up was its own project. Six Ramp engineers wrote up the fix in April 2026: an internal platform called Glass, built to give "every employee at Ramp their own AI coworker" 10.
One Okta sign-on connects an employee to everything at once, Slack, Notion, Linear, Gong, Salesforce, Zendesk, Snowflake, and Ramp's own internal tools, rather than leaving each person to configure access one integration at a time. A marketplace called Dojo turns individual workflows into shared assets: someone automates a task, packages it as a markdown skill, and publishes it for anyone else to install, Git-backed, versioned, and reviewed like code, with more than 350 shared company-wide. A recommender called Sensei surfaces which of those skills are relevant to a given employee's role, tools, and recent work, so discovery isn't left to search. Underneath it all, a daily pipeline mines Slack, Notion, Linear, and Calendar into a persistent memory layer, so a new session doesn't start cold, and jobs run on cron, daily, weekly, or custom, posting results straight into Slack 10.
The clearest proof of what Glass makes possible is Ramp Research, a Slack-native AI analyst that indexes dbt, Looker, and Snowflake metadata alongside internal documentation, holds state per thread, and returns CSV previews on demand, with no access to personally identifiable information 11. In its first four weeks, the channel built around it logged 1,476 questions against 66 in the help channel it replaced, a 10 to 20x jump in how often people actually asked, across more than 500 beta members 11.
Ramp's own explanation for building all of this in-house rather than buying it: "When you own the tool, you see exactly where people get stuck. You can ship fixes the same day someone reports a problem" 10.
Operating the software factory: teams, roles, and skills
Ownership is concentrated and disproportionate to output: 5.5 people, four engineers, a director, and a part-time product manager, own Inspect directly, even though more than 150 other engineers have contributed to its own codebase 1. That gap is the point rather than an oversight — adoption is described consistently across sources as organic rather than mandated, with engineers choosing to route work through Inspect and the percentage of merged PRs it authors reported as a consequence of that choice rather than a policy target 1,2. Separately, the company's Chief Product Officer has described an internal "L0-L3" framework for AI-usage proficiency across the company 6.
Implementation journey
- November 2025Inspect v2 launches, reaching roughly 30% of merged pull requests within a couple of months 2.
- January 2026Inspect's share of merged pull requests climbs to roughly 60% 1.
- March 2026Ramp's Chief Product Officer states "50% of Ramp's code is written by AI, probably 80% soon," a separately-sourced claim measuring something different from PR-authorship share 6.
- May 2026Inspect's share of merged pull requests reaches roughly 75% 1.
- July 2026Inspect crosses one million total sessions 1.
Measuring the software factory
The most rigorously sourced figure is PR-authorship share shown in the timeline above. That is a real, if self-reported, measure of output share, not of code quality or review burden.
Two other headline numbers lack the same grounding. The CPO's claim that "50% of Ramp's code is written by AI, probably 80% soon" comes from a single newsletter piece, carries no stated measurement methodology, and describes something different — code written versus PRs authored, which the sources report interchangeably 1,6. A claimed reduction in CI P50 time from 18 minutes to 6, attributed to an agent called "Fable," surfaces only through a third-party aggregator's summary of an unlisted talk, with no verified primary transcript available 7.
The integration factory's economics are the most granular figures in the record: 75 integrations shipped, the first costing under $15 in compute, though the source is explicit that this is compute cost only and excludes the human review and curation time it says is still required 5.
Lessons learned
Ramp's richest single-number claims are also its least independently verifiable ones. The CPO's estimate that half of Ramp's code is AI-written, "probably 80% soon," and the claimed CI-time reduction both arrive through secondary sources rather than Ramp's own engineering blog or a verified primary transcript 6,7. Rahul Sengottuvelu himself carries two different titles across sources, CTO in the most detailed profile and Head of Applied AI in an earlier vendor case study, with nothing reconciling the discrepancy 1,3.
"Organic adoption, no mandate" is a framing repeated across every first-party source, but it's a framing, not a full account: no source discloses churn, how many engineers tried Inspect and stopped using it. And the integration factory's headline cost figure is scoped more narrowly than it first appears — "<$15 per integration" excludes the human review and curation time the same source says integrations still require 5.
What's next for Ramp's software factory
Ramp hasn't described a specific forward-looking roadmap item or a planned system. What the record offers instead is directional: the continued climb in Inspect's share of merged pull requests, and the CPO's stated expectation that AI-authored code broadly will reach "80% soon" 1,6. Neither is tied to a shipped feature or a stated date.
