Building an Internal Background Coding Agent with Full Development Environment Integration

ramp · Finance · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.4 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Internal software engineering automation

Ramp needed a background coding agent that could not only write code but also verify it using the same tools, context, and workflows available to human engineers.

Constraints:

Agents needed full development environments without consuming local checkouts or laptops.
Backend work required tests, telemetry, feature flags, CI, and databases.
Frontend work required visual verification, screenshots, and live previews.
Pull requests had to preserve human review and user attribution rather than letting an app approve its own changes.

Architecture

Ramp built Inspect, a hosted background coding agent. Each session runs in a sandboxed Modal VM with a full Ramp development environment, prebuilt snapshots, frontier models, MCPs, custom tools, and clients across Slack, Chrome, web, pull requests, and hosted VS Code. The sandbox pushes branches and the API opens pull requests using the user's GitHub token so work remains attributable and reviewable.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  builder[Builder] --> inspect-client[Inspect Client]
  inspect-client --> inspect-api[Inspect API]
  inspect-api --> modal-sandbox[Modal Sandbox]
  repository-snapshot[Repository Snapshot] --> modal-sandbox[Modal Sandbox]
  modal-sandbox --> engineering-tooling[Engineering Tooling]
  inspect-api --> github[GitHub]
  modal-sandbox --> github[GitHub]

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Builder`	Ramp employee who prompts, reviews, and collaborates with Inspect.	`Inspect Client`
`Inspect Client`	Slack, Chrome, web, PR, or hosted VS Code interface.	`Inspect API`
`Inspect API`	Coordinates sessions, branch events, and pull-request creation.	`Modal Sandbox`, `GitHub`
`Modal Sandbox`	Isolated full development environment for each coding session.	`Engineering Tooling`, `Repository Snapshot`, `GitHub`
`Repository Snapshot`	Prebuilt sandbox state used for fast startup and follow-up restoration.	`Modal Sandbox`
`Engineering Tooling`	Vite, Postgres, Temporal, telemetry, feature flags, CI, and other Ramp tools.	`Modal Sandbox`
`GitHub`	Pull request and branch system opened with the user's token.	`Inspect API`

Data flow

A builder starts an Inspect session from Slack, browser, web, PR, or hosted VS Code. Inspect spins up a Modal sandbox from a prepared snapshot, uses engineering tools and model/tool integrations to edit and verify code, pushes changes from the sandbox, and has the API open or update a pull request with the user's GitHub token.

“Each session runs in a sandboxed VM on Modal with everything an engineer would have locally”article, stated

“Our setup is to have the sandbox push the changes (updating the git user as previously mentioned), and then send an event to the API with the branch name and session ID.”article, stated

Why this architecture

Ramp chose hosted sandboxes because a coding agent is only useful when it can verify work with the same tools as an engineer. Modal snapshots and warm sandboxes reduce startup friction, while user-token pull requests preserve review boundaries and accountability.

“closes the loop on verifying its work by having all the context and tools needed to prove it, as a Ramp engineer would.”article, stated

“This is strongly preferred over having it open pull requests as the app itself. In the latter scenario, this would allow for any user to approve their own changes.”article, stated

Models used: frontier models · OpenCode

Scale

Inspect wrote about 30% of pull requests merged to Ramp frontend and backend repositories.
“Internal adoption charts have been vertical: ~30% of all pull requests merged to our frontend and backend repos are written by Inspect. It only took a couple months for us to reach this level of usage, and it continues to grow.”article, stated
Inspect reached that adoption level within a couple months.
“It only took a couple months for us to reach this level of usage, and it continues to grow. We didn’t force anyone to use Inspect over their own tools.”article, stated
Repository snapshots keep new sessions at most 30 minutes out of date.
“* This ensures that at most, the repository is 30 minutes out of date * This makes the synchronization with the latest code in the repository much faster, as there’s only up to 30 minutes of changes to sync”article, stated
Ramp tracks users who sent a prompt in the last five minutes as a live activity signal.
“Show these as metrics over time, so you can inspire more growth. A live “humans prompting” count is a good gauge as well, which we base on the number of users that have sent a prompt in the last 5 minutes.”article, stated

Alternatives considered (roads not taken)

Run agents only on local developer machines.

Rejected because: Hosted sandboxes allow unlimited concurrency and avoid tying work to a laptop.

“There’s no limit to how many sessions you can have running concurrently, and your laptop doesn’t need to be involved at all.”article, stated

Open pull requests as the app itself.

Rejected because: That could let users approve their own app-authored changes.

“In the latter scenario, this would allow for any user to approve their own changes. You do not want to knowingly create a vector for unreviewed code to go into the codebase.”article, stated

Start every sandbox cold.

Rejected because: Cloning and installation should happen before the session so time-to-first-token is model-bound.

“Everything else, like cloning and installing, is done before you start your session. When background agents are fast, they’re strictly better than local: same intelligence, more power, and unlimited concurrency.”article, stated

Patterns

`tool-use-orchestration` (coding agents)

Inspect runs tests, telemetry, feature flags, CI, GitHub, Slack, and other engineering tools from its sandbox.

“It’s wired into Sentry, Datadog, LaunchDarkly, Braintrust, GitHub, Slack, and Buildkite.”article, stated

`durable-execution` (runtime)

Modal snapshots preserve prepared and follow-up sandbox state across sessions.

“allow us to freeze and restore state later.”article, stated

`human-in-the-loop-gate` (code review)

Pull requests are opened on behalf of the user and remain subject to review.

“use the user’s GitHub token to call GitHub’s pull request API”article, stated

`observability-tracing` (adoption)

Ramp tracks merged PRs and live prompting as success metrics.

“merged pull requests indicate that the agent is producing valuable work”article, stated

Tradeoffs

Execution environment

Chose Hosted Modal sandboxes over Local checkout execution.

Rationale: Hosted sessions provide isolation, concurrency, snapshots, and full tool access without using the developer laptop.

“same intelligence, more power, and unlimited concurrency”article, stated

Startup strategy

Chose Prebuilt snapshots and warm sandboxes over Cold cloning and installing at prompt time.

Rationale: Startup should feel as fast as local and be limited mainly by model time-to-first-token.

“Warm the sandbox for your session as soon as a user starts to type their prompt”article, stated

Client strategy

Chose Multiple clients where builders already work over A single dedicated web UI.

Rationale: Slack, Chrome, PRs, web, and VS Code support existing workflows and collaboration.

“You can chat with Inspect in Slack and send it screenshots, use the Chrome extension”article, stated

Gotchas (what bit them)

Missing tools cap the usefulness of coding agents.

Root cause: Generated code cannot be trusted if the agent cannot run the same verification loops as an engineer.

Resolution: Give each sandbox the full local engineering environment and integrations.

“Agents should have agency, and so we made sure Inspect is never limited by missing context or tools”article, stated

App-owned pull requests can undermine review controls.

Root cause: If the app opens the PR, users could approve their own changes through the app identity.

Resolution: Use GitHub authentication and the user's token to open PRs.

“You do not want to knowingly create a vector for unreviewed code to go into the codebase.”article, stated

Evaluation

Ramp evaluates Inspect through merged pull request share, adoption over time, concurrent session behavior, session startup speed, and whether agents can verify work with engineering tools.

Metrics: Merged pull request share · Usage growth · Live prompting count · Session startup speed · Verification coverage

“Include your entire organization’s usage, particularly surfacing how many sessions result in a merged pull request.”article, stated

Outcomes

Inspect wrote roughly 30% of merged PRs to frontend and backend repositories.
Ramp reached that adoption level in a couple months without mandating use.
The agent can run full engineering verification in isolated hosted sessions.

The source reports approximately 30% of merged frontend/backend pull requests, adoption within a couple months, unlimited concurrent sessions, and repository snapshots at most 30 minutes stale.

“We didn’t force anyone to use Inspect over their own tools.”article, stated