The architecture behind VibeGrow
One level up
Software has moved from punch cards → assembly → C → Python → English.
Engineers who used agents to write features and fix bugs now build systems that get agents to do those things autonomously. These systems are called software factories. Done for marketing, it is a marketing factory.
We build the business factory: agent swarms that run your business.
It's already happening in the market:
- Stripe: its agents merge 1,300+ pull requests a week. Humans only review.
- Ramp: its background agent writes about 75% of merged PRs, up from about 30% when Ramp first wrote about it in January 2026.
- Shopify: its Slack agent River coauthors 1 in 8 merged pull requests. About 6,000 employees used it in one 30-day stretch.
- Klarna: runs marketing campaigns and image production with AI, cutting marketing spend by about $10 million a year (2024) while producing more.
Stripe, Ramp and Shopify each spent a platform team and many months building this in-house, on systems that took years.
Everyone else is still prompting one agent at a time. The bottleneck is starting the work and giving it the proper runtime, governance, access, tracking, and approval flow. That is what we build.
This post is about how these systems are built. It covers what a factory needs, how Stripe, the labs and the open-source projects each built theirs, and how we built VibeGrow so you can have the same thing with the most freedom, the most control and the most output.
What a factory needs
Take the list from above one item at a time. Each one is a piece of architecture somebody has to build.
| A factory needs | What that means | How VibeGrow does it |
|---|---|---|
| Trigger | Work begins without a person typing a prompt each time | A message or a schedule becomes a job in the same durable queue |
| A runtime | Agents run for hours, in parallel, and a crash does not lose the work | A runner holds the agent loop and drives a separate sandbox. A dead runner costs one run and the session carries on |
| Access | Agents use your tools and logins without holding your keys | Keys stay with the runner and the control plane. Third-party APIs go through a proxy. The browser is your own Chrome |
| Guardrails | Rules you set once that hold for every run: who runs what, on which model, with which tools | Every session is bound to one tenant, user, harness and auth connection. Each harness's built-in tools are replaced or denied |
| Tracking | A record of what ran and what it cost | Every job has its own run, events and cost |
| Sign-off | A person says yes to one specific action before it happens | Agents prepare the work and ask for sign-off where you set it. Connecting your browser is an explicit step |
The rest of the post goes through these in detail. First, how everyone else builds the same thing.
How these systems are built
The first design choice is where the agent runs.
Most agent products today run the agent inside the computer it works on. Dot, Bot, Muse, Instinct and more.
The harness, the tools, the browser and the user's files, all share one machine.
Sometimes that machine is your laptop or the Mac mini you bought during the hype. Other times it is a cloud VM the vendor rents for you.
Some add a vault so the model never sees your passwords, but the harness still runs on the same machine where its commands execute.
We built VibeGrow differently. The agent loop lives in a trusted runner. The computer the agent works on is a separate sandbox that the runner drives over RPC.
The sandbox holds no model key nor any platform credentials. It doesn't have any program of its own. It simply runs the commands it gets from the agent outside and returns the output.
The sections after the comparison explain how that works and why we chose it.
Agent inside the box. The harness runs on the same machine as the tools. When the model asks to run bash, the harness runs it locally.
Unless the product adds a vault or proxy, credentials sit in environment variables or config files on that machine, because the harness needs them.
Agent outside the box. The harness runs somewhere trusted. Tool calls are serialized and sent to a sandbox, which executes them and returns the result. Credentials stay with the harness or behind a proxy.
Below, the same agent runs both ways. Send a normal request first. Then send a poisoned page: the agent fetches a page that carries an injected instruction, the model obeys it and asks the tools to read the credentials file.
Background agents compared
There are two ways to read this comparison. If you run a business, you care about what work gets done, who has to start it, and what you still have to build. If you run the platform, you care about where the agent runs and where the keys sit. Both tables are below, then a closer look at each design.
If you run the business
| Option | What it does for you | How the work gets done | Models | What is left for you to build | A good fit when |
|---|---|---|---|---|---|
| VibeGrow | Engineering and growth work: code, SEO, content, video, ads | Agents run in the background, from a message or on a schedule. They prepare the work and ask for sign-off where you set it | Pi, Codex or Claude, on subscriptions you already pay for | Your goals and your approval rules | You have an engineering or growth team and no platform team |
| AI teammates: OpenAI Dots, Claude Duet, Grok Bot, Meta Muse, Instinct | Help one person with their own tasks: inbox, briefs, research, browsing | Always on for the person who owns it. It asks before it sends, pays or deletes | The vendor's own. Grok Bot: Cursor picks the model | Nothing, but every employee runs their own | You want an assistant for each person and one vendor is fine |
| Engineering agents: Codex cloud, Devin, Factory, Vorflux | Coding tasks: features, fixes, pull requests | You hand over a task and a pull request comes back | Varies by product | Nothing for code. Everything outside code | Your bottleneck is code and nothing else |
| Infrastructure: Coder Agents, Claude Managed Agents, Rerun, OpenClaw | A place to run agents | Whatever you build on top of it | Coder and Rerun: any provider. Managed Agents: Claude | The agents, the workflows, the approvals and the tracking | You have a platform team and want to own the stack |
| Build in-house, as Stripe, Ramp and Shopify did | Exactly what your company needs | However you design it | Any | Everything. A platform team, and months of work | You are that size and can staff it |
If you run the platform
Fourteen designs, ours included, built from what each vendor publishes. Vendors publish different amounts. OpenClaw, Stripe, OpenAI Codex, Coder and Anthropic Managed Agents document their designs. Meta, xAI, OpenAI Dots, Claude Duet and Greptile publish part of theirs. Instinct publishes no architecture.
| Design | Where the loop runs | The box | Credentials | Browser | Hosting |
|---|---|---|---|---|---|
| VibeGrow | A runner container, outside the sandbox | Modal sandbox, started on the first tool call | Runner and control plane; third-party APIs through a proxy | Your own Chrome, paired through an extension | Hosted (Cloudflare and Modal) |
| OpenClaw | Your machine, next to the Gateway | Your machine | Same machine as the tools | On your machine | Your own machine; open source |
| Stripe Minions | Inside the devbox | EC2 devbox, ready in about 10 s | Isolation: no production data, no arbitrary outbound network | Not described | Internal to Stripe |
| OpenAI Codex cloud | Inside the task container | Container per task | Setup secrets only, removed before the agent phase | None; internet off by default | Hosted by OpenAI |
| Meta Muse | On its dedicated VM | The same VM | Secure storage; used without being seen | Its own, on the VM | Hosted by Meta |
| Rerun | Inside the engine container | Engine container per workspace | On the engine disk, next to the tools | Inside the engine container | Self-hosted; open source |
| OpenAI Dots | Not published | Cloud computer, one per dot | Encrypted credential service; not shown to the model | Chrome on the dot's computer | Hosted by OpenAI |
| Claude Duet | Not published | Agent machine | Kept off the agent machine; a proxy swaps in real values | A separate browser VM | Hosted by Anthropic |
| Grok Bot | Not published; runs on Cursor's cloud | One hosted computer per member, shared by their Bots | OAuth tokens on a connector backend; sign-ins persist on the computer | On the hosted computer | Cursor's cloud, US only |
| Greptile TREX | Not published | Fresh instance per review | Rotated before each run | None | Hosted by Greptile |
| Instinct | Not published | "A phone and computer", no detail | Not documented | Not published | Hosted |
| Coder Agents | The Coder control plane, outside the workspace | Workspace, provisioned only when needed | LLM credentials in the control plane only | None | Self-hosted only |
| Anthropic Managed Agents | Anthropic's servers, outside the sandbox | Sandbox, started only when needed | Vault and proxy; never in the harness or the sandbox | None built in | Hosted by Anthropic |
| Self-hosted Managed Agents | Your server, outside the sandbox | Your container or pod per session | Inference credential on the server only | None built in | Your infrastructure, by request |
A closer look at each design
Every figure uses the same layout, so you can compare them by eye: keys on the left, the agent loop at the top, the tools below it, the model on the right. The green box is the computer the agent works on. If the loop is drawn inside the green box, the agent runs inside the box.
Agent loopTool executionModelCredentialsProxy or checkThe boxDashed loop: location not published
OpenClaw
A personal agent you run yourself. The Gateway, the loop with its keys, and your shell and files sit on one machine you keep on.
- Good at: No hosting bill, full control, your own logins.
- Trade-off: It stops when the machine sleeps, and anything the agent runs can reach the keys.
Stripe Minions
An internal coding agent. Each task gets a pre-warmed devbox that holds the harness and the source code.
- Good at: The simplest design. Full permissions with no prompts, and identical boxes are easy to pre-warm.
- Trade-off: Every task gets a box. It is built for trusted internal users.
OpenAI Codex cloud
The agent runs inside a container created for the task, with your repo checked out.
- Good at: A simple model, and secrets are gone before the agent runs.
- Trade-off: Harness and box share the container, and every task gets a box.
Meta Muse
A consumer agent with a dedicated VM that holds both the agent and the person's data.
- Good at: A dedicated machine, credentials hidden from the model, and an independent watcher.
- Trade-off: The agent and its tools share one machine.
Rerun (open source)
An always-on agent workspace. One engine container per workspace runs the loop and every tool.
- Good at: One container to run, many model providers, open source.
- Trade-off: Model credentials sit on the disk the tools use.
OpenAI Dots
An always-on agent. Each dot has its own cloud computer that keeps running.
- Good at: Each dot keeps working on its own computer, and actions pass a separate review.
- Trade-off: Where the loop runs is not published. OpenAI models only.
Claude Duet
An always-on agent in research preview. The browser and the credentials are kept off the machine the agent works on.
- Good at: The browser and the credentials are kept off the agent machine.
- Trade-off: A research preview. You cannot watch the browser yet.
Grok Bot
Always-on agents from xAI that run on Cursor's cloud, one hosted computer per member.
- Good at: Logins stay in place between tasks, and OAuth tokens stay off the computer.
- Trade-off: All of a member's Bots share one computer and its sign-ins.
Greptile TREX
A code reviewer that runs the real code to prove a finding. One agent per issue worth checking.
- Good at: Parallel per issue, fast boxes from snapshots, and the box is thrown away after each review.
- Trade-off: Event-driven only, and built for one job.
Instinct
A consumer assistant you text or call. Its site says it "can use a phone and computer in the same way that you do" and publishes no architecture, so there is nothing to draw. Source: site
Anthropic Managed Agents
The harness runs on Anthropic's servers and calls the sandbox like any other tool.
- Good at: A stateless harness that resumes from the session log, and faster first tokens.
- Trade-off: Claude only, through Anthropic's harnesses.
Self-hosted Claude Managed Agents
The same service on your own infrastructure, by request through Anthropic.
- Good at: The loop and the data stay inside your network.
- Trade-off: You run and secure the server. Some features exist only on the hosted service.
Coder Agents
Self-hosted coding agents. Coder moved the loop out of the developer workspace and into its control plane.
- Good at: No LLM keys in workspaces, any provider, fully self-hosted.
- Trade-off: You operate it. Workspace network access is open unless the template restricts it.
VibeGrow
A small runner holds the harness and the keys. The sandbox starts on demand and holds neither.
- Good at: Three harnesses, including on your own subscription. Chat-only turns start no box. Keys stay out of the box.
- Trade-off: The runner is held for the whole run, mostly waiting on tokens. More moving parts than one machine.
None of these designs is wrong. Stripe's choice makes sense for Stripe: an internal coding agent, in a devbox with no production data and no open internet, can run with full permissions and no prompts. The blast radius is small by construction.
Our situation is different. VibeGrow runs agents for many customers. Those agents run arbitrary shell commands, install packages, open untrusted web content and read files customers upload. A prompt injection in a scraped web page should not be one cat ~/.config away from a model key or a customer's Claude subscription.
Anthropic described the same move in Scaling Managed Agents: Decoupling the brain from the hands. Their harness used to run inside the container. They moved it out, and every "hand" became a call shaped like execute(name, input) → string. We arrived at a similar shape for similar reasons.
There are two differences, and one of them is a cost to us.
- Harnesses. Managed Agents serves Claude through Anthropic's own harnesses. VibeGrow runs three harnesses: Pi, Codex and Claude, including on a customer's own Codex or Claude subscription. All three drive the same hands.
- State. Anthropic's harnesses are stateless, so nothing in the harness needs to survive a crash, and credentials stay in a vault behind a proxy, outside the harness. Our runner is a live container for the whole run, and it holds the credentials its loop needs. That is the price of running harnesses that ship as long-lived processes.
What makes VibeGrow suited for your business
You want what Stripe, Ramp and Shopify built, without hiring the platform team. Three things decide whether a platform gives you that.
Freedom. You are not tied to one lab.
- Run Pi, Codex or Claude, on a Codex or Claude subscription you already pay for.
- Each harness keeps its own loop. Adding another one means writing an adapter for it.
- Your sessions, files and history live in the control plane. They do not sit inside one vendor's product.
Control. You decide what the agents can touch.
- The sandbox can run anything a web page talks it into, and there is still no model key or platform credential in it to steal.
- Agents prepare the work and ask for sign-off where you set it.
- The browser is your own Chrome, and connecting it is your choice.
- For any session, exactly one place decides what happens next.
Output. The work keeps moving when nobody is watching.
- Jobs start from a message or a schedule, and new ones queue while the agent is busy.
- Every session has its own runner and sandbox, so many run side by side.
- A crashed box can cost the run in flight. It does not cost the history, the files or the queue.
- A computer starts only when the work needs one. A question that needs no tool never starts a sandbox.
The three tiers
VibeGrow has three tiers. Each one has a single job.
Our decision record puts it in one line: Cloudflare is the durable control plane. Modal is the isolated execution plane.
1. Control plane: state, order and identity
The control plane never runs a model. It owns the state that has to survive a crash.
A stateless edge Worker authenticates the request and forwards it to a Session Durable Object. There is one per session, and it orders everything for that session: jobs, events, deliveries, connected browsers and the runner lease. Its state lives in the Durable Object's own SQLite. While recoverable work remains, it keeps an alarm armed so it can recover what a dead runner abandoned. An idle session holds no alarm.
D1 holds cross-session lookups, such as the sidebar list and job-to-session routing. It never holds conversation history. R2 holds uploads, harness checkpoints, skills, archived workspaces and encrypted per-user secrets.
Keeping state in a Durable Object gives us one property we lean on everywhere: for any given session, exactly one place decides what happens next.
2. Runner: the brain
The runner is a container on Modal. It runs the agent loop for whichever harness the session uses, and it holds the credentials that loop needs.
We put the loop here, and not in the Worker, for practical reasons. Codex and Claude Code ship as real processes: an app-server binary and a CLI. They want a filesystem for their own state, long-lived child processes and more memory than a Worker isolate provides. A container gives them that without letting them touch the customer's workspace.
The runner holds one lease per (tenant, user, session). While it holds the lease, it is the only process allowed to act for that session.
3. Sandbox: the hands
The sandbox is a Modal Sandbox with Node, ffmpeg, git, poppler and a few vendor CLIs installed. Each session gets a persistent volume mounted at /workspace.
It receives no Modal secrets and no model key. Its entrypoint creates the workspace directory and then waits:
mkdir -p /workspace && tail -f /dev/null
Everything else arrives as a call from the runner: run this command, read this file, write that one, copy this upload in. There is no agent loop in the sandbox to hijack. The model can still be fooled, as the first demo shows. What changes is what a fooled model can reach.
Sandboxes are also created lazily. A model-only turn skips the computer entirely. A tool call, a skill that needs files, or a recovery step starts one. Anthropic reported that the same split, which lets a session skip sandbox startup, cut their p50 time-to-first-token by roughly 60%. That is their number, not ours.
Making three different harnesses use the same hands
VibeGrow supports Pi, Codex and Claude. Each harness has its own built-in tools, and each assumes those tools run locally. Our job is to keep the harness's native loop while replacing its hands.
All three talk to the sandbox through one interface, SandboxProvider: exec, readFile, writeFile, listFiles, copyIn. In the runner, that interface calls a small local driver, which calls the Modal SDK.
Pi runs in the same process. We swap its read, write, edit and bash tools for versions that call the sandbox.
Codex runs its pinned app-server as a child process with the shell and unified exec disabled, web search off and network access false. Its working directory is empty and private. File and command tools come from a local MCP server that forwards to the sandbox.
Claude runs through the Agent SDK. Its built-in file and shell tools are aliased to an in-process MCP server. The config is strict (strictMcpConfig: true, no setting sources). A canUseTool hook allows Claude's task-tracking tools and an AskUserQuestion the user has answered, and denies every other native tool:
return { behavior: "deny", message: `Hosted Claude cannot use native tool ${toolName}.` };
The harness asks to edit a file, and the edit happens in a different container. Nothing in the harness's loop has to change.
Where the credentials live
Moving the loop out of the sandbox only helps if the credentials move with it. Most of them do. The last two rows are the exceptions, and they are narrow on purpose.
| Credential | Where it lives | What the sandbox sees |
|---|---|---|
| Platform model key (Pi) | Runner secret, written to an owner-only directory in the runner | Nothing |
| A user's own Codex or Claude subscription | Encrypted at rest in R2; decrypted by the coordinator after an ownership check; delivered to the runner inside the lease; refreshed through the coordinator | Nothing. The runner also redacts tokens from streamed output and errors |
| Third-party APIs (ads, media generation) | OAuth tokens held by a self-hosted Nango instance and the runner | A short-lived job token and the URL of a runner proxy, which swaps in the real token |
| Blob storage | Coordinator | Per-operation signed capabilities, 5-minute maximum TTL |
| Secrets for a few integration CLIs (for example, Shopify) | Stored per user, released by the runner for one allowlisted command | That secret, for that one command; output is redacted and temporary config is cleaned up |
The proxy row is the same idea as Anthropic's git proxy for Claude Code on the web: the sandbox holds a scoped stand-in, and a trusted component checks the request and attaches the real token on the way out.
One request, end to end
Here is what happens when someone types a message.
- Commit before anything else. The Durable Object writes the job, the message, a receipt and a delivery row before it does any work. Every submission carries a
submissionId. A retry with the same ID replays the stored receipt. A different body under the same ID gets a409. - Find an owner. If a warm runner already owns the session, the job goes straight down its socket. Otherwise the Durable Object publishes to a Queue, and an always-warm trigger function spawns a session runner.
- Lease. The runner opens one WebSocket to the Durable Object and accepts the offer. The lease carries the run ID, the event cursor, uploads, skills and the sandbox to attach to.
- Run. The runner restores the harness checkpoint and starts the turn. Tool calls go to the sandbox. Events stream back in acknowledged, deduplicated batches, and the Durable Object fans them out to every connected client.
- Complete. The runner uploads its checkpoint to R2 and sends
completewith a reference. Checkpoints never travel inside socket frames; an inlined one once ran a Worker isolate out of memory. - Stay warm or leave. A warm owner picks up the next queued job over the same socket, with no Queue hop and no new container. When idle, it releases the lease.
Why the runner stays warm
Step 6 is the newest part of the design. In our first version, every message got a fresh runner: spawn a container, restore the checkpoint, do the work, exit. That is simple and safe, but people rarely send one message. They send a burst, read, and send another.
Now a runner owns the whole session, not a single job. After a turn it asks the Durable Object for the next queued message and runs it on the same harness session and the same sandbox. It lets go after five idle minutes. Each job still gets its own lease, run, events and cost.
Every message on that socket is fenced by owner epoch (a counter that goes up each time a session changes owner), job, run and token. A runner from an old epoch cannot complete a job it no longer owns.
Steering and queued messages
People also correct themselves mid-run.
A new message sent while the agent is busy normally becomes its own job in a FIFO queue. The runner picks it up when the current turn ends.
A correction aimed at the running turn takes a different path. The Durable Object saves it in the submission receipt first. The runner then has two seconds to deliver it into the harness's native input, using priority: "next" for Claude. The client sees one of three outcomes: accepted, rejected or unconfirmed.
unconfirmed is the hard case. The message may or may not have reached the model, so the runner retires that harness instance. The coordinator keeps the input in the receipt and never replays it into a different run, because replaying it could make the agent act on it twice.
Surviving failure
The runner, the sandbox and the network can all fail. A run can fail with them, but the session keeps its history, files and queue.
When a runner dies, the Durable Object waits out the two-minute stale-owner window and moves the session to the next epoch. A new runner restores the checkpoint from R2 and picks up the messages that queued while nobody owned the session. If the old runner comes back and tries to finish its job, its write carries the old epoch, so the Durable Object turns it away.
Two pieces of state make this work:
- Harness checkpoints stay in each harness's native format: Pi JSONL, Codex rollouts and the Claude Agent SDK session store. At safe turn boundaries, the runner takes one if 30 minutes have passed or the state has grown by 20 MiB. Only the matching adapter can restore it. Saved sessions are not interchangeable between harnesses, and we do not pretend they are.
- The workspace lives on a per-session volume, so a dead sandbox does not take the files with it. A runner can reattach to a live sandbox when one still exists. After seven idle days the workspace is archived to R2 and restored on demand.
The browser is yours
The agent needs a browser for many business tasks, and the useful browser is usually the one where you are already signed in.
We do not run a cloud browser. "My Browser" is your own Chrome, connected through our companion extension. You pair it with a ten-minute, single-use code, or automatically through the macOS app.
The browser is a separate set of hands. It does not go through the sandbox. The runner sends commands through the control plane to an authenticated extension, and each run gets its own lease on the browser.
Your cookies and sessions stay in Chrome. But once you connect it, the agent can read and act in your signed-in pages, and an agent that reads a poisoned page can be told to act there too. That is why pairing is an explicit choice.
Cost and limits
Running the loop in a separate container costs something. These are the numbers as of November 2026:
| Item | Value |
|---|---|
| Sandbox | 2 CPU, 2 GiB |
| Session runner | 0.5 CPU, 2 GiB |
| Accounting ceiling, runner + sandbox | 127 µ$/s (deliberately conservative) |
| Always-warm trigger | about $2.94/day (accounting ceiling) |
| Sandbox lifetime | 60 min idle, 24 h hard maximum |
| Warm runner idle timeout | 5 min |
| Stale-owner window | 2 min |
| Checkpoint cadence | 30 min or 20 MiB |
The sandbox is the larger of the two. It starts at the first tool call and stops after 60 idle minutes, so a chat-only session never pays for it. The runner stays small because inference, the expensive part of its job, happens at the model provider. The runner is also the part we pay for while it waits: it is held for the whole run, mostly waiting on tokens.
Known limits
Moving the loop out protects keys. It does not make the model harder to fool.
An injected instruction can still misuse what the agent is allowed to do. It can call a third-party API through the proxy while the job token is valid. It can read the files in the session's workspace. It can act in a browser you paired. And for the one allowlisted CLI command that needs a secret, that secret is in the sandbox for the length of that command.
The runner is also now the valuable target. It holds the credentials, so it must never execute anything the model produces. That is why every native tool in every harness is replaced or denied.
A fenced runner can also still touch files. Epoch fencing makes the control plane reject a dead runner's writes. It cannot revoke a mounted volume. Until Modal ends that container, a partitioned runner can still change files in the session's workspace. Waiting for the old job to be settled before a new owner starts narrows that window. It does not close it.
Why this shape
The sandbox is where untrusted things happen, so the valuable keys should live somewhere else.
Agents read web pages written by strangers. They open files customers upload. They install packages. Any of those can carry instructions. If the loop, the keys and the tools share a machine, one successful injection reaches all three.
Splitting the brain from the hands gives each tier a narrow job. The control plane keeps order and owns identity. The runner thinks and holds keys. The sandbox does work and can be thrown away. A failure in one tier has a defined blast radius and a defined recovery path.
It also keeps us honest about what each part promises. A finished model turn means the agent stopped. A committed receipt in the Durable Object means the request was durably accepted. The events that follow record what actually ran. Those are different facts, and the architecture keeps them in different places.
Comparison figures are drawn from what each vendor publishes, as of November 2026. Corrections are welcome.