Continue CLI vs Claude Code: workflow, models and total cost

These two are not competing purchases any more. Continue's CLI is an Apache-2.0 client whose repository is read-only and whose last published version is 1.5.47 from June 18, 2026; Claude Code published 2.1.278 on September 19, 2026 and is still under active release. So the real question on this URL is not "which is better" — it is whether you are running cn today and what migrating costs, or whether you are about to adopt a client that its own repository describes as unmaintained.

Continue's README on branch main states that the repository "is no longer actively maintained and is read-only for all users", and continue.dev now serves a single page titled "Continue (acquired by Cursor)" whose body says "Continue has joined Cursor". One thing to clear up first: Cursor is the acquirer, not the product. Cursor's plan prices are Cursor's, and they are not what Continue costs or ever cost. Everything below was checked September 21, 2026.

Which one should you pick, and in which direction

This page owns both directions, so here are the conditions rather than a winner.

Stay on Continue CLI when you need an Apache-2.0 client you are willing to fork and carry yourself; when you want one endpoint reached over the OpenAI-compatible protocol; or when per-role model assignment is the feature you actually use — a cheap model on autocomplete, a large one on chat, a split Claude Code's documented model settings have no equivalent for. The cost of staying is explicit: no upstream fixes, and the published 1.5.47 package contains the string hub.continue.dev nowhere at all, so any documentation step that resolves a hub slug describes a build you cannot install from npm today.

Move to Claude Code when you want a client that is still receiving releases, when you want layered permission machinery rather than three policies applied by flags and a permissions.yaml, and when you are content with the Anthropic Messages protocol and the Claude family — Anthropic documents no OpenAI-compatible format for that route, and says it "doesn't support routing Claude Code to non-Claude models through any gateway". The cost of moving is that your config.yaml does not translate, the base-URL convention is inverted, and a third-party credential switches off several account-linked features listed further down.

Pick neither when you want an OpenAI-compatible client that is also actively maintained. That is the one requirement neither side satisfies, and it is a different shortlist — see Continue alternatives.

The two products, precisely

Versions read from the Continue CLI and Claude Code registry entries on September 21, 2026. Two official contradictions are worth carrying rather than smoothing over. First, Continue's README announces "a final 2.0.0 release of the VS Code extension, CLI, and JetBrains plugin", but npm has no 2.x of the CLI at all — latest is 1.5.47. Second, the same README calls the repository read-only while the GitHub API reports archived: false and disabled: false; the newest commit on main is from July 21, 2026, with the subject "docs: remove Sign in link (login flow retired)". Only the maintenance statement is load-bearing.

And treat Continue's own CLI documentation as a record of intent rather than instructions. The quickstart still lists "A Continue account, or an Anthropic API key" as a requirement and documents cn login and a CONTINUE_API_KEY environment variable. In the published 1.5.47 package the shipped runtime bundle, dist/index.js, contains no occurrence of CONTINUE_API_KEY — the string survives only in the tarball's docs and test sources — and hub.continue.dev appears nowhere in the package at all. The docs outlived the build they describe.

Workflow, permissions and what runs without asking

From Continue's tool permissions and headless mode pages and Anthropic's permission modes page, all read September 21, 2026. Documentation, not runtime tests. The practical difference is the direction each one leans: Continue makes an unattended run deliberately incapable of writing until you widen it on the command line, while Claude Code on a consumer plan starts in a mode where a classifier approves actions on your behalf. One is a gate you open; the other is a gate someone else is holding.

Pointing either client at your own endpoint

This is where migration actually costs time, because the two clients put the endpoint in completely different places and write it in opposite shapes. Continue's configuration reference documents no global base-URL environment variable — the address goes in a models: entry, where provider: names the wire protocol, not the vendor.

name: kunavo
version: 0.0.1
schema: v1
models:
  - name: Claude Sonnet 4.6
    provider: openai          # the wire protocol, not the vendor
    model: claude-sonnet-4-6
    apiBase: https://api.kunavo.com/v1    # apiBase CARRIES /v1
    apiKey: sk-kn-...
    roles: [chat, edit, apply]

  - name: Fast completions
    provider: openai
    model: claude-haiku-4-5
    apiBase: https://api.kunavo.com/v1
    apiKey: sk-kn-...
    roles: [autocomplete]

Claude Code takes two environment variables instead, and ANTHROPIC_BASE_URL is an origin with no path, because the client appends /v1/messages itself. Anthropic's own verification command is curl -X POST "$ANTHROPIC_BASE_URL/v1/messages", which shows the concatenation directly.

export ANTHROPIC_BASE_URL=https://api.kunavo.com   # origin, NO /v1
export ANTHROPIC_AUTH_TOKEN=sk-kn-...             # Authorization: Bearer

claude

That inversion is the single sentence worth carrying out of this page: Continue's apiBase carries /v1; Claude Code's ANTHROPIC_BASE_URL must not. Copying one value into the other produces either a 404 on /v1/v1/messages or requests to a path that does not exist. The ANTHROPIC_BASE_URL page covers the rest of that route's failure modes, and the Continue setup has the config shape above in full.

Three traps specific to Continue, each read from source on September 21, 2026 rather than executed. First, first run: with no --config, a TTY attached and CONTINUE_USE_BEDROCK unset, onboarding prints "To get started, enter your Anthropic API key." and rejects anything not starting with sk-ant-. The same function has several earlier exits: --config <file>, CONTINUE_USE_BEDROCK=1, and a branch that skips the prompt when stdin is not a TTY or when NODE_ENV=test, CI=true, VITEST=true or GITHUB_ACTIONS=true is set. Second, if you do give it an sk-ant- key, onboarding writes provider: anthropic blocks with no apiBase, hardwiring the vendor endpoint; repointing is a manual edit afterwards. Third, if you use provider: anthropic with an apiBase, Continue's Anthropic provider joins the path as new URL("messages", apiBase), which is trailing-slash sensitive: a base ending /v1/ gives /v1/messages, while the same string without the slash sends requests to /messages at the host root. Neither Continue provider page read for this guide warns about it.

And one boundary on the Claude Code side, from three separate Anthropic pages. The LLM gateway page says that while a gateway credential variable or an apiKeyHelper is active, "a developer's claude.ai subscription isn't used", and that Anthropic "doesn't endorse, maintain, or audit third-party gateway products, and doesn't support routing Claude Code to non-Claude models through any gateway". The connect page says Remote Control and voice dictation are unavailable while ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN or an apiKeyHelper is active. And the gateway compatibility guide says gateway model discovery is off by default, and that when it is enabled Claude Code keeps an entry only when its id contains "claude" or "anthropic".

What each vendor charges, on one footing

Plan figures from claude.com/pricing, read September 21, 2026. One disagreement to settle in checkout: that page rendered both Max tiers as "From $100/month" in this fetch, while Anthropic's Max plan help-centre article gives $100 for Max 5x and $200 for Max 20x and adds that prices are subject to change. Confirm the tier you want at checkout rather than from either page alone.

On the Continue side there is genuinely nothing to quote, and that is the finding. Third-party review sites still publish Continue Hub plan tables — a per-million-token Starter tier, Team and Company tiers — and none of it appears on continue.dev, whose /pricing path returns 404. A historical price is not a current one, so this guide prints none.

For a published anchor on what the work itself costs, Anthropic's cost documentation reports that "Across enterprise deployments, the average cost is around $13 per developer per active day and $150-250 per developer per month, with costs remaining below $30 per active day for 90% of users", with background functionality typically under $0.04 per session. That is Anthropic's aggregate over its own enterprise deployments — not a guarantee, not a figure for a solo developer, and not a Kunavo figure. No equivalent number exists for Continue, because nobody publishes one.

A worked estimate at the same endpoint

Pointed at one endpoint with one model, neither client changes the per-token rate. What changes the bill is how each one spends tokens. The figures below are illustrative token arithmetic, not measured task costs and not a bill ceiling. Assume one session that sends 200,000 uncached input tokens and receives 15,000 output tokens, at live Kunavo catalog rates per million tokens.

The interesting number is the one the client architecture controls. Continue assigns a model per role, so a month of assumed autocomplete traffic — say 400,000 input and 20,000 output tokens, an assumption for illustration rather than a measurement — costs $0.200 on Claude Haiku 4.5 against $0.600 if the same traffic sits on Claude Sonnet 4.6. Claude Code documents no autocomplete role to split off; it runs one session model, with separate subagent and background model settings. Anthropic's cost page also notes that agent teams "use approximately 7x more tokens than standard sessions when teammates run in plan mode", and that the prompt cache lifetime "is an hour on a subscription and drops to five minutes once you're drawing on usage credits; on an API key or cloud provider, it's five minutes by default" — so the same long, intermittent session is re-processed sooner off-plan.

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 — a funding minimum, not a task fee or a subscription. See billing details.

What migration actually costs

Budget four things, in rough order of effort. The config shape does not translate: a YAML models: list with per-model roles becomes two environment variables, and there is no converter. The base-URL convention is inverted, as above. The per-role model assignment has no destination — decide up front whether you were relying on it. And the permission vocabulary changes from three policies to modes plus rules, so any CI invocation of cn -p ... --allow Write needs rewriting rather than translating.

One role does not move at all: Kunavo serves no embedding model and no reranker, so a Continue config that assigns the embed or rerank role needs a different provider for those two — and Claude Code has no equivalent role to migrate them into either.

Two things this page did not check, said plainly rather than guessed: how Continue's rules files map onto Claude Code's instruction files was not re-verified here, so budget that separately; and no benchmark, speed or quality comparison exists in anything read for this page, so there is no basis here for calling either agent better at coding.

Setting up and checking the first bill

Kunavo publishes setup references for both clients. Those are published configuration guides, not compatibility tests — neither cn nor claude has been runtime-tested here against Kunavo's endpoint, and every behavioral claim above comes from source reading and official documentation. Keep a working route available while you try either one, run a single bounded task, then read the charge your account actually recorded for it. Start at the Continue integration or the Claude Code integration, and create a Kunavo account when you are ready to fund a key.

Related reading: Claude Code without a subscription for the per-token route in detail, OpenAI-compatible API for the protocol Continue speaks, and Continue alternatives if the maintenance status is what decided this for you.

FAQ

Continue's homepage, README, GitHub metadata, CLI documentation and published 1.5.47 package, plus Cursor's CLI overview and Anthropic's pricing, cost, permission-mode and three gateway pages, were read on September 21, 2026. Neither client was executed and neither was pointed at Kunavo's endpoint: the first-run key check, the URL-join behavior and the permission defaults come from source and documentation, not from a test run. Kunavo token rates are read from the live catalog, and every dollar figure here is illustrative token arithmetic.