How Ramp gives AI agents access without losing control

Ramp CTO Rahul Sengottuvelu says he asked Claude Fable to tackle import cycles and lazy loading in the company’s large Python application. The model made progress and much of the code was merged. He wants to understand where models fail so the team can revisit those problems with later releases.

One early Fable test was deliberately measurable: Sengottuvelu chose a substantial piece of code in the testing suite, away from the product itself, and checked its behavior with large amounts of data. The generated implementation ran in shadow for weeks and was consistently faster than the existing one, he says.

Anthropic’s Boris Cherny says he gives every new model a set of tests and that Fable was the first to complete them all. When it struggled, he used a dynamic workflow in which Claude orchestrates subagents. In his own CI example, he estimates the median fell from 18 minutes to six as the agents repeatedly profiled and optimized the system.

Cherny says the workflow landed code, waited a day for production data, then returned to repeat the process until it had accumulated the improvements. Ramp engineer Austin Ray asks how he can trust a large workload when many background agents do work out of view. Cherny compares the workflow to giving a model more computation at test time.

Asked about loops versus dynamic workflows, Cherny says loops suit repetitive work, such as watching a pull request, fixing CI and rebasing. Dynamic workflows fit open-ended tasks such as system optimization, where the next step is not known in advance. Ray says using them requires giving up more of the engineering workflow to an agent.

Cherny describes loops as taking a recurring horizontal slice of many engineers’ work, such as code review or daily dead-code cleanup. As a more end-to-end example, he says Claude Tag can launch an experiment, check it later, increase exposure and eventually prepare a pull request to ship a variant; he approved the initial pull request.

Ray describes a relatively bare Claude Code setup: terminal panes, few plugins or tools and a simple CLAUDE.md. He uses subagents and adversarial review and says a minimal setup helps him learn what models can do. Sengottuvelu’s setup has moved more work into the background, often to gather information about service behavior or project bottlenecks.

Sengottuvelu says running many local development instances can become a constraint when a company has many services, databases and queues. Newer models need less hands-on guidance in his experience, so he has increasingly moved sessions into the background; local sessions remain useful for close debugging or access to his machine’s context.

Ramp has applied agents across much of its engineering lifecycle, Sengottuvelu says: identifying ideas and bugs, noticing problems in logs, writing and reviewing code, and monitoring changes after deployment. The company has also considered security uses such as finding bugs and other issues.

As models improve, Ramp has often removed scaffolding it had built around earlier capabilities, Sengottuvelu says. The team tries to design for a future model by providing tools, context and agency so it can handle requests more like a coworker. He also acknowledges that the current product must work today.

Ray calls this a bet on speed: infrastructure designed to compensate for today’s model limitations may soon become technical debt. Aiming further ahead may let the team make more progress with its available resources, although it must decide where to place that bet.

Cherny asks how Ramp controls data access, cost and code quality as its systems scale. Sengottuvelu says the team studies individual execution traces rather than only aggregate benchmarks: what command should have run, and did the agent lack context or the right tool? Layered defenses allow the company to give agents more agency while limiting access.

The aim is to give the model what it needs and nothing more, including read-only credentials where appropriate. Sengottuvelu wants colleagues to state the outcome they need—fix a bug or implement a feature—rather than dictate every step. The team shapes the agent’s behavior with prompts, tools and skills around the path a successful task should take.

Ray adds that hard controls and least privilege prevent certain actions altogether. Sengottuvelu says Ramp’s security team built the infrastructure, helped configure network access policies and credentials, and uses the agents itself. The work is not separated from the people responsible for security.

Ramp looks for cases where the worst possible effect of a buggy change is tightly constrained and the potential benefit is clear, Sengottuvelu says. The company is preparing its testing and deployment verification loops for greater output. Ray adds that reviewers’ priorities should change as models stop making some classes of mistakes.

Ramp also built a code-review bot on Inspect, its background-agent API. Sengottuvelu says some teams write skill files containing the particular problems and accumulated knowledge they want the bot to check. That gives teams a way to make their review practices reusable.

Asked how engineers are empowered to remove bottlenecks, Sengottuvelu points to a culture where experiments that do not work out are acceptable. Ramp gives engineers access to tools without imposing individual token or tool budgets, he says, making it easier for colleagues to share a common understanding.

Ray describes Glass as a home base where nontechnical staff can interact with a coding agent without needing to see code or technical detail. Sengottuvelu describes Inspect as a background coworker with access to tools such as GitHub, Linear, Slack, Datadog and Sentry; it can investigate tickets, errors and other engineering tasks.

People can start Inspect from the web or mention it in a Slack conversation, Ray says. Colleagues saw it being asked to help in a thread and discovered that they could use it too. Sengottuvelu says each pull request gets a virtual machine for a time so people can take over or collaborate through links.

Ramp is still working on giving Inspect the repositories, dependencies and tools it needs so that people can stay in the background longer rather than returning to local development. The team continues to ask what the agent should have done and adjust the tools and context around that path.

Ray describes an on-call assistant that has always run on Claude Code. Ramp developed the skills, tools and prompts locally, then packaged the assistant in a container with safeguards. He says it runs on incidents assigned to engineers, including customer support tickets and system incidents, and returns root-cause analysis to the incident’s Slack channel for responders.

Cherny compares Inspect with Anthropic’s Claude Tag, which also works in Slack and has taken over tasks previously handled by specialized bots. Sengottuvelu says more Inspect sessions now come from automation than people: schedules and external systems trigger sessions that can notify channels or individuals.

The organization of these automations is decentralized, Sengottuvelu says. A team maintains shared foundations such as Inspect, but other teams can build what they need on top. Ray says the platform team watches for repeated demand or parallel efforts and turns those into stronger shared tools, while also anticipating future model capabilities.

Ramp does not set individual token or dollar limits, Sengottuvelu says, but it uses cost-conscious defaults, batch and flexible APIs, and cheaper models for automations not controlled by a person. The team expects to keep adopting newer models and tries not to make features dependent on one model’s particular behavior.

Ray says the team also talks to people whose spending suddenly rises. If an experiment could benefit others, they help turn it into a shared capability; if spending was accidental, they help correct it. Costs can be optimized later once the team knows an experiment is worth scaling.

Sengottuvelu argues that if each dollar spent on tokens produces more than a dollar of value, minimizing cost is not necessarily the objective. He expects the price of a given level of intelligence to fall over time and wants Ramp employees to become skilled at applying it to difficult problems.

His advice to other technology leaders is to watch the rate at which models improve, not just their current abilities. Ramp tries to build for what may be possible three to six months later, he says, because a system designed only around today’s constraints can already be behind when it ships.