---
schema: "swft.publication/v1"
id: "company-ramp-inspect"
title: "Ramp Inspect: how a background coding agent became factory infrastructure"
description: "How Ramp Inspect uses agent sandboxes, company context, evals, security and integration pipelines, and human review to produce software."
summary: "Ramp Inspect is an internal background coding agent that works inside a prepared remote development computer. Its important lesson is that the environment, company context, tests, attribution, and human review make the agent useful. Ramp published its architecture, while Inspect itself remains private."
canonical: "https://swft.io/companies/ramp-inspect"
author: "SWFT Editorial"
author_type: "Organization"
published: "2026-09-01"
modified: "2026-09-02"
kind: "case-study"
section: "Companies"
tags: ["Ramp Inspect", "background coding agent", "agent sandbox", "Ramp SWE-Bench", "AI software factory"]
evidence_labels: ["INFERENCE", "OBS", "SELF-REPORT"]
source_ids: ["modal-ramp-inspect", "open-inspect-github", "pragmatic-engineer-ramp-inspect", "ramp-inspect-background-agent", "ramp-inspect-integrations", "ramp-security-fixes", "ramp-sheets-self-maintaining", "ramp-swe-bench"]
authorship_disclosure: "AI-drafted from the cited public sources and independently checked by a second AI editorial-review agent (Codex) for source fit, claim boundaries, overlap, and reader utility. SWFT Editorial is responsible for corrections."
---

# Ramp Inspect: how a background coding agent became factory infrastructure

Inspect pairs a prepared remote development environment with company context, executable feedback, human acceptance, and specialized production lines.

> **Authorship:** AI-drafted from the cited public sources and independently checked by a second AI editorial-review agent (Codex) for source fit, claim boundaries, overlap, and reader utility. SWFT Editorial is responsible for corrections.

## Quick answer

Ramp Inspect is an internal background coding agent that works inside a prepared remote development computer. Its important lesson is that the environment, company context, tests, attribution, and human review make the agent useful. Ramp published its architecture, while Inspect itself remains private.

Ramp's Inspect shows why a capable model is only one part of a useful coding agent. The product became valuable when it gave the agent a prepared company computer, current context, executable feedback, familiar entry points, and a human acceptance path.

## What is Ramp Inspect?

Inspect is Ramp's internal background coding agent. An employee can start work from Slack, a browser extension, a web interface, a pull-request discussion, a mobile device, or a browser-based development environment. The session runs in an isolated remote computer with the services and tools needed to understand, run, and test Ramp's code.

Ramp's [original technical account](https://builders.ramp.com/post/why-we-built-our-background-agent) describes an environment containing application services, databases, a browser, monitoring tools, feature flags, source control, and access to continuous integration (CI), the automated build-and-test process for proposed code. Sessions are multiplayer, so people can watch or steer the same work. The branch is attributed to the employee who requested it, which keeps a person attached to review and acceptance.

## Why did the remote environment matter?

An earlier Inspect product focused on visual editing in the browser. In [operator interviews](https://newsletter.pragmaticengineer.com/p/why-ramp-built-inspect), Ramp leaders said people liked it but did not adopt it widely. The useful version became a full remote development environment that could take work into the background.

That shift changes the product promise. The agent can reproduce a bug, inspect logs, run the application, use a browser, edit code, test the result, and prepare a pull request inside one bounded workspace. Ramp and its [infrastructure provider](https://modal.com/blog/how-ramp-built-a-full-context-background-coding-agent-on-modal) report that these workspaces start in seconds and support hundreds of concurrent sessions.

The transferable term of art is **agent sandbox**: an isolated computer where an agent can act without receiving unrestricted access to the employee's laptop or production systems.

## How did Inspect become a factory platform?

Ramp reused Inspect as the execution layer for narrower production lines:

- A [security pipeline](https://builders.ramp.com/post/100-vulnerabilities-patched-with-0-humans) used detector agents, adversarial judges, a validator that wrote a failing integration test, and Inspect to attempt a repair. Humans reviewed and landed the resulting pull requests.
- [Ramp Sheets](https://labs.ramp.com/research/ramp-sheets-self-maintaining/) generated monitors when code merged. Alerts could trigger reproduction and repair in an Inspect sandbox, with results returned through Slack. Ramp kept trusted human-written monitors because generated ones were not reliable enough to stand alone.
- An [integration agent](https://builders.ramp.com/post/integrations-that-write-themselves) researched an outside API, wrote a fixed, testable provider module, ran tests with protected credentials, and opened an evidence-rich pull request. Ramp reports 75 shipped integrations through that line.

These are closed loops. A signal starts work, specialized steps narrow the problem, an agent changes code, executable checks provide feedback, and a person decides whether to accept the result.

## How does Ramp evaluate Inspect?

[Ramp SWE-Bench](https://labs.ramp.com/swebench) reconstructs 80 tasks from real merged production changes. A run gets one attempt and 45 minutes. Success means the task's failing tests pass without breaking the rest of the test suite. Humans curate the tasks and final acceptance.

This is a production-grounded eval because the work comes from Ramp's own history. The tasks, repository states, prompts, patches, and complete results remain private, so outside readers cannot reproduce the benchmark.

## Is Inspect open source or used by other companies?

Ramp published a detailed blueprint, not Inspect's source code. An independent project called [Open-Inspect](https://github.com/ColeMurray/background-agents) implements a similar architecture under an open-source license. Other teams have described systems inspired by that blueprint and project. This shows that the pattern traveled. It does not show that those companies use Ramp's own Inspect service.

## What can a product team copy?

Copy the environment before copying the interface. A useful pilot needs a fast sandbox, the real application and tests, only the company tools required for the task, clear attribution, and a reviewed path back to the codebase. Then choose one repeated line of work with an observable signal and executable proof.

Ramp's published PR-share figures track where accepted changes began. They do not establish code share, defect rate, causal productivity, completion rate, or the cost of abandoned sessions. Human review remains part of every documented delivery path.

## How we know

- **First-party report (SELF-REPORT)** Ramp describes Inspect's environment, entry points, attribution, specialized security, monitoring and integration loops, benchmark, and adoption. Sources: [Why We Built Our Own Background Agent](https://builders.ramp.com/post/why-we-built-our-background-agent); [We proactively fixed ~100 security issues in 6 days with 0 humans](https://builders.ramp.com/post/100-vulnerabilities-patched-with-0-humans); [How we made Ramp Sheets self-maintaining](https://labs.ramp.com/research/ramp-sheets-self-maintaining/); [Ramp SWE-Bench](https://labs.ramp.com/swebench); [Integrations That Write Themselves](https://builders.ramp.com/post/integrations-that-write-themselves).
- **First-party report (SELF-REPORT)** Modal and The Pragmatic Engineer provide attributable infrastructure and operator-interview detail, including later company-reported scale. Sources: [How Ramp built a full context background coding agent on Modal](https://modal.com/blog/how-ramp-built-a-full-context-background-coding-agent-on-modal); [Why Ramp built its own in-house coding agent, Inspect](https://newsletter.pragmaticengineer.com/p/why-ramp-built-inspect).
- **Observed artifact (OBS)** Open-Inspect is an independent open-source implementation inspired by Ramp's blueprint, not Ramp's code or hosted Inspect service. Sources: [Background Agents: Open-Inspect](https://github.com/ColeMurray/background-agents).
- **Analysis (INFERENCE)** SWFT treats the prepared environment and reusable execution layer as Inspect's most transferable factory pattern. Sources: [Why We Built Our Own Background Agent](https://builders.ramp.com/post/why-we-built-our-background-agent); [Integrations That Write Themselves](https://builders.ramp.com/post/integrations-that-write-themselves).

## Sources

- **First-party report (SELF-REPORT)** [How Ramp built a full context background coding agent on Modal](https://modal.com/blog/how-ramp-built-a-full-context-background-coding-agent-on-modal) — Modal; published 2026-02-19; accessed 2026-09-01. Ramp's infrastructure provider describes Inspect's sandbox contents, startup behavior, concurrent use, and company-reported PR share.
- **Observed artifact (OBS)** [Background Agents: Open-Inspect](https://github.com/ColeMurray/background-agents) — Cole Murray; accessed 2026-09-01. An independent MIT-licensed implementation inspired by Ramp's published Inspect architecture; it is not Ramp's source code or service.
- **First-party report (SELF-REPORT)** [Why Ramp built its own in-house coding agent, Inspect](https://newsletter.pragmaticengineer.com/p/why-ramp-built-inspect) — The Pragmatic Engineer; published 2026-08-25; accessed 2026-09-01. Detailed interviews with Ramp leaders covering Inspect's product history, current scale, team, startup time, handoff patterns, and production-safe debugging context.
- **First-party report (SELF-REPORT)** [Why We Built Our Own Background Agent](https://builders.ramp.com/post/why-we-built-our-background-agent) — Ramp Builders; published 2026-01-12; accessed 2026-09-01. Ramp's technical account of Inspect's isolated development environments, company context, entry points, attribution, and early adoption.
- **First-party report (SELF-REPORT)** [Integrations That Write Themselves](https://builders.ramp.com/post/integrations-that-write-themselves) — Ramp Builders; published 2026-08-14; accessed 2026-09-01. Ramp's account of a specialized Inspect line that researches APIs, writes deterministic provider modules, tests them, and opens evidence-rich PRs.
- **First-party report (SELF-REPORT)** [We proactively fixed ~100 security issues in 6 days with 0 humans](https://builders.ramp.com/post/100-vulnerabilities-patched-with-0-humans) — Ramp Builders; published 2026-02-20; accessed 2026-09-01. Ramp's account of a detector, adversarial judge, failing-test, and repair pipeline. The zero-human claim ends before human PR review and landing.
- **First-party report (SELF-REPORT)** [How we made Ramp Sheets self-maintaining](https://labs.ramp.com/research/ramp-sheets-self-maintaining/) — Ramp Labs; published 2026-03-23; accessed 2026-09-01. Ramp's report on generated monitors, alert-triggered reproduction and repair, retained human monitoring, and engineer review.
- **First-party report (SELF-REPORT)** [Ramp SWE-Bench](https://labs.ramp.com/swebench) — Ramp Labs; updated 2026-06-11; accessed 2026-09-01. Ramp's production-grounded private benchmark of 80 reconstructed tasks, one-attempt scoring, test-based acceptance, and human curation.

## Read next

- [Stripe Minions: how developer infrastructure became an AI software factory](/companies/stripe-minions)
- [How an AI software factory works](/software-factory-architecture)
- [Software factory metrics that matter](/software-factory-metrics)