Somewhere in the Slack channels of a handful of Y Combinator-backed startups, engineers are treating AI the way they'd treat a junior developer: with an @ mention, a ticket assignment, and reasonable expectations that something useful will come back.
The difference? The entity on the receiving end isn't checking messages between meetings. It's Replicas, a fledgling tool that spins up isolated virtual machines, runs through coding tasks autonomously, and opens pull requests—no hand-holding required. According to the company, some early customers report these background agents contributing north of 30% of their merged code—a self-reported figure with no independent verification. That's a bold claim, and one worth unpacking.
Replicas emerged from stealth in April 2025, the work of Connor Loi and Saai Arora, engineers with stints at Ramp, Shopify, and IBM. Their pitch is deceptively straightforward: stop thinking of AI as an autocomplete tool and start thinking of it as something that can take an entire task off your plate. Not a copilot whispering suggestions as you type—more like a contractor who works overnight shifts in a sandboxed corner of your codebase.
The timing is deliberate. We're in the middle of what feels like a Cambrian explosion for AI-assisted development. Cursor shipped its agent-first interface in early April. Anthropic's Claude Code added scheduling and remote features earlier this spring. Perplexity launched an enterprise background agent in mid-March. The infrastructure is proliferating faster than anyone can reasonably keep track of, and Replicas is positioning itself as the turnkey option for teams that don't want to reinvent the wheel.
The Technical Wager
Here's where Replicas diverges from the crowded field: the sandboxed virtual machine. When an engineer assigns a task—by mentioning @tryreplicas in a GitHub issue, say, or routing a Linear ticket to the integration—the system doesn't just generate code and call it a day. It clones repositories, installs dependencies, spins up a working environment. The agent (Claude or Codex, using the customer's own API keys) can fire up databases, run test suites, iterate on failures. Only then does it open a pull request.
This isn't a thin wrapper around an LLM. Replicas maintains what it calls Environments—configurable setups that include secrets, system prompts, files. Teams can keep a pool of pre-warmed VMs (five by default) to dodge cold-start delays. The company's changelog, updated nearly daily through May, reads like a product being stress-tested in real time: snapshot improvements, Slack DM support, the addition of Opus 4.7 with its 1-million-token context window.
The integrations sprawl across the tools developers already use. In Slack, you can summon Replicas in channels, DMs, or threads. It's thread-aware, and you can specify environments inline with syntax like [env:production]. Linear users can assign issues directly to the bot, which spins up a workspace and cleans up when the issue closes. GitHub users trigger agents via comments, and Replicas will auto-respond to CI/CD failures on linked PRs. There's a CLI for terminal purists, a REST API for custom builds, and an Automations feature that runs agents on schedules (minimum one-hour intervals) or in response to webhooks, Slack pings, Sentry alerts.
The system even supports PR attribution via OAuth, so commits appear under a team member's name instead of a faceless bot account. A small detail, perhaps, but one that suggests the founders understand how code authorship works in practice.
The 30% Question
Now, about that headline number.
Replicas says it's being used by more than 20 YC startups—another self-reported figure from the company's Launch YC post, offered without external verification. The homepage goes further: "Engineering teams use Replicas to ship over 30% of pull requests." In a LinkedIn video posted around launch, Loi said the tool is internally responsible for over 70% of the company's own PRs and has "shipped thousands" for customers.
These figures are unverified, with no methodology disclosed or independent audit provided. But they fit a pattern that's harder to dismiss. Ramp's internal agent, Inspect, reportedly handles 60% of merged PRs at the payments company. Stripe's Minions project—detailed in a blog series earlier this year—merges over a thousand PRs weekly. The infrastructure for background agents is being built at scale, whether we're ready for it or not. Replicas is betting it can package that capability for teams without the resources to roll their own.
Still, the 30% claim deserves skepticism. Are we talking simple bug fixes or meaningful feature work? How much of that code requires substantial rework before merging? The company hasn't said, and those details matter if we're trying to gauge whether this is a productivity multiplier or just automated busywork.
What's Inside
Under the hood, Replicas supports Model Context Protocol (MCP) servers at the environment level, letting teams connect external tools and data sources. Skills can be installed via a skills.sh directory—a Unix-y touch that will feel familiar to DevOps types. Secrets are encrypted at rest and can sync from Infisical or Doppler. The system's "warm hooks" and snapshotting are designed to shave latency off the process of spinning up an agent mid-task.
The company recently started offering forward-deployed engineers for Team and Enterprise customers. That's a telling move. It suggests that onboarding these systems isn't as plug-and-play as the landing page might imply, that there's still friction between the promise and the practice.
The documentation is sprawling—GitHub, Slack, Linear, CLI workflows, API endpoints, Automations. Breadth over simplicity, which could be either a strength or a liability depending on how quickly the product matures.
Pricing and the Opacity Problem
Replicas offers a free Hobby tier with 20 credits monthly. The Developer plan runs $50 per month for 100 credits and a dedicated Slack support channel. Team plans start at $150. Enterprise plans offer unlimited credits and custom configurations. Credit packs are available separately: 30 credits for $15, 100 for $70, 250 for $150.
But here's the rub: the company hasn't disclosed what a credit actually buys in compute time. That makes cost estimation difficult, which is frustrating for teams trying to model whether this makes financial sense at scale. It's a common SaaS playbook—abstract the pricing to smooth out usage spikes—but transparency would help.
A Crowded Playing Field
Replicas is hardly alone. Cursor 3 just shipped agent-first features. Anthropic keeps iterating Claude Code. Open-source projects like OpenCode saw rapid adoption earlier this year. The infrastructure layer is fragmenting too—SuperHQ offers competing microVM sandboxes, and analysts like Ona are already mapping out the need for multi-agent parallelism and better memory architectures. Problems Replicas will need to solve if this scales.
The company lists a Founding Engineer position in San Francisco on the YC company directory, with a salary range of $150,000 to $250,000 and 2–4% equity. Third-party databases list a convertible note round involving Pioneer Fund, though Replicas hasn't publicly announced funding. YC's directory shows a team size of one, while LinkedIn lists 2–10 employees—a discrepancy that's probably just stale data, but worth noting.
The Bigger Question
Whether background coding agents become a category or just another feature in your IDE remains unclear. What's clear is that Replicas is making a specific bet: that engineering teams want agents they can invoke from the tools they already use, that operate in real development environments, and that produce reviewable pull requests instead of inline autocomplete suggestions.
The 30% PR figure is ambitious. Maybe it's marketing gloss, maybe it's the start of something that reshapes how software gets written. Either way, it's hard to look away.
If those numbers hold—if agents really can shoulder a third of the workload at growing startups—then we're not talking about a productivity tool. We're talking about a fundamental shift in how engineering teams are structured and what they optimize for. And that's a story worth watching, even if the details are still coming into focus.
