TL;DR: Continue.dev autocomplete fails for one of three reasons: no model has the autocomplete role in config.yaml, the model you picked can’t do fill-in-the-middle (FIM), or the editor’s inline-suggestion toggle is off. Fix the config first — a code model like Codestral or qwen2.5-coder with roles: [autocomplete] — then rule out the editor and Copilot. Nine times out of ten it’s the config.

Symptom	Most likely cause	The fix
No ghost text ever appears	No model with roles: [autocomplete] in config	Add a FIM code model with the autocomplete role
Ghost text is garbage / repeats the line / prints `<	fim	>` tokens
Worked before, stopped after an update	Config migrated from config.json to config.yaml	Move tabAutocompleteModel to a roles entry
Suggestions are slow or time out	Ollama context too small, or model too big	Set num_ctx ≥ 8K; use a ≤ 7B FIM model
Nothing, and Copilot is installed	Another provider owns inline suggestions	Disable Copilot inline completions

Honest take: Before touching timeouts or reinstalling, open your config.yaml and confirm one model has roles: [autocomplete] and that model is a code/FIM model — not llama3 or a generic instruct model. That single check resolves most “Continue isn’t autocompleting” reports.

First, separate the two things Continue does

Continue.dev has two completely independent features, and people conflate them when debugging:

1. Chat / agent — the sidebar where you ask questions and run agentic edits. This uses a model with the chat role.
2. Autocomplete — the gray inline “ghost text” that appears as you type. This uses a different model with the autocomplete role.

The number-one support thread on the Continue GitHub is some version of “chat works but autocomplete doesn’t.” That’s expected behavior when your config only defines a chat model. Autocomplete will stay silent until you explicitly give it its own model. If your sidebar chat answers fine but you get no ghost text, you almost certainly have this problem — skip to the config fix below.

Fix 1: Give autocomplete a model (the real fix)

Since the move to Continue’s config.yaml (schema v1), models are assigned roles instead of separate top-level keys. Autocomplete needs a model whose roles list contains autocomplete. Here is a minimal working local setup with Ollama:

name: My Config
version: 0.0.1
schema: v1
models:
  - name: Qwen Coder Chat
    provider: ollama
    model: qwen2.5-coder:7b
    roles:
      - chat
      - edit
  - name: Qwen Coder Autocomplete
    provider: ollama
    model: qwen2.5-coder:1.5b
    roles:
      - autocomplete

Note the two separate model entries. The small 1.5b model handles autocomplete because inline completion needs to be fast, and a bigger model handles chat. You do not need a huge model for autocomplete — the state-of-the-art FIM models top out around 7–10B parameters, and going bigger buys you latency, not quality.

If you use the Mistral API instead of local, Codestral is Continue’s recommended cloud autocomplete model (it replaced StarCoder2 as the default FIM recommendation):

  - name: Codestral
    provider: mistral
    model: codestral-latest
    apiKey: <YOUR_MISTRAL_KEY>
    roles:
      - autocomplete

Save the file. Continue reloads config on save — you should see ghost text within a keystroke or two. The default config lives at ~/.continue/config.yaml (%USERPROFILE%\.continue\config.yaml on Windows).

Fix 2: Use a fill-in-the-middle model, not a chat model

This is the cause behind the “ghost text is garbage” symptom. Autocomplete is not the same task as chat. It runs on fill-in-the-middle (FIM): the model is handed the code before your cursor (the prefix) and the code after it (the suffix), and asked to predict what belongs in the gap. That requires a model trained with FIM tokens.

Generic chat/instruct models — llama3, mistral, gpt-4o, plain qwen — were not trained on FIM. Point autocomplete at one and you get one of three failure modes: no output, output that ignores the suffix and dumps a whole function, or literal <|fim_prefix|> / <|fim_suffix|> tokens leaking into your file.

Use a model that ships FIM. Verified-good picks in 2026:

• Codestral (Mistral, cloud) — purpose-built for FIM, matches Copilot quality on most completions.
• qwen2.5-coder (local, Ollama) — Continue’s recommended local FIM model; the 1.5b and 7b tags both work.
• deepseek-coder and starcoder2 — older but still solid FIM models if you already have them pulled.

Pull the exact tag before you reference it, and match it character-for-character in the config — a typo in the model tag produces the same silent nothing as a missing role:

ollama pull qwen2.5-coder:1.5b

Fix 3: Turn on the editor’s inline suggestions

Continue can be perfectly configured and still show nothing if the editor is swallowing inline suggestions.

VS Code: open Settings (Ctrl/Cmd + ,), search for editor.inlineSuggest.enabled, and make sure it’s checked. Also confirm Continue’s own toggle: click the Continue button in the status bar (bottom right) — it flips “Enable Tab Autocomplete” on and off, and it’s easy to disable by accident.

JetBrains: go to Settings → Tools → Continue and confirm autocomplete is enabled there.

Fix 4: Kill the competition (Copilot and friends)

Only one extension can own the inline-suggestion slot at a time. If GitHub Copilot, Codeium, Tabnine, or Amazon Q is installed and active, it may win the race and Continue’s ghost text never renders. Disable the other provider’s inline completions (you can keep its chat), reload the window, and Continue’s suggestions come back. This is a frequent cause of “it randomly stopped working” — it usually lines up with installing or re-enabling another AI extension.

Fix 5: The Ollama context trap (slow or truncated completions)

If autocomplete works but is slow, times out, or gives low-quality results on larger files, you’re likely hitting Ollama’s default context window. Ollama defaults num_ctx low and silently truncates the prompt when it overflows — so on a big file, the suffix that FIM depends on gets cut, and completions degrade or stall. This is the same root cause we documented for chat and agent tools in the Ollama num_ctx fix guide, and it applies to autocomplete too.

For autocomplete you don’t need a giant window — the whole point is speed — but you want enough room for a reasonable prefix and suffix. Set it in autocompleteOptions and, for a guaranteed result, bake it into the model with a Modelfile so Ollama can’t fall back to its default:

  - name: Qwen Coder Autocomplete
    provider: ollama
    model: qwen2.5-coder:1.5b
    roles:
      - autocomplete
    autocompleteOptions:
      debounceDelay: 250
      maxPromptTokens: 1024

debounceDelay (milliseconds before a request fires) and maxPromptTokens (how much surrounding code to send) are the two knobs that matter most. If completions feel laggy on a weak GPU, lower maxPromptTokens before you blame the model. If you’re not sure your machine can drive a local FIM model at usable speed at all, the best local coding models by VRAM guide on runaihome.com has the size-to-hardware breakdown.

Fix 6: The config.json → config.yaml migration

If autocomplete broke after a Continue update and you last configured it more than a few months ago, you may be caught between formats. Older Continue used config.json with a top-level tabAutocompleteModel key. Current Continue uses config.yaml with the roles system shown above. A stale tabAutocompleteModel in an old JSON file won’t apply the way tutorials from 2025 imply.

The fix is to stop configuring autocomplete as a special top-level model and instead give a normal model the autocomplete role in config.yaml. Half the outdated Continue tutorials still online reference the old key — if you copied one, that’s your bug. Our Continue.dev configuration guide for multi-language projects uses the current config.yaml shape throughout.

When none of that works: read the logs

If you’ve done all six and still get nothing, stop guessing and read Continue’s log — it tells you exactly what the autocomplete request did:

• VS Code: Ctrl/Cmd + Shift + P → Toggle Developer Tools → Console tab. Type in a file and watch for the autocomplete request and any error.
• JetBrains: open ~/.continue/logs/core.log.

Common things the log reveals: a 404 because the Ollama model tag doesn’t exist, a connection refused because Ollama isn’t running (see the Ollama connection refused fix), or a completion that did return successfully — which means the problem is on the editor side (Fix 3 or Fix 4), not the model.

A note on the “worked yesterday” case

If Continue autocomplete was fine and suddenly isn’t, the fastest triage order is: (1) did you install/enable another AI extension? (Fix 4); (2) did Continue or VS Code update and reset a toggle? (Fix 3); (3) is Ollama actually running and is the model still pulled? (logs). This mirrors the triage flow we use for Cursor tab completion not working — the “it randomly stopped” class of bug is almost always an environment change, not a corrupted install.

FAQ

Why does Continue chat work but autocomplete doesn’t? Because they use different models with different roles. Chat uses the chat role; autocomplete needs a separate model with roles: [autocomplete]. A config with only a chat model will chat fine and never autocomplete. Add a FIM code model with the autocomplete role.

Which model is best for Continue.dev autocomplete in 2026? Codestral if you’re using the Mistral API (it’s Continue’s recommended cloud FIM model). For fully local, qwen2.5-coder via Ollama — the 1.5b tag for speed, 7b if you have the VRAM and want better quality. Avoid chat/instruct models; they aren’t trained for fill-in-the-middle.

Do I need a big GPU for local autocomplete? No. Autocomplete models are small by design — most top out around 7B parameters. A 1.5B FIM model runs on modest hardware. The bottleneck for autocomplete is latency, not model size, so a bigger model actively hurts the experience.

Why is Continue printing <|fim_prefix|> or weird tokens into my code? You’ve pointed autocomplete at a model that doesn’t understand FIM tokens, so it echoes them instead of using them. Switch to a real FIM model (Codestral, qwen2.5-coder, deepseek-coder).

Is Continue.dev free? Yes — Continue is open source (Apache 2.0) and free to run. Your only cost is the model: $0 if you self-host with Ollama, or per-token API pricing if you use Codestral or another cloud model. For more fully open-source local coding tools, see the roundups on aifoss.dev.

Sources

• Continue Autocomplete Setup and Configuration Guide — Continue Docs (verified Jul 18 2026)
• Autocomplete Role in Continue Models — Continue Docs
• Recommended Models for Autocomplete — Continue Docs
• config.yaml Reference — Continue Docs
• Using Ollama with Continue — Continue Docs
• Continue GitHub Issues on autocomplete (community-reported failure modes)

Last verified: Jul 18 2026 against the official Continue.dev documentation.