# Replicas V1: The end-to-end background coding agent

A deep dive into Replicas V1, Environments, and next steps.

- Author: Connor Loi
- Published: 2026-03-18
- Category: Product launch
- Canonical: https://tryreplicas.com/blog/replicas-v1


Recently, Stripe and Ramp released blogs outlining their in-house background coding agents. 

For Replicas, it was proof that autonomous coding agents, when given proper environments and tooling, could be relied on to *write and test production-ready code*.

The idea that Claude Code or Codex could write tons of code for software engineering teams is not a new concept. LLMs have been used to accumulate slop for several months.

So, **what has changed?**

# Autonomy in Agents

Coding models are becoming more autonomous every day. They are being optimized for longer-horizon tasks - working on software engineering problems for hours, potentially days. They are also getting dramatically better at using filesystems and bash, executing actions on a computer by themselves.

Today, the biggest difference between Claude Code or Codex in a sandbox (which we've already built) and a capable software engineer is **environments**.

Think about how software engineers work: they code, test iteratively, and solve. At Replicas, we test by running a dev environment locally - database, backend, and frontend - we write the code and try it out for ourselves. Opening a browser, clicking around, and verifying behaviour.

Thus, in order to make a background coding agent that can build and verify its work end-to-end, we must give it the same environments we give our engineers.

## Proof in Production
The background coding agents at Stripe, Ramp, and Coinbase are incredible. These companies ship extremely sensitive code - payments infrastructure requires stupidly high stability. The fact that they ship even 10% (Stripe) of their code with background coding agents, let alone 50% (Ramp), is...magical.

They were able to do this because they invested in building in-house background coding agents tuned to their development stack. They gave agents the same tools, environments, and context that a Ramp or Stripe engineer would have.

So the question becomes: how do we bring this to everyone else?

This is Replicas V1.

# How Replicas V1 Works

<video controls playsinline style="width: 100%; border-radius: 8px;">
  <source src="https://mxeqiomwgdgaesecwtct.supabase.co/storage/v1/object/sign/docs-assets/videos/Replicas_V1_Launch.mp4?token=eyJraWQiOiJzdG9yYWdlLXVybC1zaWduaW5nLWtleV8yMzJlY2QyZC1lNzc1LTQxM2MtYTBlMC05ZmU4YzIwMzM3NWEiLCJhbGciOiJIUzI1NiJ9.eyJ1cmwiOiJkb2NzLWFzc2V0cy92aWRlb3MvUmVwbGljYXNfVjFfTGF1bmNoLm1wNCIsImlhdCI6MTc3MzUwNzE2OSwiZXhwIjoxODM2NTc5MTY5fQ.V76ACB0vqhkDGSDm-hysmv3uem3XPatKhnaCFiY3dFg" type="video/mp4" />
</video>

The core idea is simple: give coding agents a real development environment and let them form their own feedback loops. Build, test, fix, test, until done. Just like an engineer on your team would.

We have a set of core beliefs for a good background agent:
- *A background agent must be **accessible***.
- *A background agent must be **responsive***.
- *A background agent must be **customizeable***.
- *A background agent interacts through **natural language***.\*

\**This seems obvious, but the idea is that it is easy to make users click buttons and menus to get the agent to do something. But a properly designed background agent should just "work" from your sentences.*

All of our design decisions flow from these principles.

## Lives where you live
> *A background agent must be **accessible***.

The Linear and Slack integrations were the first things I ever built. Since the beginning, Replicas has and always will be designed to respond and chat with where your team is.

It should be **effortless** to delegate to Replicas.

<img src="/blog/replicas-v1-slack.png" alt="Replicas Slack integration" style="display: block; margin: 0 auto; width: 75%; border-radius: 8px;" />

<img src="/blog/replicas-v1-linear.png" alt="Replicas Linear integration" style="display: block; margin: 0 auto; width: 75%; border-radius: 8px;" />

## Sandboxing and Warm Pools
> *A background agent must be **responsive***.

You should not have to wait more than 30 seconds (honestly, 10 seconds) for Replicas to respond. The largest advantage for agents is that they do not sleep. 

When you give Replicas a task from Slack, it always responds within 15 seconds. As we continue refining our infrastructure, we want to keep it to 5 seconds.

We do a lot of work to make this happen:
- **Warm pools**: Execute as much as possible on the VM beforehand
- **Sandboxing**: We use Daytona sandboxes, and can often start our custom image sandboxes in less than 200ms.

```mermaid
flowchart LR
    Start[Task Received] --> Check{Warm Pool?}

    Check -- Yes --> Claim[Claim Ready Sandbox]
    Claim --> Wake[Wake + Sync Repos]
    Wake --> Creds

    Check -- No --> Create[Create Sandbox]
    Create --> Setup[Clone Repos + Install Skills + Upload Files]
    Setup --> Creds

    Creds[Write Credentials + Env] --> StartHooks[Run Start Hooks]
    StartHooks --> Ready[Engine Ready]

    subgraph pool["Warm Pool"]
        P1[Create Sandbox] --> P2[Clone Repos + Install Skills]
        P2 --> P3[Upload Files + Run Warm Hooks]
        P3 --> P4[Sleep in Pool]
    end

    P4 -.-> Claim
```

## Environments
> *A background agent must be **customizeable***.

With V1, we introduced **Environments**, which was essentially several ways to configure how the agent's dev setup is ahead of time.
- **Environment Variables**
- **Files** (`.env` files, `config.json`, etc.) 
- **Skills** (`agent-browser`, `react-best-practices`)
- **Warm and Start hooks** - shell commands on startup

With these configuration options, any codebase that can run "locally" can be made ready out-of-the-box for the coding agent. We also support multiple repos per sandbox.

<img src="/blog/replicas-v1-environment.png" alt="Replicas environment configuration" style="display: block; margin: 0 auto; width: 75%; border-radius: 8px;" />

## Autonomy (Again)
> *A background agent interacts through **natural language***.\*

Every codebase, team, and workflow is different. As much as possible, you should be able to explain to Replicas how to do common actions just as you would a human:
- *"Can you look at Greptile's review comments on the PR? Are they valid?"*
- *"Test your work by opening the frontend in a browser and using the feature."*
- *"Take a screenshot and show me what you added."*

And our favourite one:
- *"Can you make a preview so I can try it out?"*

### Previews

Replicas agents can expose previews of running services. This means you can view a web app (running on the code changes made by Replicas) on their port 3000 from your own computer and interact with it. The agent can verify its own frontend work visually, and so can you.

<img src="/blog/replicas-v1-previews.png" alt="Replicas live previews" style="display: block; margin: 0 auto; width: 75%; border-radius: 8px;" />

This is designed to work entirely on natural language. We created and install a `replicas-agent` skill by default, which teaches the agent how to:
- Run services as persistent, background processes
- Use the `replicas preview` command

The skill also guides agents to fix issues with *cross-service references*.

Consider a web app that runs client-side, and makes a backend request to `localhost:8787`. Replicas will naturally:
- Create a preview for `localhost:3000` at `3000-{workspaceId}.replicas.dev`
- Change the `.env` (or however you set it up) so it points to `8787-{workspaceId}.replicas.dev`
- Create a preview for `localhost:8787`...

# What's Next

We've started building Replicas V2, with a renewed focus on improving Replicas' performance on long, complex engineering tasks. We're continuing to push on speed, environment fidelity, and deeper integrations into the tools your team already uses.

If you're an engineering team that wants a background coding agent that actually understands your stack - founders@replicas.dev

# References

- [Why We Built Our Background Agent](https://builders.ramp.com/post/why-we-built-our-background-agent) - Ramp
- [Minions: Stripe's One-Shot End-to-End Coding Agents](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents) - Stripe
- [Minions: Stripe's One-Shot End-to-End Coding Agents (Part 2)](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents-part-2) - Stripe