---
title: Continue.dev: configure a custom model in 30 seconds
slug: continue-custom-model
canonical_url: https://blog.juscode.co/continue-custom-model
published_at: 2026-05-26T00:00:00+00:00
author: jusCode
tags: continue, continue-dev, custom-model, openai-compatible, vscode, jetbrains
tldr: Add a `models` entry in ~/.continue/config.json with provider "openai", apiBase https://api.juscode.co/v1, your jcg_ key, and model "jusCode-auto". Restart VS Code and the new model appears in Continue's model picker. Works the same for JetBrains.
key_takeaways:
  - Continue.dev works with any OpenAI-compatible endpoint via a models entry in config.json.
  - Set base_url to https://api.juscode.co/v1 and use a jcg_ token with model jusCode-auto.
  - Continue picks up the new model in its picker; works the same on JetBrains.
---

# Continue.dev: configure a custom model in 30 seconds

[Continue](https://continue.dev) is the most config-driven open-source coding agent: every model, provider, and slash-command is declared in `~/.continue/config.json`. That makes it the easiest agent to point at a custom OpenAI-compatible endpoint like jusCode.

## The minimal change

Edit `~/.continue/config.json`. Add a `models` array entry:

```json
{
  "models": [
    {
      "title": "jusCode",
      "provider": "openai",
      "apiBase": "https://api.juscode.co/v1",
      "apiKey": "jcg_your_key_here",
      "model": "jusCode-auto"
    }
  ]
}
```

Restart VS Code (or your JetBrains IDE). Open the Continue panel, click the model picker, and pick **jusCode**. Done.

## Getting a key

Sign in at [juscode.co/login](https://juscode.co/login). Open [juscode.co/developer](https://juscode.co/developer) → **Keys** tab → **Mint key**. Copy the `jcg_…` token (shown once). Paste into the `apiKey` field above.

## Multiple jusCode models at once

If you want different routing for chat vs autocomplete vs agentic edits, add multiple entries with explicit model IDs:

```json
{
  "models": [
    {
      "title": "jusCode (auto)",
      "provider": "openai",
      "apiBase": "https://api.juscode.co/v1",
      "apiKey": "jcg_…",
      "model": "jusCode-auto"
    },
    {
      "title": "Claude Sonnet via jusCode",
      "provider": "openai",
      "apiBase": "https://api.juscode.co/v1",
      "apiKey": "jcg_…",
      "model": "anthropic/claude-sonnet-4.5"
    },
    {
      "title": "Hermes 4 via jusCode",
      "provider": "openai",
      "apiBase": "https://api.juscode.co/v1",
      "apiKey": "jcg_…",
      "model": "nousresearch/hermes-4-405b"
    }
  ]
}
```

Continue's model picker lets you switch on the fly. Useful when you want to force a specific model for a tough refactor.

## Tab autocomplete

Continue's tab autocomplete (the inline suggestion as you type) reads from a separate `tabAutocompleteModel` block. Point that at a cheap small model via jusCode:

```json
{
  "tabAutocompleteModel": {
    "title": "jusCode tab",
    "provider": "openai",
    "apiBase": "https://api.juscode.co/v1",
    "apiKey": "jcg_…",
    "model": "qwen/qwen3-coder-8b"
  }
}
```

Tab autocomplete fires constantly while you type. Routing it to an 8B model instead of a frontier model is the single biggest cost lever for Continue users. Quality is indistinguishable for the tactical "what comes next" call.

## Embeddings (RAG)

If you use Continue's `@codebase` retrieval, the embeddings model is separate. jusCode doesn't currently route embeddings, so keep using Continue's default (or your own embedding provider) for that subset. Inference is what we route; embeddings are a different workload.

## Verifying

After restarting, open the Continue panel and ask "what's in this file?" with the cursor on an open file. The call goes through jusCode. Open [juscode.co/developer](https://juscode.co/developer) → **Usage** tab, and you'll see the spend tick up.

If you don't see the model in Continue's picker after editing config.json, double-check JSON syntax (a trailing comma will make Continue silently ignore the file).

## What works, what doesn't

| Feature | Works? | Notes |
|---|---|---|
| Chat | ✅ | |
| Slash commands (`/edit`, `/comment`, `/test`) | ✅ | |
| `@codebase` retrieval | ✅ | Inference yes; embeddings out of scope (use Continue's default) |
| `@docs` / `@url` context | ✅ | Continue handles fetch; jusCode handles inference |
| Tab autocomplete | ✅ | Cheap-model routing has huge cost leverage here |
| Image inputs | ✅ | Auto-routes to vision-capable model |
| Custom slash commands | ✅ | Whatever you've defined in config.json works |
| Local models (Ollama path) | n/a | Not a jusCode concern: use Continue's local provider for those |

## Team configuration

Continue supports a `team` config that fetches `config.json` from a shared URL. Host a team config at e.g. `https://your-domain.com/continue-config.json` with the jusCode endpoint, distribute the URL to your team, and everyone gets the same routing without each engineer hand-editing their config.

You can also use a `secrets.json` for the API key so team members don't share one. Just generate per-user `jcg_` keys (each engineer mints their own via `/developer`).

## Why Continue benefits from per-call routing

Continue is unusually heavy on small calls. Tab autocomplete fires hundreds of times per hour. `@codebase` retrieval fans out to multiple sub-queries. Each chat turn is a roundtrip. If every one of those goes to Sonnet 4.5, you're paying $10-40/day per engineer.

jusCode picks the cheapest capable model for each call. A tab autocomplete goes to Qwen3 8B for ~$0.05/M tokens. A multi-file refactor goes to Sonnet for ~$3/M tokens. The blended bill drops 60-80% with no quality regression on the tactical traffic that makes up the bulk.

## Setup checklist

1. Sign up at [juscode.co/login](https://juscode.co/login).
2. Mint a `jcg_` key at [/developer](https://juscode.co/developer) → Keys.
3. Edit `~/.continue/config.json`: add the `models` block above.
4. Restart VS Code or JetBrains.
5. Pick "jusCode" from the model selector.
6. (Optional) point `tabAutocompleteModel` at a small model for autocomplete savings.

## Related reading

- [OpenAI-compatible drop-in (Cursor, Aider, Cline, Goose…)](/docs/openai-drop-in/)
- [Cline + custom endpoint: cut your VS Code agent bill 60%+](/blog/cline-custom-endpoint/)
- [Aider on a budget](/blog/aider-cheap-inference/)
- [The cheapest LLM API for coding agents in 2026](/blog/cheapest-llm-api-for-coding-2026/)

---

*Raw markdown: [/blog/continue-custom-model.md](/blog/continue-custom-model.md)*


## FAQ

### How do I point Continue.dev at a cheaper endpoint?

Use a models entry in config.json: base_url https://api.juscode.co/v1, a jcg_ token, and model jusCode-auto. Behavior is unchanged.

### Does Continue.dev lose any features on a custom endpoint?

No. Tool use, edits, and memory keep working; only the model selection moves behind the gateway.

### How much does per-call routing save?

Typically 60-80% on real coding-agent workloads, because most steps do not need a frontier model.