Building a Custom Background Coding Agent for Production Software Development

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: Background coding agent for production software development

Ramp wanted a background coding agent that could run against its internal codebase, integrate deeply with company tooling, help both engineers and non-engineering builders, and produce pull requests with minimal setup friction.

Constraints:

• the agent needed deep integration with internal and third-party Ramp tooling
• non-engineering builders should not need local setup
• cloud agents must start quickly enough to compete with local development
• large repositories and dependencies make cold starts expensive
• human review still needs to verify quality and stability

Architecture

Ramp built Inspect, a custom background coding agent running on Modal sandboxes. Inspect exposes internal clients such as web, Slack, and Chrome extension surfaces, starts from prebuilt repository snapshots refreshed every 30 minutes, runs the coding agent in cloud sandboxes with Ramp dependencies installed, can spawn child sessions for parallel work, and creates pull requests for human code review.

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

flowchart LR
  user-clients[User clients] --> inspect-api[Inspect API]
  inspect-api --> modal-sandbox[Modal sandbox]
  ramp-codebase[Ramp codebase] --> repo-snapshots[Repo snapshots]
  repo-snapshots --> modal-sandbox
  modal-sandbox --> coding-agent[Coding agent]
  ramp-codebase --> coding-agent
  coding-agent --> child-sessions[Child sessions]
  coding-agent --> pull-requests[Pull requests]
  child-sessions --> pull-requests
  pull-requests --> code-review[Code review]

Components

Data flow

A builder sends Inspect a prompt through one of Ramp's clients. Inspect starts a Modal sandbox from the latest repository snapshot, synchronizes recent changes, runs the coding agent with internal tools and secrets, optionally spawns child sessions, opens one or more pull requests, and leaves final quality approval to code review.

Why this architecture

Ramp built rather than bought because it wanted end-to-end control over internal integrations and data. Modal sandboxes and 30-minute snapshots let cloud background agents approach local-agent startup speed while enabling parallel, no-local-setup use by engineers, PMs, and designers.

Models used: coding agent

Scale

• Inspect was powering about 40% of Ramp's merge pull requests.
  “It's what's powering right now about 40% of our merge poll requests. Uh, it's a project we've been working on for the”transcript, implied
• Ramp refreshes repository snapshots every 30 minutes.
  “So what we do is that every 30 minutes we're actually like cloning all of our repositories uh and then like uh”transcript, stated
• Inspect usually starts a request in 10 seconds or less.
  “So because of that it like end to end like it usually gets started on a request in 10 seconds or less. >> We use functions, snapshots, dict uh and”transcript, stated
• The first Inspect prototype took only a few days.
  “really only took me like a few days to get like a first prototype off the ground. Um and then from there it's just”transcript, stated
• About 80% of pull requests to the Inspect codebase are written by Inspect.
  “>> Yeah, that that's like what are we at there like 80% of pull requests to inspect are written uh by inspect.”transcript, implied

Alternatives considered (roads not taken)

Off-the-shelf background coding agents

Rejected because: Ramp wanted complete control over internal integrations, responses, data, and UX.

Cold-clone repositories for each request

Rejected because: Refreshing snapshots every 30 minutes avoids downloading the full repository on each run.

Single local-computer execution

Rejected because: Cloud execution enables parallel work and avoids the setup burden of running many sessions locally.

Patterns

tool-use-orchestration (agent-design)

Inspect runs inside Ramp's tooling and uses internal and third-party integrations to perform coding work.

batch-offline-processing (operations)

Ramp prebuilds repository snapshots every 30 minutes so agent runs can start quickly.

latency-optimization (operations)

Modal sandboxes and snapshots reduce startup time to seconds and avoid full repository clones per request.

multi-agent-orchestration (agent-design)

Inspect can spawn child sessions to work on multiple pieces in parallel.

human-in-the-loop-gate (operations)

Inspect-generated pull requests still pass through code review for quality and stability.

Tradeoffs

Build versus buy

Chose custom Inspect agent over off-the-shelf background agent.

Rationale: Custom ownership gave Ramp control over internal integrations, data specificity, responses, and UX.

Execution environment

Chose cloud sandboxes with snapshots over single local computer execution.

Rationale: Cloud sandboxes remove setup for users and support parallel work.

Repository preparation

Chose refresh snapshots every 30 minutes over download and install everything at request time.

Rationale: Snapshots reduce cold-start work to recent commits instead of a full clone and install.

Review boundary

Chose human code review after agent-generated PRs over fully autonomous merge.

Rationale: Ramp still wants a quality and stability gate even when Inspect does most of the implementation work.

Gotchas (what bit them)

Cloud background agents start at a disadvantage against local agents.

Root cause: Local agents often already have repositories, dependencies, logged-in apps, warm caches, and running services.

Resolution: Use Modal snapshots, secrets, tools, and prebuilt environments to approximate Ramp-in-a-box.

Coding agents can leave too much verification work for reviewers.

Root cause: Many agents write code but do not fully verify UI, backend behavior, or tests.

Resolution: Design Inspect to run as much verification as possible before opening a PR.

Agent-written code may differ from human style.

Root cause: Agentic tools optimize and express code differently than humans.

Resolution: Adjust codebase expectations so humans and agents can both work effectively in it.

Evaluation

Ramp evaluated Inspect through adoption and pull-request contribution, startup latency, internal builder usage, and the amount of review work still required before merge.

Metrics: about 40% of merged pull requests started by Inspect · about 80% of Inspect-codebase pull requests written by Inspect · startup in 10 seconds or less · snapshots every 30 minutes · human code review quality and stability

Outcomes

• Inspect starts requests in 10 seconds or less using Modal sandboxes and refreshed snapshots.
• About 40% of merged Ramp pull requests are started by Inspect.
• Product managers and designers can ship smaller features without local engineering setup.
• Inspect can spawn child sessions for parallel work.

Ramp reports about 40% of merged PRs started by Inspect, snapshots every 30 minutes, startup in 10 seconds or less, and roughly 80% of Inspect-codebase PRs written by Inspect.