TL;DR: The trending “step back from Windsurf” stack — Ollama + Continue.dev + Open WebUI — works today and costs $0/month against Devin Desktop Pro’s $20. But every blog post recommending it skips one fact: Continue.dev has been frozen at v2.0.0 since Cursor’s June acqui-hire, with a read-only repo and zero future patches. Run the stack, but run the corrected version below.

	Devin Desktop Pro	Ollama + Continue v2.0.0 + Open WebUI	Ollama + Cline (+ Continue for autocomplete)
Monthly cost	$20/seat	$0 + electricity	$0 + electricity
Annual cost	$240	$0	$0
Code leaves your machine	Yes — BYOK still routes to cloud APIs	No	No
Maintenance status	Active (Cognition)	Continue frozen at v2.0.0; Open WebUI active	Cline active (Apache 2.0); Continue frozen
The catch	No local model weights, ever	Building on an unmaintained extension	No ghost-text autocomplete in Cline itself

Honest take: Switch — but not to the stack the Medium post sold you. Ollama and Open WebUI are solid; Continue.dev is a frozen appliance that should only hold the autocomplete slot, not your agent workflows. Put Cline in the agent seat, keep Continue v2.0.0 for ghost text until it breaks, and you replace 90% of what Windsurf did for $0/month.

The post making the rounds this month — “Why I’m Using Open WebUI & Continue.dev (and Stepping Back from Windsurf)” — struck a nerve because it names something a lot of developers have felt since June 2: the product they signed up for doesn’t exist anymore. Windsurf is now Devin Desktop, Cascade was force-retired on July 1, and the app opens on an Agent Command Center instead of your code. If your reaction to all that churn is “I want a stack no acquisition can take away from me,” the local-first instinct is correct.

The execution in most of these posts is not. They recommend Continue.dev as if it were a living project. It isn’t — and we know because we documented the shutdown in detail in July. This article is the version of the switch guide that survives contact with that fact: what to install, the exact configs, where the trending stack genuinely beats Devin Desktop, and where it quietly falls apart.

Why people are actually leaving

Three concrete grievances keep coming up in the September threads, and two of them checked out when we verified this week.

BYOK on Devin Desktop never touches local weights. Devin Desktop supports bring-your-own-key, but only for select cloud models — your key routes to Anthropic’s or OpenAI’s API. There is no supported path to point the editor at weights running on your own GPU. For developers who moved to Windsurf precisely because they wanted control, that’s a hard stop. Verified September 6, 2026 against current third-party documentation of Devin Desktop’s model options; Cognition’s own docs describe BYOK as cloud-model-only.

The forced Cascade migration burned trust. Cascade hit end-of-life on July 1, 2026, four weeks after the rebrand. Everyone with Cascade-dependent scripts and muscle memory got a deadline, not a choice. Nothing about Devin Local is bad — our own testing found it more token-efficient than Cascade — but “we deleted the thing you built your workflow on” is exactly the failure mode local-first developers are trying to escape.

Pricing held, but the anchor moved. Devin Desktop’s tiers as of this week: Free, Pro at $20/seat/month, Max at $200/month, Teams at $80/month base plus $40 per seat. The $20 Pro price didn’t change with the rebrand. What changed is what sits above it — a $200 Max tier and usage quotas that make the $20 tier feel like the floor of a ladder you’re expected to climb.

One caution before you rage-quit: Devin Desktop’s Free tier still includes unlimited Tab completions, and its proprietary autocomplete remains better than anything you can self-host. If autocomplete quality is 90% of what you use an AI editor for, the cheapest rational move is Devin Free, not a GPU. The local stack is for people whose reason to leave is where the code goes, not the invoice.

The stack, piece by piece — with honest status labels

Ollama — active, healthy, the default local inference server. Nothing to flag.

Continue.dev — frozen, and you need to internalize what that means. Cursor acquired Continue in June 2026; the final release, v2.0.0, was tagged June 19, and the continuedev/continue repository now carries the notice “no longer actively maintained and is read-only for all users” — still there when we checked September 6, 2026. The code stays Apache 2.0, the extension still installs from the VS Code Marketplace, and v2.0.0’s last act was actually good for local use: telemetry and login were stripped out entirely, so nothing phones home. But no security patches, no provider updates, and no fixes when a future VS Code release breaks it. As of this writing, no community fork has meaningful momentum — the Kilo Code rescue that saved Roo Code’s users has not happened for Continue.

Open WebUI — active, but read the license. Open WebUI gives you the ChatGPT-style browser chat, document RAG, and model switching that Devin Desktop’s chat panel provided, all pointed at your Ollama instance. Development is very much alive (18,000+ commits and counting). Two things to know: it is no longer plain BSD — the current Open WebUI license adds a branding-preservation requirement, which matters if you plan to deploy it for a team — and it’s a chat layer, not an editor integration. It complements Continue; it doesn’t replace it. For the deeper FOSS-licensing angle, aifoss.dev covers the self-hosted ecosystem full-time.

The model. The September posts mostly demo undersized 7B models and then shrug at the output quality. Skip that mistake: if you have a 24GB card, the model that makes this stack credible is Qwen3.8-27B — Apache 2.0, an 18GB Q4_K_M build on Ollama, and vendor-reported coding scores within 1.5 points of Claude Sonnet 5 on SWE-bench Pro. A used RTX 3090 is the cheapest ticket in; for the full hardware math, runaihome.com’s GPU buying guide for local AI is the deep dive.

Setup: the 30-minute version

Tested order: inference first, editor second, chat panel last.

1. Ollama + the model

Install Ollama (needs v0.32.12 or later for Qwen3.8 support), then:

$ ollama pull qwen3.8:27b
pulling manifest
pulling 8f2c4a1b9e33... 100% ▕████████████████▏  17 GB
pulling 41bc9d2e7710... 100% ▕████████████████▏ 931 MB
success

$ ollama run qwen3.8:27b "write a python function that reverses a linked list"

If the second command produces tokens at reading speed on a 24GB card, you’re set. If it crawls, Ollama has silently offloaded layers to CPU — the KV cache at long context is what overflows, not the weights. The fix is capping the context window; we walked through the exact settings in Ollama not using your GPU.

2. Continue v2.0.0, configured to survive the freeze

Install the Continue extension from the VS Code Marketplace, then put this in ~/.continue/config.yaml:

name: Local Assistant
version: 1.0.0
schema: v1
models:
  - name: Qwen3.8-27B local
    provider: ollama
    model: qwen3.8:27b
    apiBase: http://localhost:11434
    capabilities:
      - tool_use

Two rules keep this config working indefinitely. First, no uses: blocks anywhere. Continue’s hub-reference syntax resolved against hub.continue.dev, which was shut down July 15 and no longer even has a DNS record — a config with uses: lines will half-load with no useful error. Every model, rule, and prompt must be declared inline. This is the single most common “Continue randomly broke” cause we’ve seen since July, and it looks nothing like a shutdown notice. Second, declare capabilities: [tool_use] explicitly; auto-detection is frozen along with everything else, so newer model names won’t be recognized. Autocomplete config — a smaller, faster model in the autocomplete role — works exactly as it did in our original Continue + Ollama guide, which remains accurate for v2.0.0 because v2.0.0 will never change.

3. Open WebUI as the chat panel

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

Open http://localhost:3000, create the local admin account, and it auto-discovers Ollama. (Bare-metal alternative: pip install open-webui && open-webui serve, which lands on port 8080 instead.) This is your Windsurf-style side chat: long design discussions, RAG over your docs folder, model A/B testing — the conversations that don’t need to happen inside the editor.

Open WebUI’s docs also describe an optional deeper wiring: pointing Continue through Open WebUI instead of straight at Ollama, using provider: openai, apiBase: http://localhost:3000/api, and an API key generated in Open WebUI’s settings. You gain Open WebUI’s pipelines and per-user access control in front of your editor requests; you add a hop and an auth token to debug. For a solo machine, straight-to-Ollama is the right call. For a small team sharing one GPU box, routing through Open WebUI gives you the access control Devin Teams charges $40/seat for.

Where the stack loses to Devin Desktop

Three gaps, in descending order of pain.

Autocomplete quality. Devin’s proprietary Tab completions are trained and served for exactly that job. Continue’s local FIM ghost text with a small model is serviceable — and the only free local option in VS Code — but you will notice the difference on multi-line completions within an hour. Nothing self-hosted closes this gap in 2026.

Agentic multi-file work. Continue v2.0.0’s agent mode was mid-pack when it froze, and it will only decay relative to the field. Devin Local does genuine multi-file, subagent-parallel work. This gap, unlike the other two, has a free fix — covered next section.

Codebase-wide context. Windsurf indexed your whole repo in the cloud; the local stack indexes what fits in a 262K context window and whatever embeddings you set up locally. Real gap, but note the irony: cloud indexing is precisely the “my code lives on someone’s server” behavior the switch is meant to end.

The correction: put Cline in the agent seat

Here’s where we break from the trending posts. Building your agent workflow on a frozen extension is a countdown, not a strategy. Cline is Apache 2.0, actively maintained, points at the same Ollama endpoint you just configured, and its agentic multi-file editing is what Continue’s agent mode wanted to be. It has no ghost-text autocomplete — which is exactly why the right division of labor is:

• Cline → agent tasks: multi-file refactors, test generation, “fix this failing build”
• Continue v2.0.0 → the autocomplete slot only, until a VS Code update breaks it
• Open WebUI → everything conversational, plus RAG
• Ollama + Qwen3.8-27B → one model serving all three

Same $0/month, same single GPU, and the load-bearing piece is maintained software.

Who should switch — the verdict

Switch now if you have a 24GB GPU, your code can’t leave your machine (client contracts, regulated codebase, or plain principle), and agent work matters more to you than best-in-class autocomplete. The corrected stack replaces a $240/year Devin Pro seat outright, and every component except frozen Continue is actively maintained.

Don’t switch if Devin’s Tab completions or cloud codebase indexing are the features you actually use daily, or if your GPU tops out at 8–12GB — a 7B-class model will make the whole stack feel like a downgrade and you’ll blame the wrong component. Devin Desktop Free covers the autocomplete-only use case at the same $0 without the hardware.

Nobody should adopt the stack as the viral posts describe it — Continue.dev in the agent seat — without understanding they’re standardizing on software that stopped moving in June.

FAQ

Is Continue.dev safe to keep using at v2.0.0? Locally, yes, with eyes open: v2.0.0 removed telemetry and login, so it makes no network calls beyond your configured endpoint. The risk isn’t spying — it’s unpatched bugs and eventual breakage against a future VS Code release, with no maintainer to fix either.

Can Devin Desktop run a local model if I bring my own key? No. BYOK on Devin Desktop covers select cloud models only, and your requests still route to that provider’s API. There is no supported local-weights path — this is the stack’s single biggest structural advantage over it.

Do I need Open WebUI at all? It’s the optional third of the stack. Continue and Cline talk to Ollama directly. Add Open WebUI when you want a persistent chat workspace, document RAG, or shared access for more than one person on the same GPU box.

What about the Open WebUI license for team deployments? The current license adds a branding-preservation requirement on top of the historically permissive terms. Solo use: irrelevant. Deploying a rebranded internal instance for a company: read the LICENSE file first.

What hardware does this realistically need? 24GB VRAM for Qwen3.8-27B Q4_K_M with usable context — an RTX 3090 or 4090. Below that, drop to a 14B-class model and lower your expectations for agent tasks. Hardware sizing is covered in depth at runaihome.com.

Sources

• continuedev/continue — repository (read-only notice, Apache 2.0, final v2.0.0)
• Continue v2.0.0 docs — Ollama provider configuration
• open-webui/open-webui — README (install commands, license, Ollama integration)
• Open WebUI docs — Continue.dev integration tutorial
• Devin pricing — official page (tiers cross-checked September 6, 2026 against Automation Atlas and CostBench)
• Devin Desktop BYOK and model options — Bodega One
• Cursor quietly acquires Continue — The New Stack
• Why I’m Using Open WebUI & Continue.dev (and Stepping Back from Windsurf) — Medium

Last verified September 6, 2026. Pricing and features change frequently; verify current state before purchasing.

Know which coding tool is worth paying for

Hands-on comparisons of AI coding assistants and what each one costs to run — including the local-model path. Sent only when something changes. Unsubscribe anytime.

Email address Subscribe