Cascade
Engineering · Local models

Small local models fail the same way in every harness. Cascade is built to carry what they drop.

We gave the same 9-billion-parameter model the same job in two coding-agent harnesses. It made the same mistakes in both. One harness stopped at every mistake and waited for us. The other noticed, corrected course, and finished on its own.

17 October 2026 · The Cascade team · 7 min read

Cascade is an open-source AI app builder that runs on your machine: you describe an app, an agent plans it, writes the code, builds it in a sandbox and checks it in a browser. It works with frontier models through your own API key, but the reason it exists is local models — the ones you run yourself with Ollama, for free, with nothing leaving your machine.

Local models in the 7–35B range are good enough to write real code. They are not good enough to finish real work reliably, and that gap is mostly not about intelligence. This post is about where it comes from, measured.

The experiment

One model, one task, two harnesses:

That other agent is excellent. It is also designed around frontier models, and that design choice turns out to be the whole story here.

Same model, same failures

In both harnesses the model dropped the ball in the same three ways:

  1. Wrong-shell commands. Windows cmd syntax — cd /d C:\… — sent to a bash shell, which fails.
  2. Stale writes. Editing a file from memory after it had changed on disk, so the edit is rejected.
  3. Turns that end on a thought. The model reasons about what to do next, then ends its turn without doing it.

Because the failures were identical across two very different harnesses, they are properties of the model, not of either tool. That matters: you cannot prompt them away for good, and a better model will not show up next week to fix them for you. The harness has to handle them.

Where the harnesses differed

The other agent's contract assumes the model finishes its own work, so when the 9B model ended a turn with the job half done, the turn simply ended. We typed "continue" four or five times. It still did not converge. That is not a bug in that agent; it is a reasonable design for the models it was built for.

Cascade ran the same kind of task unattended:

Task (qwen3.5:9b, 32K context)Result in CascadeTime
Todo appBuilt and verified, unattended212 s
Landing page with a hero sectionBuilt and verified, unattended164 s
Multi-page online storeHonest timeout — zero failed shell commands, no false "done"—

The store result is the ceiling of a 9B model on work that spans many files, and we would rather report it than hide it. The point is the difference in kind: the first two finished with nobody at the keyboard, and the third failed honestly instead of claiming success.

How Cascade carries what the model drops

Every recovery in Cascade is a small, specific check that fires only when there is evidence the model dropped something:

Cascade's activity log: a passing npm run build, the agent opening its own product and checkout pages in a browser, auditing them, and starting a smoke-test subagent
The verify half in practice (from a real build): build, open the pages in a browser, audit them, and hand the store to a smoke-test subagent.

The design rule that keeps this honest: every check is triggered by evidence, never by model size. A frontier model that does its own verification never trips them, so they cost it nothing. A small model that drops a ball gets caught at the exact place it dropped it.

Two more things we measured the hard way

The prompt matters more than you think

Same 9B model, same store task, four prompt revisions, one change at a time. The failure moved from pathological (a 30-minute timeout with zero builds attempted) to structural (a red build) to cosmetic (a green build that failed one brand-name check) — and the last run was the fastest, at 13.5 minutes. The model never changed. For local models, prompt architecture is a first-order variable, not polish.

Check your sampling before you blame the model

A 35B mixture-of-experts model failed every scenario in one batch while the 9B passed the same tests. Its signature was strange: it announced its next step ("Now wire the button:") and ended the turn. The cause was not capability. The test ran at temperature 0 while the model's Modelfile pinned a presence penalty of 1.5 — greedy decoding plus a strong penalty on repeated tokens steers a model away from writing code, which is mostly repeated tokens. With temperature 0.6 and a presence penalty of 0.5, the same family worked. Run ollama show <model> --modelfile and work out the effective settings before you conclude anything.

If you want to run a coding agent locally

Try it on your own models

Cascade is free and MIT licensed. Download the desktop app for Windows, macOS or Linux, point it at Ollama or your own key, and describe an app.

Also on the blog: One prompt, one turn, a working store: inside a real Cascade build.