Breakscale: A System Design Simulator Where Every Number Is Actually Measured
Most system design material is static diagrams and rules of thumb. “Add a cache.” “Use a queue.” “Put a load balancer in front.” It’s hard to build real intuition for why p99 latency falls off a cliff once utilization passes 80%, or how a short timeout plus a couple of retries can turn one slow database into a total outage. Breakscale fixes that by running the experiment instead of describing it.
It’s an open-source (MIT) system design simulator where every number on screen comes from a real discrete-event simulation — not an animation drawn to look plausible. You put load balancers, caches, databases, queues, and ~30 other components on a canvas, wire them into a system, and drag the traffic slider up until something gives.
The retry storm, made visible
The flagship example is the retry storm, and it’s the clearest demonstration of why this approach beats a diagram. Load it, push traffic to 100 requests per second, and you watch something counterintuitive: the database sits at 99.9% busy — working flat out — while goodput falls to zero.
Why? Because every request the database actually finishes has already been abandoned by a caller that gave up waiting. A short timeout with a couple of retries turns 100 offered requests into 348 requests hammering a database that was already full. The system is maximally busy and producing nothing. You can read that paragraph and nod, or you can drag a slider and watch latency percentiles climb, queues fill, circuit breakers trip, and the whole thing collapse in real time. The second one sticks.
Three ways to run it
In your browser — Open breakscale.tech, pick an example, raise the traffic slider until something turns red. No account. Designs stay in your browser; shared designs are encrypted before they leave, with the key held in the fragment of the URL that browsers never send to a server.
In VS Code — Install the extension and run Open Breakscale from the command palette. Same engine, same examples, works offline, right beside your code. Designs move between the editor and the website via a share link or a .breakscale file.
With your AI assistant — This is the part I find most interesting. Breakscale is also an MCP server hosted at https://mcp.breakscale.tech/mcp, so Claude, Copilot, Cursor, and Codex can drive it for you. Point an assistant at a repo and ask it to turn the architecture into a design — it builds the design, runs it through the same simulation engine, and comes back with measured numbers plus a link that opens the result. Nothing to install; in claude.ai you add the URL under Customize → Connectors → Add custom connector.
# Claude Code
claude mcp add --transport http --scope user breakscale https://mcp.breakscale.tech/mcp
Why this matters
There’s a meaningful difference between a tool that illustrates system behavior and one that measures it. A diagram can show you a cache sitting in front of a database; it can’t show you the exact traffic level where your specific timeout-and-retry configuration flips from “slightly degraded” to “total outage.” Breakscale measures that from individual simulated requests, which means the failure modes emerge from the dynamics rather than being hand-drawn.
The honest caveat — which the project states plainly — is that this helps you understand system behavior and architectural trade-offs, not guarantee how your actual production infrastructure will perform. It’s a learning and reasoning tool, not a capacity planner for your real cluster. But as a way to build genuine intuition for distributed-systems failure modes — retry storms, cascading timeouts, queue saturation, the 80%-utilization cliff — it’s one of the better things I’ve seen. And wiring it into an AI assistant via MCP means you can go from “describe a system” to “here’s exactly where it breaks, with numbers” in a single prompt.
Repo: github.com/workersio/breakscale · Try it: breakscale.tech