Skip to content
ReviewRamble

The weekly brief

AI, reviewed, in your inbox.

  • New reviews of tools, models, MCP servers and repos, with the verdict up front
  • Re-checked prices and ratings when something changes
  • New analysis pieces as they are published

Models, agents, MCP servers and the tools actually worth your time.

One email a week. Unsubscribe with the link in any brief. How we use your email

Breakscale

System design simulator: wire up 33 components, raise traffic until something fails, and see measured latency, queues and retry storms.

Reviewed by ReviewRamble editors · Updated

View on GitHub Open source

Share this page:XLinkedInFacebookRedditWhatsAppEmail

Our rating

4.2/5

Breakscale lets you watch queueing theory break a design in real time, and its AI part is an optional MCP add-on around a simulator that uses no AI itself.

What is Breakscale?

Breakscale is a system design simulator from workersio. You place load balancers, caches, databases, queues, rate limiters, circuit breakers and other components on a canvas, connect them, then raise the traffic and watch a discrete-event simulation show where latency climbs, queues fill and requests fail. Faults can crash or slow nodes, cut links, drop packets and deliver requests twice.

It runs at breakscale.tech with no account, as a VS Code extension that works offline, and as an MCP server that lets AI assistants build and test designs for you. The simulator itself uses no AI model.

The repo is TypeScript and MIT licensed, with 2,432 stars and 222 forks. It was created in August 2026 and the last commit was on 16 November 2026. There are no tagged releases; the MCP server is on npm as breakscale-mcp 0.1.1.

Is Breakscale worth it?

Breakscale answers a question most system design material only asserts: what actually happens to a design when the traffic doubles. You wire up components from a palette of 33, drag a traffic slider, and a discrete-event engine pushes individual simulated requests through finite server slots and real FIFO queues, so p50, p95 and p99 latency are measured from completed requests rather than produced by a formula. The README's headline example is a retry storm: at 100 requests a second, timeouts and retries turn into 348 requests reaching a database that is 99.9% busy while goodput, the work callers actually receive, is zero.

The teaching material is the strongest part. There are 24 worked examples (17 that each isolate one failure mode, plus 7 small reconstructions of Netflix, Spotify, Discord, Uber, Twitter/X, Stripe and WhatsApp that the README calls teaching diagrams, not insider knowledge), 18 challenges, 6 rebuilt public outages and a 48-step learning path. A search called Can you break it? injects faults until a goal you set fails, then shrinks the result to the fewest faults that still break it. Correctness checks catch double charges and lost writes, not only slow responses, and runs are deterministic for a given seed, so a replay link shows someone else the exact failure.

The AI angle is narrow, and the project is honest about it. Nothing in the simulator calls a language model: the engine, the examples and the fault search are ordinary TypeScript, and the scenarios are written by hand rather than generated. The AI part is an MCP server with 5 tools, hosted at mcp.breakscale.tech with no sign-in or run locally with npx on Node 20, which lets Claude, Copilot, Cursor, Codex or Gemini CLI turn a repo or a description into a design, simulate 30 seconds of it and return the numbers with a link. In claude.ai, VS Code, Cursor and Goose the canvas opens inside the chat. The weak point is the input: when an assistant reads your code, capacities and service times are its guesses, which is why the README's suggested prompt asks it to say which numbers it guessed.

The catch: a model this clean leaves things out. Each component is a capacity, an instance count and a gamma-distributed service time; garbage-collection pauses, the quirks of a particular database and failures beyond the listed fault types are not modelled, so the output teaches the shape of a failure, not a capacity plan. The project is also young: created on 23 August 2026, with no tagged releases, the MCP package at 0.1.1, and a VS Code extension README that still counts 23 examples. Privacy is handled with care. There is no account, designs stay in the browser, share links are encrypted with the key kept in the part of the URL browsers never send, and only the website counts page views, with Vercel's cookie-free analytics. The hosted MCP server does receive whatever design your assistant sends, which may describe your internal architecture; the local stdio mode avoids that.

Our take: for feeling why p99 latency falls apart once utilisation passes 80 percent, nothing else in our repos section comes close, and the MCP server is a sensible extra rather than the point. For a diagram of an existing codebase with no simulation, GitDiagram or Archify get there with less setup.

Where it earns its place

  • A backend engineer preparing for system design interviews

    Understand why retries and timeouts can take a whole service down

    Load the Retry Storm and Circuit Breaker examples at breakscale.tech, raise the traffic until goodput collapses, then add a breaker and compare with the pinned run. Free, no account, roughly an hour per failure mode.

  • A university lecturer teaching distributed systems

    Show a lecture hall what queueing does to tail latency

    Use presenting mode with the Single Server and Sharded Database examples, then set the 18 challenges as exercises; fixed seeds mean every student sees the same run, and replay links can be handed in and marked.

  • A tech lead on a 10-person team using Claude Code

    Find where our checkout service breaks before a sales event

    Add the MCP server with claude mcp add, ask the assistant to turn the repo into a design and list the numbers it guessed, correct them, then run break_it with a goal such as errors under 1%. Use the local stdio mode if the architecture is confidential.

Before you commit

Setup
Open breakscale.tech and pick an example; or install the VS Code extension and run Open Breakscale; or add https://mcp.breakscale.tech/mcp as an MCP connector. From source it needs Bun: bun install, bun dev, then localhost:5173.
Integrations
MCP server with five tools (read_me, create_view, export_design, open_design, break_it) for claude.ai, Claude Desktop, Claude Code, VS Code with Copilot, Cursor, Codex, Gemini CLI, Windsurf, Goose and Zed; .breakscale files move designs between the website and VS Code; the engine can be driven from a TypeScript script.
Data and privacy
No account; designs stay in browser or VS Code storage. Share links are encrypted with the key in the link fragment; short links keep the encrypted blob in Cloudflare KV, capped at 256 KB with 20 writes a minute per address. The website uses Vercel's cookie-free analytics; the extension and MCP server have none. The hosted MCP server sees designs sent to it.
Cost at scale
Nothing: the website, extension and hosted MCP server are free and MIT licensed. The only cost is your AI assistant's own usage when you work through the MCP server.
Limits
Components are modelled as capacity, instances and gamma-distributed service time, so results show behaviour, not real capacity figures; the company reconstructions are teaching diagrams; 7 open issues and pull requests; MCP package at 0.1.1 with no tagged GitHub releases.

What’s good

  • Latency and utilisation figures come from simulated requests, not formulas
  • 24 examples, 18 challenges and 6 rebuilt outages in a 48-step path
  • Fault search shrinks a failure to the fewest faults that cause it
  • No account; designs stay local and share links are encrypted
  • MCP server runs hosted or locally, with an in-chat canvas in some clients

What’s not

  • No AI in the simulator; assistants only guess the inputs
  • Simplified component model, not a capacity planner
  • Under three months old with no tagged releases
  • Hosted MCP server receives the designs your assistant sends
  • VS Code extension README lags the main README

Best for

Engineers, students and lecturers who want to see distributed-system failure modes happen under load instead of reading rules of thumb.

Breakscale alternatives

Breakscale: common questions

Is Breakscale worth it?
Breakscale lets you watch queueing theory break a design in real time, and its AI part is an optional MCP add-on around a simulator that uses no AI itself. We rate it 4.2 out of 5.
How much does Breakscale cost?
Free and MIT licensed: the website, the VS Code extension and the hosted MCP server cost nothing and need no account. The author takes donations through GitHub Sponsors and Ko-fi.
What are the downsides of Breakscale?
No AI in the simulator; assistants only guess the inputs; simplified component model, not a capacity planner; under three months old with no tagged releases; hosted MCP server receives the designs your assistant sends; vS Code extension README lags the main README.
Who is Breakscale best for?
Engineers, students and lecturers who want to see distributed-system failure modes happen under load instead of reading rules of thumb.
How much does Breakscale cost for a team or in production?
Nothing: the website, extension and hosted MCP server are free and MIT licensed. The only cost is your AI assistant's own usage when you work through the MCP server.
Is Breakscale safe for company data?
No account; designs stay in browser or VS Code storage. Share links are encrypted with the key in the link fragment; short links keep the encrypted blob in Cloudflare KV, capped at 256 KB with 20 writes a minute per address. The website uses Vercel's cookie-free analytics; the extension and MCP server have none. The hosted MCP server sees designs sent to it.
What are the best Breakscale alternatives?
The closest alternatives we have reviewed are GitDiagram and Archify.

Answers checked Nov 18, 2026.

Make Breakscale? Show this rating on your siteBreakscale rated 4.2 out of 5 on ReviewRamble