By Sumeet Vaidya
Most cloud sandboxes are built for small repos and short tasks. Webflow needed dozens of agents running its full stack at once. We sat down with James Nimlos, a staff software engineer at Webflow responsible for its agentic infrastructure to understand how to scale at a company like Webflow.
Anyone running more than a handful of coding agents against a large codebase hits the same wall. The first agent works great. By the fifth, the laptop fans are screaming. By the tenth, things break in ways that are hard to debug.
Webflow's main codebase is a monorepo that has grown organically for more than a decade, backed by real databases, caches, queues, and services. At this point, if an agent were able to review ten files per minute, it would take almost five and a half days to analyze the entire monorepo. To get agents completing tasks across the monorepo in hours or even minutes, Webflow needed more creative solutions.
When engineers started running agents in parallel, each in its own Git worktree, two failures showed up right away. One agent decided to type-check the entire monorepo at once and froze the engineer's machine. Another spent cycles convinced a test it had written was failing, when the test was actually hitting a server running on a different worktree's branch.
Worktrees isolate code. They don't isolate compute, ports, or services.
“Engineers are running a lot of parallel edits in worktrees, but their laptops don't have the resources for real verification loops. One engineer's machine froze when an agent kicked off a massive parallel typecheck. Another watched an agent burn cycles chasing a 'failing' test that was really hitting a service running from a different branch.”
— James Nimlos, Staff Software Engineer at Webflow
Moving agents to the cloud was the obvious next step. Finding a cloud sandbox that could actually handle Webflow's codebase was the hard part.
Most sandboxes are designed around a clean container with a fresh checkout of a repository. That works for a small service or a greenfield app. On a large monorepo, it breaks down in three ways.
The environment is too small. Webflow's stack needs far more memory and compute than a typical sandbox provides to run and access services the code depends on. The monorepo has over 1,300 modules, 44 deployed services, and 53 local support services. An agent that can't build, run, and test the real thing generates PRs that look plausible but are often subtly wrong.
Every session starts cold. If each agent has to clone, install, and work out how the project fits together before writing a line of code, you pay for that setup in minutes and tokens on every task.
Scale and security become coordination and identity problems. Real tasks involve several agents and several people. One agent writes code, one performs a risk assessment, another reviews it, and a teammate joins the Slack thread halfway through. Every commit needs the right author, every tool call needs the right access, and CODEOWNERS must review for proper diligence.
When Webflow evaluated other providers, engineering time wasn’t the main blocker. Fitting its constraints would have meant rewriting the development environment and modifying production services, which was both hard to justify and potentially risky.
Webflow built a remote coding agent that takes a request from Slack all the way to a draft PR. The design principle is simple: keep the orchestrator thin, and push the heavy lifting down to a sandbox system built for it. That sandbox system is Crafting.
A typical task looks like this:
Webflow recently shipped a second version, which rebuilt the orchestration layer on a custom harness that adds smart model routing, mid-turn steering and message queuing, scheduled automations, built-in review rounds, and session continuation, so follow-ups pick up where the last turn left off.
Generic sandboxes solve isolation. Given its tech stack, Webflow needed five more things.
Each session gets its own Crafting sandbox with the full Webflow stack: databases, caches, queues, and services, not just a checkout. Webflow runs these sandboxes on a dedicated node pool sized for the monorepo, so a repo-wide type-check is just another job. Because every agent has its own environment, the "test hitting another branch's server" problem disappears.
These are the same sandboxes Webflow engineers already develop in. Agents and humans share one environment definition, so Webflow didn't have to rebuild its dev environment to fit an agent platform. Whatever works for an engineer works for an agent.
Even the best architected agents are at risk of breaking out of their environments. No matter how secure a system might be, an exfiltrated token is a major security risk with its TTL as the only mitigation. Crafting helps Webflow keep agents restricted by connecting them to Webflow’s AWS and GCP accounts through identity federation and OIDC. By keeping connections in Webflow’s own cloud, Crafting can restrict agents to having short-lived credentials rather than static secrets with longer lifetimes. These tokens are only generated as needed and dramatically reduce the risk of any security incidents.
Sandboxes come from a pre-warmed pool with the repo, dependencies, and agent context (agents.md, skills, MCP configuration) already in place. Agents spend tokens on the task, not on figuring out the project. Templates scope which MCP servers each agent can see, which keeps context lean. Sandboxes are cleaned up when sessions end, so Webflow isn't paying for idle full-size environments.
In Crafting, a template can define more than an environment. It can define an agent: its instructions, tools, context, and access level. Webflow uses templates to run different agents with different permissions, and template access controls to protect sensitive ones while new teams experiment. A new team doesn't rebuild the stack. It starts from a template that already works.
Identity is where scale gets harder.
Sessions are multiplayer: one engineer starts a thread, another asks for the PR, a third adds context. Crafting gives Webflow the building blocks to keep that straight:
Getting attribution right in multiplayer threads was a complex problem that took some iteration.
“The verification loop is the one that matters. People can have agents write code as fast as they want, locally. But running the full test suite, end-to-end and smoke tests, and producing screenshots and demo videos takes real compute. That’s the last mile of software delivery, and it’s where people least trust agents if they can’t see the evidence. If we get that right and make it automatic, that’s what pushes people to the next level.”
— James Nimlos, Staff Software Engineer at Webflow
The first version ran on Crafting's built-in agent. For V2, Webflow replaced the entire harness and changed its model mix without having to change the sandbox itself. Crafting exposes sandboxes over SSH, so any harness can plug in, and it supports whatever model the harness picks.
For a codebase that will outlive several generations of models, that matters the most. Agents, tools, harnesses, and workflows will keep evolving, but Webflow shouldn’t have to continuously modify its environments to keep moving fast.
Webflow wants people across engineering, product, and design to open PRs. For someone who doesn't run code locally, setting up a dev environment for a monorepo is a real barrier, and every setup adds load on the internal developer team. Relying on popular vibe coding apps or even agentic IDEs results in the same problems engineers faced when developing without the full stack. Cloud agent runtimes also addressed local performance on varying laptop configurations for employees, reducing the frequency of laptop refreshes to try out complex agent workflows.
On Crafting, those environments are instantly available anytime someone needs them. A designer or PM asks for a change in Slack, and the agent does the work in a fully configured sandbox. A "paper cut" channel lets anyone file a UI issue that becomes a draft PR for an engineer to approve. A PM can ask for a plan before anyone writes code. If it touches ten files across services, it goes to an engineer. If it’s a two-line CSS fix, the PM can take it to a draft PR themselves.
“We’ve had people tell us this is their daily driver. What excites them most is drafting a real plan and seeing how complex a change actually is. Non-engineers can finally answer ‘how hard could it be?’ for themselves.”
— James Nimlos, Staff Software Engineer at Webflow
The team keeps moving up the stack, toward broader development workflows and automated triage. The division of labor stays the same: engineers decide what to do, the agent makes the changes, and Crafting provides a safe place to do it against Webflow’s real stack at scale.
Next up, Webflow hopes to achieve the following goals in the coming months:
Running coding agents against a large codebase? Crafting gives every agent your real stack, in your cloud. Talk to us →