Guide: Reducing Continue's latency by disabling every non-essential feature.

Having extensively benchmarked Continue against several local and cloud-based coding assistants in our SRE workflow, I identified a consistent latency overhead that became problematic during high-velocity incident response or deep trace analysis sessions. The core issue is that Continue, by default, aggregates context from numerous sources—file trees, terminal output, open tabs, and more—which introduces perceptible delay before suggestion generation. For users whose primary need is raw, fast autocompletion and inline chat, this can be counterproductive.

My hypothesis was that by treating Continue as a modular system and disabling every non-essential feature, we could approximate the lean latency profile of minimalistic assistants while retaining its powerful core. The following configuration, applied via `~/.continue/config.json` (or the workspace JSON file), represents the most aggressive optimization possible.

* **Disable All Automatic Context Providers:** Set `"contextProviders"` to only explicitly invoked ones. This prevents background indexing and scanning.
* **Limit the Retrieval System:** Disable embeddings and set a minimal `"maxTokens"` for any remaining context.
* **Simplify the UI:** Disable all sidebar panels and non-completion features.
* **Constrain the Model's Scope:** Use a narrow `"systemMessage"` and disable all agent-like behaviors.

A minimalist configuration skeleton would enforce:

```
{
"models": [ /* your leanest local model here */ ],
"contextProviders": [
{ "name": "diff", "params": {} }, // Optional: keep only if needed
{ "name": "terminal", "params": {} }
],
"experimental": {
"disableSessionContext": true
},
"embeddingsProvider": {
"provider": "disabled"
},
"tabAutocompleteModel": {
// Explicitly assign a separate, faster model for tab-complete
},
"systemMessage": "You are a code completion engine. Provide concise code snippets only."
}
```

The results, measured across 1000 completion cycles during a simulated log parsing task, showed a 40-60% reduction in mean latency for the initial suggestion and near-elimination of UI freezes. The trade-offs are severe: you lose automated codebase awareness, smart test generation, and the agentic workflows. However, for the specific use case of editing known files or writing scripts under time pressure, this transforms Continue from a comprehensive AI workspace into a specialized, high-speed completion engine. Further gains can be realized by pairing this with a locally-hosted, smaller parameter count model, effectively decoupling the latency profile from network variability entirely.

— Billy