Continue and Cursor are no longer two competing products to choose between: Continue was acquired by Cursor, its repository is read-only, and the part of it still documented to work is the part you configure yourself in a local file. Cursor is the side still shipping, and since August 14, 2026 it is a wholly owned SpaceX subsidiary. So the real question is not which agent has better features — it is whether you want a frozen client you can point at any OpenAI-compatible endpoint, or a maintained product whose model access is Cursor's to define.
continue.dev is now a single page titled "Continue (acquired by Cursor)", and the repository README opens with a note that the repo "is no longer actively maintained and is read-only for all users". The newest commit on main is dated July 21, 2026 and removes the sign-in link because the login flow was retired. On the other side, Cursor's docs now say it supports models from "OpenAI, Anthropic, Google, SpaceXAI, and more", and its first-party pool is Grok and Composer. All checked September 19, 2026.
Which one should you pick
Because one side is frozen, the decision turns on five concrete things: how you work, who approves the agent's actions, whether your model choice is yours or the vendor's, where the bill lands, and what it costs to move.
| Your situation | Pick | Why, specifically |
|---|---|---|
| You want a client that will still receive fixes next year | Cursor | Continue's repository is read-only per its own README, so no one is committing fixes to it if a provider changes its API |
| Your model must come from a third-party OpenAI-compatible endpoint | Continue | Its config takes apiBase per model; Cursor's documented custom-key surface names five vendors and no arbitrary base URL, and its CLI reference documents neither |
| You want one editor, Tab completion and an agent that a vendor keeps current | Cursor | Tab keeps using Cursor's built-in models even when you paste your own key, and the Pro tier includes both usage pools |
| You run headless in CI and want the token bill to be the whole bill | Continue | The CLI README documents cn -p as headless mode with no TUI, and there is no subscription in front of it — but see the config note below |
| You are on a team and the extra per-token charge matters | Depends | Cursor Teams and Enterprise add $0.25 per million tokens to every third-party model request, including ones made with your own key |
You already have a large .continue/rules tree | Continue, for now | Neither vendor documents an importer in either direction; Cursor reads .cursor/rules, user rules, team rules or AGENTS.md, so migration is a rewrite |
One note before you lean on the Continue column. Its CLI configuration page says cn resolves configuration from a --config file path, then a saved config, then the default ~/.continue/config.yaml — so keep the models written inline in a local file you control. The same page shows launch flags that take a namespaced slug, such as cn --agent my-org/pr-reviewer; that is a namespaced slug rather than the file path the --config flag takes, and with the repository read-only and the login flow retired this page cannot tell you what such a slug resolves to today. Prefer the local file over anything that has to be fetched.
What each product actually is today
| Continue | Cursor | |
|---|---|---|
| Status | Acquired by Cursor; repository read-only, last commit to main July 21, 2026 | Maintained; wholly owned SpaceX subsidiary since August 14, 2026 |
| Licence | Apache 2.0, source stays on GitHub | Proprietary |
| Terminal client | cn, npm @continuedev/cli 1.5.47 (June 18, 2026) | agent, installed from cursor.com/install |
| Editor surface | VS Code extension (Open VSX 2.1.0 pre-release) and JetBrains plugin (Marketplace 1.0.67); the README steers JetBrains users to the CLI | The Cursor editor, plus ACP, which Cursor documents for JetBrains IDEs |
| Account required | The repo README says authentication was pulled out in the final 2.0.0 release; the CLI README still lists cn login, and npm's latest is 1.5.47 — check the build you install | Yes — agent login or a Cursor-issued key |
| Hosted services | The account layer is retired: the last commit removes the sign-in link and says the login flow was retired | Cloud Agents, Bugbot, dashboard, team controls |
| Config location | ~/.continue/config.yaml, documented as the same format the IDE extensions use | ~/.cursor/cli-config.json; project .cursor/cli.json holds permissions only |
Two source disagreements worth knowing rather than papering over. The README calls the repo read-only while the GitHub API reports archived: false, with a pushed_at later than any commit on main and a live open-issue count in the hundreds. And the README's "final 2.0.0 release" line, which it applies to all three artifacts, matches none of the registries: Open VSX serves 2.1.0 as a pre-release dated June 19, 2026 above a stable 2.0.0, npm serves the CLI at 1.5.47, and JetBrains Marketplace serves the plugin at 1.0.67. Quote the artifact you installed, not the README line.
The decisive difference: where the model key lives
This is the axis that actually separates them, and it is not symmetrical. Continue's config.yaml reference documents apiBase as a field that "can be used to override the default API base that is specified per model", and its OpenAI provider page shows provider: openai with an apiBase carrying the /v1 suffix — the protocol, not the vendor. The same reference lists the roles a model entry can fill — chat, autocomplete, embed, rerank, edit, apply, summarize, defaulting to [chat, edit, apply, summarize] — and notes that the tool_use capability is "required for Agent mode". That reference documents no plan tier or account as a condition on any of those fields.
Cursor documents the opposite shape. Its bring-your-own-key help page tells you to open Cursor Settings, find OpenAI, Anthropic, Google, Azure OpenAI or AWS Bedrock, and paste a key. It is a vendor list, and the only customer-owned endpoints on it are the Azure OpenAI and Bedrock ones the same page describes — "Models deployed in your Azure OpenAI Service instance" and models "available in your Bedrock configuration". There is no field on that page for an arbitrary OpenAI-compatible base URL. It also states that "Custom API keys only work with chat models" and that Tab keeps using Cursor's built-in models. The Cursor CLI authentication reference documents exactly two methods, browser login and a Cursor-issued CURSOR_API_KEY; it documents no provider key and no endpoint option. Community threads describe an "Override OpenAI Base URL" field with plan-dependent visibility — that is forum evidence, it appears in none of the Cursor documentation checked here, and this page neither treats it as a supported configuration nor claims it does not exist. Everything below is about what Cursor documents.
| Question | Continue | Cursor |
|---|---|---|
| Arbitrary OpenAI-compatible endpoint? | Yes — provider: openai plus apiBase, documented with an example | Not in the Cursor docs checked here; Azure OpenAI and Bedrock reach your own deployment, not an arbitrary one |
| Which roles a model entry can declare | The schema's full role list — chat, autocomplete, embed, rerank, edit, apply, summarize; it does not carve out custom endpoints | Chat models only; Tab stays on Cursor's models |
| Does your own key draw plan usage? | No plan exists | Individual plans: no. Teams and Enterprise: the $0.25 per million Cursor Token Rate still applies |
| Terminal client BYOK | Same config format as the editors, read from ~/.continue/config.yaml | None in the documented surface |
| Who sees the request | Your endpoint | Cursor's backend, which its help page says builds the final prompt |
Two boundaries to note if you take the Continue route. First, copy the /v1 suffix: Continue's own OpenAI-compatible example writes apiBase as http://localhost:8000/v1, and Kunavo's Continue setup prints the full https://api.kunavo.com/v1 for the same reason. Second, Kunavo does not serve the embed or rerank roles — no model in the Kunavo catalog answers an embedding request — so point those entries at a local embedder or an outside provider and keep Kunavo for the chat, edit, apply and autocomplete entries. For the Anthropic-shaped route, the generic reference documents apiBase while the Anthropic provider page never mentions it, so treat that path as plausible rather than documented and confirm it in your own setup; the Messages endpoint is where it would land.
What Cursor charges
| Plan | Published price | Cursor Models pool | Other Models pool |
|---|---|---|---|
| Hobby | Free | Agent, Chat and Tab with the Auto model, limited usage | Not listed on the plan table |
| Start (India only) | ₹649/mo, tax inclusive | Included | Not included |
| Pro | $20/mo | Included | Included |
| Pro Plus | $60/mo | Included | Included |
| Ultra | $200/mo | Included | Included |
| Teams Standard | $40/user/mo | Included | Included, plus the Cursor Token Rate |
| Teams Premium | $120/user/mo | 5x Standard agent limits | Included, plus the Cursor Token Rate |
Read from Cursor's models and pricing documentation on September 19, 2026, except the Hobby row, which comes from Cursor's pricing help page — Hobby is not on the plan table in the docs at all. Three things that table does not say. Cursor publishes no dollar value for what any plan includes — only behavioural guidance, and its own numbers are "Daily Agent users: Typically $60–$100/mo total usage" and "Power users (multiple agents/automation): Often $200+/mo total usage". Start is India-only and explicitly excludes the Other Models pool, on-demand usage, Bugbot and Auto, so it is not a cheap global tier. And on Teams and Enterprise, every third-party model request carries a Cursor Token Rate of $0.25 per million tokens on input, output and cached tokens alike, applied on top of model API pricing "for included usage, on-demand usage, and BYOK usage"; first-party Grok and Composer are exempt. Two documented uplifts sit outside that table as well: opting in to regional data residency adds 10% on eligible models, and Max Mode, which exists only on legacy request-based plans, bills at the model's API rate plus 20%. Annual pricing is not stated here.
A worked cost estimate for the Continue side
These are illustrative token arithmetic, not measured task costs and not a bill ceiling. Assume one agent session that sends 400,000 uncached input tokens and receives 25,000 output tokens. The Cursor column uses Cursor's published Other Models rates for a model of that name; the Kunavo column uses live catalog rates for the Kunavo model id you would put in config.yaml. They are not interchangeable columns — one is reachable inside Cursor, the other inside Continue or another client that accepts a base URL.
| Model | Cursor list, in / out per 1M | Kunavo catalog, in / out per 1M | Session at Cursor's rate | Session at Kunavo's rate |
|---|---|---|---|---|
| Claude Sonnet 5 | $2.00 / $10.00 | $2.00 / $10.00 | $1.050 | $1.050 |
| Claude Opus 5 | $5.00 / $25.00 | $2.00 / $10.00 | $2.625 | $1.050 |
| Gemini 3.1 Pro | $2.00 / $12.00 | $0.70 / $4.20 | $1.100 | $0.385 |
| GPT-5.6 Terra | $2.00 / $12.00 | $0.70 / $4.20 | $1.100 | $0.385 |
Three readings, and the third is the one people get wrong. Cursor documents the Other Models pool as "charged at the model's API price", with no markup for individual plans beyond the two opt-in uplifts noted above — so where the two columns match, as they do on Claude Sonnet 5, the argument for a gateway is model access and portability, not a discount. Where they differ, the gap is a catalog difference, not a promise about your total. On a Teams or Enterprise plan the same session adds a further $0.106 at the $0.25 per million Cursor Token Rate, on top of whichever rate applies. And cheapest listed price is not lowest cost to finish the task: a model that needs three attempts can cost more than a dearer one that needs a single pass, so measure on your own repository before ranking by rate.
A cheaper lane exists for the high-volume roles. Continue's autocomplete role fires on keystrokes, so a separate entry naming a small model — Claude Haiku 4.5 lists at $0.40 in and $2.00 out per million — usually moves the monthly total more than any other single setting. Kunavo's catalog amount is a billing floor rather than a cap: when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost times the applicable markup. Cache charges and external tools sit outside this example. The minimum top-up is $10 in prepaid credit, which is a funding minimum rather than a subscription — see billing details.
Migration cost, in both directions
Neither side documents an importer. Continue keeps project rules in a .continue/rules folder in the workspace; Cursor's rules documentation lists project rules in .cursor/rules as .mdc files, user rules, team rules on Team and Enterprise plans, and AGENTS.md as a simpler alternative. Rewriting those is the visible cost. The less visible one is that a Continue setup pointed at an arbitrary third-party endpoint has no documented destination in Cursor, so a move is also a change of billing model — from metered tokens you control to a subscription plus metered third-party usage.
Going the other way is cheaper to start and riskier to keep: Continue takes an apiBase for any OpenAI-compatible endpoint, but you are adopting a client whose repository is read-only. If what you actually wanted from Continue was the freedom to choose the endpoint, a client that still ships and has the same freedom is the better destination — Cline, OpenCode and Zed each take a custom base URL in their Kunavo setup guides. Cursor alternatives covers that shortlist, and Claude Code vs Cursor handles the terminal-versus-editor question without repeating it here.
If you take the Continue route
Kunavo publishes a configuration reference for Continue. That is a published setup guide, not a compatibility test: Continue has not been runtime-tested here against api.kunavo.com, and every behavioural claim above comes from Continue's own documentation, its repository and the package registries. Write the models inline in ~/.continue/config.yaml rather than relying on any Hub slug, keep a working route available while you try it, run one bounded task, then read the charge your account recorded for it. Start at the Continue integration guide, and create a Kunavo account when you are ready to fund a key.
Still comparing clients rather than endpoints? Cline vs Cursor and Zed vs Cursor ask the same question of clients that are still shipping, and the OpenAI-compatible API explainer covers why provider: openai names a protocol rather than a vendor.
FAQ
Is Continue still maintained?
No. The README on continuedev/continue states that the repository is no longer actively maintained and is read-only for all users, and continue.dev is now a single page saying Continue was acquired by Cursor. The last commit to main is dated July 21, 2026 and is titled "docs: remove Sign in link (login flow retired)". The GitHub API still reports archived: false, with tens of thousands of stars and close to a thousand open issues, which contradicts the README's wording, so read both rather than either alone. Checked September 19, 2026.
Does Continue still work after the Cursor acquisition?
The part you configure locally is still published; the hosted side is not something this page can vouch for. The packages remain downloadable — Open VSX serves the VS Code extension, JetBrains Marketplace serves the plugin, npm serves the CLI — and the documented config file still drives model selection. What changed is the account layer: the last commit on main removed the sign-in link and its message says the login flow was retired. Continue's own CLI configuration page documents a plain local path, ~/.continue/config.yaml, and a --config flag that takes a file path, so a configuration that names its models inline has no hosted dependency to lose. Whether Continue's remaining hosted endpoints still answer is not something this page tested. Nobody will ship a fix if a provider changes its wire format.
What version of Continue CLI should I install?
Whatever npm actually serves, which is not 2.0.0. The README says a "final 2.0.0 release" was done for the VS Code extension, the CLI and the JetBrains plugin, but no registry agrees with that number: npm serves @continuedev/cli at 1.5.47, published June 18, 2026, with no deprecation flag and 332 versions in total; Open VSX serves the VS Code extension at 2.1.0, marked pre-release, dated June 19, 2026, above a stable 2.0.0; JetBrains Marketplace serves the plugin at 1.0.67, from March 2026. Install and check what you got rather than quoting the README line. Checked September 19, 2026.
Can I use my own API key with Cursor?
Partly, and the documented path is the editor. Cursor's help page documents pasting a key for OpenAI, Anthropic, Google, Azure OpenAI or AWS Bedrock under Cursor Settings > Models, and states that custom API keys only work with chat models while Tab completion continues using Cursor's built-in models. Two of those five — Azure OpenAI and AWS Bedrock — run against your own deployment, so "your own endpoint" is possible there; what that page does not document is a base-URL field for an arbitrary OpenAI-compatible server. The Cursor CLI authentication reference documents browser login and a Cursor-issued CURSOR_API_KEY and no provider key or endpoint option. Checked September 19, 2026 against the Cursor pages linked on this page; that is what is documented, not a statement about what the product can be made to do.
Is Continue vs Cursor a cost comparison any more?
Not a like-for-like one. Continue is Apache 2.0 and charges nothing as software, so what you pay is whatever the endpoint you configured charges. Cursor bills a subscription — Pro $20, Pro Plus $60, Ultra $200, Teams $40 or $120 per user per month — and then meters third-party models at their API list price, with an extra $0.25 per million tokens on Teams and Enterprise. The honest framing is that you are comparing a maintained product with included usage against an unmaintained client with no floor and no ceiling, not comparing two price lists.
Can I move my Continue configuration into Cursor?
Not automatically. Continue keeps project rules in a .continue/rules folder in the workspace; Cursor reads .cursor/rules, user rules, team rules on Team and Enterprise plans, and an AGENTS.md file. Neither vendor documents an importer in either direction. Expect to rewrite rules by hand, re-declare MCP servers, and re-create model entries — and note that Cursor's documented custom-key surface has no field for an arbitrary OpenAI-compatible base URL, so a Continue setup pointed at a gateway has no documented equivalent on the other side.
Who owns Cursor now?
Per the Wikipedia article on Cursor (company), SpaceX announced on June 16, 2026 that it was exercising a purchase right in an all-stock deal, and the acquisition closed on August 14, 2026, with Cursor surviving as a wholly owned subsidiary being integrated into the SpaceXAI team. The product reflects it: Cursor's first-party model pool is Grok 4.6, Grok 4.5 and Composer 2.5, and its documentation lists SpaceXAI among the vendors it supports. The cursor.com footer still names Anysphere, Inc. as the legal entity.
Checked September 19, 2026 against continue.dev, the continuedev/continue README and CLI README, the GitHub, npm, Open VSX and JetBrains Marketplace listings, docs.continue.dev, and Cursor's own models-and-pricing, rules, CLI and bring-your-own-key documentation. The SpaceX acquisition date comes from Wikipedia, not from a dated post on either company's own site. Neither client was runtime-tested against Kunavo or against any endpoint, no benchmark was run, no host was probed, and every dollar example is illustrative token arithmetic at live catalog rates. Where a document is silent — Cursor on custom base URLs, Continue on what its retired hosted endpoints still answer — this page says the document is silent rather than filling the gap.