Key takeaways
- 30% of merged pull requests now come from Inspect — organic adoption, not mandated
- Agents run in sandboxed VMs on Modal with full access to databases, CI/CD, monitoring
- Multi-modal access: Slack bot, web interface, Chrome extension for visual React editing
FAQ
What is Ramp Inspect?
Ramp's internal background coding agent that runs in sandboxed VMs with full development environment access, responsible for 30% of merged pull requests.
How does Ramp Inspect work?
Agents run on Modal VMs with access to Postgres, Temporal, Sentry, Datadog, GitHub, Slack, and Buildkite. Engineers interact via Slack bot, web interface, or Chrome extension.
What makes Ramp Inspect different?
Full environment access — agents have the same tools as human engineers, enabling them to verify their own work through testing and monitoring, not just write code.
Executive Summary
Ramp Inspect is a background coding agent that has reached 30% adoption for merged pull requests — achieved through organic engineer adoption, not mandates. The key innovation is giving agents full access to the development environment: databases, CI/CD, monitoring, feature flags, and communication tools. Agents don't just write code; they verify their work using the same tools human engineers use.
| Attribute | Value |
|---|---|
| Company | Ramp |
| Type | Internal tool |
| Adoption | 30% of merged PRs |
| Infrastructure | Modal (sandboxed VMs) |
| Public Documentation | January 2026 |
Product Overview
Inspect runs background coding agents in sandboxed virtual machines on Modal. Unlike code-generation-only tools, Inspect agents have access to the full development stack: Vite, Postgres, Temporal, Sentry, Datadog, LaunchDarkly, Braintrust, GitHub, Slack, and Buildkite. This enables a verification loop where agents can run tests, check monitoring dashboards, query databases, and participate in code reviews.
Key Capabilities
| Capability | Description |
|---|---|
| Full environment access | Same tools as human engineers (DB, CI, monitoring) |
| Multi-modal interfaces | Slack bot, web interface, Chrome extension |
| Browser in sandbox | Agents can run browser automation within VMs |
| Multi-repo support | Work across multiple repositories in single session |
| Multiplayer sessions | Teams can watch and guide agent actions in real-time |
Product Surfaces
| Surface | Description | Use Case |
|---|---|---|
| Slack bot | Quick conversations | Simple tasks, Q&A |
| Web interface | Detailed task management | Complex multi-step work |
| Chrome extension | Visual React editing | UI component changes |
Technical Architecture
Ramp's architecture separates control plane (Cloudflare) from data plane (Modal), enabling rapid session startup and unlimited concurrency.
Architecture Overview
Control Plane (Cloudflare)
├── Durable Objects (state management)
├── Conversation context
└── Session coordination
↓
Data Plane (Modal)
├── Sandboxed VMs
├── File system snapshots
└── Instant session startup
↓
Development Environment
├── Vite, Postgres, Temporal
├── Sentry, Datadog, LaunchDarkly
├── GitHub, Slack, Buildkite
├── Braintrust (evaluations)
└── Frontier models + MCP + custom tools
Key Technical Details
| Aspect | Detail |
|---|---|
| Compute | Modal (sandboxed VMs, instant startup) |
| State | Cloudflare Durable Objects |
| Models | All frontier models supported |
| Integrations | Sentry, Datadog, GitHub, Slack, Buildkite, LaunchDarkly |
| Standards | MCP + custom tools + Ramp-specific skills |
Strengths
- Organic adoption — 30% of merged PRs without mandates indicates genuine engineer value
- Full verification loop — Agents verify work through tests, monitoring, and database queries, not just linting
- Browser in sandbox — Enables visual testing and browser automation
- Multi-repo support — Single session can work across frontend and backend repositories
- Multiplayer observation — Teams can watch and guide agents, maintaining human oversight
- Instant sessions — Modal's infrastructure enables near-zero startup time
Cautions
- Build-vs-buy may not generalize — Ramp has strong AI infrastructure expertise; smaller teams may lack resources
- Human review still required — Unlike StrongDM, Inspect doesn't eliminate the review bottleneck
- Model limitations acknowledged — Ramp explicitly states frontier models still hallucinate and require oversight
- Integration investment — Connecting to Sentry, Datadog, LaunchDarkly, etc. required significant work
- Not for sale — Internal tooling only; open-source clone exists but isn't official
Open Source Validation
Cole Murray's "Background Agents" project reimplements Ramp's architecture:
| Component | Implementation |
|---|---|
| Control plane | Cloudflare Workers + Durable Objects |
| Data plane | Modal cloud sandboxes |
| Agent runtime | OpenCode |
| Features | Multiplayer sessions, commit attribution |
GitHub: github.com/ColeMurray/background-agents
This validates that Ramp's architecture is replicable by external teams.
Competitive Positioning
vs. Other In-House Agents
| System | Differentiation |
|---|---|
| Stripe Minions | Both require human review; Ramp has Chrome extension for visual editing |
| StrongDM Factory | Inspect requires review; Factory eliminates it |
| Coinbase Claudebot | Both Slack-native; Ramp has more documented integrations |
When to Reference Ramp Inspect
- Reference when: Building background agents with full environment access
- Study the architecture when: Designing verification loops beyond simple CI
- Consider open-source clone when: Implementing similar patterns without Ramp's resources
Ideal Customer Profile
This is internal tooling, not a product for sale. However, the architecture is worth studying if:
Good fit for similar build:
- Full-stack engineering team (frontend + backend)
- Existing investment in observability (Sentry, Datadog or equivalents)
- Modal or similar sandboxed compute available
- Team culture supports background agent adoption
Poor fit:
- Limited observability infrastructure
- Single-repo, simple CI/CD setup
- No existing Modal/sandboxed compute
- Need visual editing but no React stack
Viability Assessment
| Factor | Assessment |
|---|---|
| Documentation Quality | Excellent (detailed technical spec) |
| Replicability | Good (open-source clone exists) |
| Adoption Metrics | Strong (30% of PRs, organic) |
| Architecture Maturity | High (production-validated) |
| External Validation | Strong (InfoQ, ZenML coverage) |
Ramp's decision to publish detailed technical specifications — including execution environments, agent integration patterns, state management, and client implementation — demonstrates confidence that competitive advantage comes from execution, not architecture secrecy.
Bottom Line
Ramp Inspect proves that background coding agents can reach significant production adoption (30% of merged PRs) when given full development environment access. The key insight: agents need verification capabilities, not just code generation.
Key metrics: 30% of merged PRs, full stack integration, multi-modal interfaces.
Architecture pattern: Cloudflare control plane → Modal sandboxes → full dev environment → verification loop → human review.
Recommended study for: Teams designing background agents with verification loops, infrastructure engineers evaluating Modal for agent workloads.
Not recommended for: Organizations without observability investment, teams seeking to eliminate human review (consider StrongDM's approach).
Outlook: Ramp's open technical documentation and the existence of an open-source clone suggest this architecture will become a reference implementation for background coding agents.
Research by Ry Walker Research • methodology
Disclosure: Author is CEO of Tembo, which offers agent orchestration as an alternative to building in-house.