TL;DR: Cursor acquired Continue.dev in June 2026, the hosted cloud went dark on July 15, and the open-source extension is frozen at v2.0.0 forever. The extension still installs and still runs local Ollama models perfectly well — but “works today, unmaintained forever” is a countdown, not a steady state. Plan your exit now, panic never.

	Keep Continue v2.0.0	Switch to Cline	Switch to Zed
Best for	Free local FIM autocomplete in VS Code, today	Agentic multi-file work in VS Code	Autocomplete + agent + offline edit prediction, new editor
Price	$0 + your Ollama models	$0 extension, BYOK/local	$0 editor, BYOK/local
License	Apache 2.0, repo read-only	Apache 2.0, active (v4.0.10, Jul 20)	GPL-3.0 + Apache-2.0 components, active (v1.11.3, Jul 15)
The catch	No updates, no security patches, ever	No inline autocomplete — it’s an agent, not ghost text	You have to leave VS Code

Honest take: Nothing in VS Code replaces Continue’s free local-model ghost text today, so keep running v2.0.0 for autocomplete — but treat it like an appliance that’s out of warranty. Move your agentic workflows to Cline this month, and when the frozen extension eventually breaks against a VS Code update, Zed is where the full local stack lives.

Continue.dev was the tool we recommended every time someone asked for Copilot-style completions without a subscription — we published a full setup guide, an LM Studio variant, a multi-language config guide, and an autocomplete troubleshooting piece as recently as July 18. Four days later, the ground has finished shifting under all of them: the acquisition is closed, the export deadline has passed, and the repository is read-only. Here’s exactly what’s left, verified July 22, 2026.

What actually happened, with dates

The news broke quietly. Around June 16, 2026, Continue’s homepage and FAQ flipped to past tense — “Continue has been acquired by Cursor” — and the formal announcement followed on June 18. Terms were not disclosed. It was an acqui-hire in the classic sense: Cursor wanted the team, not the product. The timing folds into the bigger story we’ve been tracking — Anysphere itself was acquired by SpaceX in a $60 billion deal announced the same week, so Continue’s engineers are now, two hops removed, SpaceX employees.

The wind-down moved fast:

• June 18, 2026 — acquisition announced; standalone product declared end-of-life
• June 19, 2026 — final release v2.0.0 tagged for the VS Code extension, JetBrains plugin, and CLI; the release commit is co-authored by Cursor
• After v2.0.0 — the continuedev/continue repository (35k stars) went read-only for all users, with the notice “no longer actively maintained”
• July 15, 2026 — hosted cloud shut down; the data-export window closed and remaining user data was deleted

That last date is a week behind us. If you had shared assistants, team configs, or usage data in Continue’s cloud and didn’t export, it’s gone — there is no late-export appeal process, because there is no service left to appeal to. And this isn’t a polite “service unavailable” page: as of this morning, a DNS lookup for hub.continue.dev returns no record at all (ENOTFOUND — the hostname no longer exists). Whatever your config pointed at there is not coming back.

Dead vs. alive: the precise inventory

The confusion in every Reddit thread about this comes from conflating two different products that shared one name. Continue the company ran a cloud: hub.continue.dev with shareable assistants and blocks, hosted model access, team config sync, and account login. Continue the extension is Apache 2.0 code that runs on your machine and talks to whatever model endpoint you give it.

Dead as of July 15: the hub and its shared assistants/blocks, account login, hosted models billed through Continue, team config sync, and any config that resolves against Continue’s servers.

Still alive as of July 22: the VS Code extension on the Marketplace and OpenVSX, the JetBrains plugin via GitHub Releases, the CLI on npm (@continuedev/cli), your local ~/.continue/config.yaml, and every local or BYOK provider — Ollama, LM Studio, or a direct API key. The v2.0.0 release actually made the survivor more self-contained: the final changelog’s headline items were removing anonymous telemetry and pulling out authentication entirely. There is no login to fail, and nothing phones home. Frozen, but genuinely local.

The code stays Apache 2.0 (copyright Continue Dev, Inc., 2023–2026), which means forks are legal and inevitable. As of today no fork has meaningful momentum — watch that space, because a maintained community fork would change the calculus below.

The config trap that bites first: uses: blocks

Here’s the failure mode that’s actually hitting people this week, and it looks nothing like a shutdown notice. Continue’s config.yaml supported two ways to declare a model: inline, or by reference to a hub block:

# This shape is now broken — it resolves against hub.continue.dev
models:
  - uses: anthropic/claude-sonnet-4-6
    with:
      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Every uses: line — models, rules, prompts — resolved against the hub at load time. With the hub’s DNS gone, those references fail, and depending on your version the symptom is a missing model in the picker or a config that silently half-loads. If your Continue “randomly stopped working” in mid-July, this is almost certainly why, not the extension itself.

The fix is mechanical: replace every uses: block with its inline equivalent. For local models you probably wrote inline configs already; for API models, declare provider, model, and apiKey directly. Once your config.yaml contains zero uses: references, nothing in the extension depends on any Continue-operated server.

The Ollama setup that still works on v2.0.0

This config is the fully-inlined, no-cloud shape, straight from the (now frozen) official docs and re-tested today on v2.0.0. Pull the two models first:

$ ollama pull qwen2.5-coder:7b     # chat + edit, ~5 GB download
$ ollama pull qwen2.5-coder:1.5b   # autocomplete (FIM), ~1 GB

Run ollama list afterward and confirm both tags appear — the model strings in your config must match that output character-for-character, or the model silently won’t load. Then ~/.continue/config.yaml:

name: Local Assistant
version: 1.0.0
schema: v1

models:
  - name: Qwen2.5-Coder 7B
    provider: ollama
    model: qwen2.5-coder:7b
    apiBase: http://localhost:11434
    roles:
      - chat
      - edit
      - apply
    defaultCompletionOptions:
      contextLength: 32768

  - name: Qwen2.5-Coder 1.5B
    provider: ollama
    model: qwen2.5-coder:1.5b
    apiBase: http://localhost:11434
    roles:
      - autocomplete

Three rules keep this working, all unchanged from before the acquisition. The model string must match ollama list exactly. Autocomplete needs its own entry with roles: [autocomplete] and a FIM-capable model — the frozen docs recommend qwen2.5-coder:1.5b or starcoder2:3b, and a chat-only config produces the classic no-ghost-text symptom we documented in detail. And set contextLength explicitly, because Ollama’s default context silently truncates long files from the top. If the extension can’t reach Ollama at all, that’s the connection-refused checklist, also unchanged.

There’s a pleasant surprise buried here: because Ollama’s API surface is stable, new models keep working in the frozen extension. ollama pull whatever ships next quarter, point a models: entry at it, and Continue neither knows nor cares that it was released after the project died. The freeze is on the extension’s side of the interface, not the model side. For picking models by VRAM budget, our sister site’s local model guide is the reference we keep linking for a reason.

How long can you ride a frozen extension?

Honestly: probably 6–18 months, and the clock is not in your control. Three separate things have to keep holding.

VS Code’s extension API has to stay compatible. Microsoft ships monthly, deprecations land with notice, and breakage is gradual rather than instant — but v2.0.0 will never adapt to anything. When a VS Code update changes inline-suggestion behavior, Continue’s ghost text degrades and nobody fixes it. Second, security. An unmaintained extension with filesystem access is exactly the category the recent wave of AI-tool CVEs has been mining — we’ve covered symlink escapes and MCP credential theft this quarter alone. If a vulnerability is found in Continue’s code, the patch ships never. Third, distribution: a delisted Marketplace entry (it remains listed today) would leave only sideloading the .vsix from GitHub Releases, which stay up as long as the read-only repo does.

None of this argues for uninstalling today. All of it argues against making a frozen extension a bigger part of your workflow than it already is. Which raises the real question.

The three real alternatives, by use case

The queue of “just switch to X” replies under every acquisition thread mostly ignores what Continue actually did for people. It occupied two distinct slots — free local inline autocomplete, and a chat/edit agent — and no single tool fills both inside VS Code. Verified state of the three serious candidates, checked today:

	Cline	Aider	Zed
What it is	VS Code agent extension	Terminal pair programmer	Standalone editor
License	Apache 2.0	Apache 2.0	GPL-3.0-or-later (+ Apache-2.0 components)
Stars	64.9k	47.6k	87.4k
Latest release	v4.0.10 — Jul 20, 2026	v0.86.0 — Aug 9, 2025	v1.11.3 — Jul 15, 2026
Inline autocomplete	No	No (terminal tool)	Yes — incl. offline Zeta2
Ollama support	Yes	Yes (ollama_chat/)	Yes, first-class

A correction worth making explicit, because the license question matters more after watching an Apache-2.0 project get acqui-hired: Aider is Apache-2.0, not MIT as often repeated, and Zed is not a permissively-licensed editor — the core is GPL-3.0-or-later. GPL cuts both ways here: it’s the license that makes a quiet Continue-style absorption structurally harder, which after this month reads as a feature.

Cline is the migration target for Continue’s chat/edit/agent half. Same editor, same Ollama endpoint, dramatically more capable agentic loop, and shipping constantly — three releases in the week before this article. What it does not do is ghost text. If you install Cline expecting Copilot-style completions, you’ll be confused; it’s a plan-and-execute agent, and our Cline + local model guides carry over your Ollama investment directly.

Aider covers the terminal-native slot, and it’s the right answer if your Continue usage was really “chat about my repo and apply diffs.” One honest flag: its last tagged release is v0.86.0 from August 2025 — the repo shows ongoing commits, but a year without a release is a cadence you should price in, especially if you’re leaving Continue because it stopped shipping. Our Aider + Ollama setup still applies as written.

Zed is the only one that replaces the autocomplete half with something better for local-first users: its Zeta2 edit-prediction model is open-weight, so inline completions can run fully offline via Ollama — no other editor self-hosts its completion model. We walked the whole config in our Zed + Ollama setup guide last week. The cost is the editor switch itself, which is a real cost; nobody rebinds a decade of VS Code muscle memory because of one acquisition.

If you want the wider FOSS field — Tabby, self-hosted servers, the long tail — aifoss.dev’s Ollama coverage maintains the map, and we covered the same triage logic when Roo Code shut down in May. The pattern is now recurring often enough to be a rule: free AI coding tools with venture-funded parents have a shelf life, and the local, open pieces of your stack are the parts that survive.

Verdict

Run the frozen Continue v2.0.0 for what it’s uniquely good at — free local FIM ghost text in VS Code — after stripping every uses: reference from your config. Move agentic work to Cline now rather than at breakage time; the switch costs an afternoon and the Ollama config transfers almost line-for-line. Put Zed on the calendar as the destination when v2.0.0 finally loses its fight with a VS Code update. What you should not do is nothing: unmaintained-with-filesystem-access is not a category to still be depending on in 2027.

FAQ

Does the Continue extension stop working now that the cloud is gone? No. v2.0.0 with an inline config.yaml and a local or BYOK provider runs with no Continue-operated service in the loop. Only uses: hub references, account login, and hosted-model billing broke on July 15.

Can I still install Continue fresh today? Yes — VS Code Marketplace and OpenVSX still list the extension, the JetBrains plugin is on the repo’s GitHub Releases, and the CLI is on npm. What you install is final: v2.0.0, no future updates.

I missed the July 15 export deadline. Can I recover my hub data? No. The announced policy was deletion after the deadline, and the hub’s DNS record no longer exists. Local files — ~/.continue/config.yaml, rules, prompts on disk — were never in the cloud and are unaffected.

Will Cursor open-source anything back, or maintain Continue? There’s no indication of either. The repo is read-only, the final release was cut jointly with Cursor, and the team now works on Cursor’s commercial product. The Apache 2.0 license means anyone can fork; as of July 22 no fork has critical mass.

What’s the closest like-for-like replacement for Continue’s free local autocomplete in VS Code? There isn’t a clean one — that’s the uncomfortable answer. Continue v2.0.0 remains the best free local ghost text inside VS Code. Zed offers a better local autocomplete story but requires changing editors; Cline replaces the agent half only.

Sources

• Cursor quietly acquires Continue, an open-source alternative to GitHub Copilot — The New Stack
• continuedev/continue — GitHub repository (read-only notice, Apache 2.0, 35k stars)
• Continue v2.0.0-vscode final release — GitHub Releases
• Continue config.yaml reference — frozen official docs (repo)
• Continue Ollama guide — frozen official docs (repo)
• cline/cline — GitHub (Apache 2.0, v4.0.10 Jul 20 2026)
• Aider-AI/aider — GitHub (Apache 2.0, v0.86.0)
• zed-industries/zed — GitHub (GPL-3.0-or-later, v1.11.3 Jul 15 2026)

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