CraftingGet Access
Get Access

How Webflow scaled coding agents across a large monorepo

Most cloud sandboxes are built for small repos and short tasks. Webflow needed dozens of agents running its full stack at once.
How Webflow scaled coding agents across a large monorepo
Challenge
Webflow's decade-old monorepo needs real databases, caches, queues, and services to build and test, so coding agents running in parallel on laptops froze machines and collided across worktrees, and generic cloud sandboxes were too small for the stack.
Solution
Webflow built a thin Slack-to-draft-PR orchestrator and pushed the heavy lifting to Crafting, which gives every agent a pre-warmed sandbox with the full Webflow stack, short-lived cloud credentials, and template-scoped tools and permissions.
Results
Over 50% of engineers and designers have used the agent, it is responsible for over 50% of PRs in some repositories, and nearly every post in Webflow's UX papercuts channel now gets picked up and worked on.

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.

The laptop ceiling

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.

Why generic sandboxes fall short on a large codebase

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.

A thin orchestrator with heavy environments

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:

  1. Someone mentions the agent in a Slack thread and directs it to fix a flaky test, look into a UX bug, or run a root cause analysis.
  2. The orchestrator picks a template, and Crafting provisions a sandbox with the full Webflow stack already running.
  3. The agent implements the change, runs tests and validations, takes screenshots and videos, and calls only the tools it's allowed to use.
  4. The agent opens a draft PR and posts back to the thread for human review.

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.

What made Crafting different

Generic sandboxes solve isolation. Given its tech stack, Webflow needed five more things.

1. Better performance with sandbox customization

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.

2. Short-lived tokens living in Webflow's cloud

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.

3. Warm from the first token

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.

4. Built for many agents and people working in parallel

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:

  • A GitHub app with limited permissions prevents access escalation, ensuring all changes go through the standard process.
  • Login providers and OAuth, so each user's own tokens can be configured to flow to the MCP servers they're allowed to use, with no shared global credentials.
  • Lockdown mode and tool-call filtering, so autonomous agents can reach only what they're explicitly allowed to reach.
  • An isolated agent performs a risk assessment to understand the context of the change and assigns a High, Medium or Low risk rating based on a rubric. As an example, if a change touches authentication services, infrastructure or introduces new dependencies it would be a high risk always. For content changes to docs, features in low risk services, updates to formatting or comments get a low risk assignment.
  • A separate agent identity (and model) runs an adversarial review to uncover coding flaws and risks to be further investigated.
  • Then a final service account enables codeowners to merge their own low risk PRs to reduce the burden of a human code review. All Medium and High risk changes require humans to analyze and approve changes.

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

5. Everything above the sandbox stays swappable

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.

The second scaling problem: more people shipping code

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

Results

  • Managers, PMs, and designers who don’t keep a local environment current have been the strongest and most rapid adopters. Over 50% of engineers and designers have used the agent at this point, with adoption increasing.
  • An internal UX papercuts channel went from 1 in 10 posts getting any attention to nearly every post being tagged and worked on.
  • The agent is responsible for over 50% of PRs in some repositories.
  • Some teams have zero open vulnerabilities because the agent can verify the fix works, beyond just making the change.

Advice for teams with large codebases

  • Solve the environment before the agent. Agents will continuously evolve, but every agent needs the right dependencies, controls, and data to get the job done.
  • Get agents off laptops early to tackle scale, permissions, and maintainability.
  • Treat verification as the primary goal. Agents already write code fast with validation quickly becoming the bottleneck for larger codebases, especially for testing across services and dependencies.
  • Keep the orchestrator thin so you can swap harnesses and models as new tools and providers become available.
  • Build for scale from day one. What works for a single engineer or agent quickly falls apart with multi-agent collaboration or shared resources.

Looking ahead

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:

  • 100% of engineering, product, and design merged a PR (91% last quarter)
  • Increase roadmap capacity
  • Decrease MTTR and overall incident minutes

Running coding agents against a large codebase? Crafting gives every agent your real stack, in your cloud. Talk to us →

Put your agents to work on the real thing.
Built for Security,
Measured in Velocity.
© Crafting Inc. 2026. All rights reserved
Service agreement
LinkedInGitHub