Continue

Connect Continue to Mixen — pay from your balance in roubles, with a catalog of 105+ models.

Installation

• VS Code — install the Continue extension from its Visual Studio Marketplace page, then click Install inside VS Code.
• JetBrains — Settings (Ctrl+Alt+S) → Plugins → search for “Continue” in the Marketplace → Install.

Configuration

The configuration lives in ~/.continue/config.yaml (Windows: %USERPROFILE%\.continue\config.yaml). Continue reloads it automatically on save — no IDE restart needed.

name: Mixen
version: 0.0.1
schema: v1

models:
  - name: GPT-5.6 Sol (Mixen)
    provider: openai
    model: openai/gpt-5.6-sol
    apiBase: https://api.mixen.ai/v1
    apiKey: your-api-key
    roles:
      - chat
      - edit
      - apply

  - name: Claude Opus 5 (Mixen)
    provider: openai
    model: anthropic/claude-opus-5
    apiBase: https://api.mixen.ai/v1
    apiKey: your-api-key
    roles:
      - chat
      - edit

Key points:

• provider: openai — this is how Continue connects to any OpenAI-compatible API; Mixen serves /v1/chat/completions.
• apiBase — the Mixen base URL, model — an ID from the catalog.
• roles — which dropdowns the model appears in (chat, edit, apply, summarize, …); omitted, it gets the default roles.
• For agent mode, add capabilities with tool_use to the model — otherwise tools are unavailable to it.
• The old config.json is deprecated — configuration goes in config.yaml.

Verifying the connection

Before writing the config, you can check the key and balance with a minimal generating request:

curl https://api.mixen.ai/v1/chat/completions \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"model":"z-ai/glm-5.3-flash","messages":[{"role":"user","content":"ping"}],"max_tokens":5}'

200 with a response — the key and balance work; 401 invalid api key — the key was copied incompletely or isn’t a Mixen API key; 402 — no funds on the balance.

GET /v1/models does not verify the key — it responds without one; use it only to check that the API is reachable.

Picking a model per task

Continue assigns models by role, so a cheap and an expensive model happily work at the same time — each in its own dropdowns. Prices are per 1M tokens, input/output; the full price list with cache columns — in the catalog.

Role and task	Model	Input / output
Autocomplete and apply — short frequent operations	GLM 5.3 Flash (z-ai/glm-5.3-flash)	8.4 / 27.9 ₽
Chat and edit — everyday edits	GLM 5.3 (z-ai/glm-5.3)	156 / 490.2 ₽
Agent mode — multi-step tasks	GPT-5.6 Sol (openai/gpt-5.6-sol), Claude Sonnet 5 (anthropic/claude-sonnet-5)	213.9 / 1069.5 ₽

For apply (applying edits to a file) long deliberation is pointless — another spot where Flash saves money without quality loss.

Autocomplete through Mixen

There is no separate tabAutocompleteModel field in the current config.yaml — autocomplete corresponds to the autocomplete role in the same roles list. The provider stays openai; Continue’s documentation describes no provider restrictions for this role:

  - name: GLM 5.3 Flash (Mixen)
    provider: openai
    model: z-ai/glm-5.3-flash
    apiBase: https://api.mixen.ai/v1
    apiKey: your-api-key
    roles:
      - autocomplete

Autocomplete is the most frequent request in an IDE, so input price matters most here: for GLM 5.3 Flash it’s 8.4 ₽ per 1M tokens. Tab behavior itself (if needed) is tuned with the autocompleteOptions block on the model holding this role.

Saving on sessions

In Chat and Agent mode, Continue sends the accumulated context with every turn — rules, history, open files. Mixen caches the repeating prefix automatically; nothing to enable.

• Cached input is ~10% of the regular price: for GPT-5.6 Sol input is 213.9 ₽ per 1M tokens and 21.4 ₽ from cache; for GLM 5.3 Flash — 8.4 and 1.7 ₽.
• The cache lives 5 minutes with sliding renewal: every request inside the window extends it. A dense session keeps the cache alive from start to end.
• A pause longer than 5 minutes — the first turn after it pays the full input; the cache then warms up again.

Tactics:

• Reconnaissance (questions, reading) on a cheap model warms the cache for future edits — the context is shared when you work in one chat.
• A run of consecutive turns costs less than the same turns spread out: don’t let the cache go stale mid-task.
• Responses stream as per-symbol deltas; streaming doesn’t affect the price.

What a typical session costs

Let’s price a chat session on GLM 5.3 (input 156 ₽ per 1M, from cache — 29 ₽): 20 turns of ~50K tokens of context each.

Scenario	Session input
Without cache	1M tokens × 156 ₽ ≈ 156 ₽
With cache	first turn in full, then the prefix at 29 ₽ ≈ 47 ₽

Autocomplete on GLM 5.3 Flash lives in a different price world: 200 requests of ~2K input tokens are roughly 3.4 ₽ even without any cache. The numbers are indicative: real volumes depend on the project and the length of the history.

The cache share of a response is the usage.prompt_tokens_details.cached_tokens field; it doesn’t surface anywhere in the UI, of course, but when reconciling the bill it answers why a turn came out cheaper than the full input.

Reasoning depth

Our API accepts reasoning_effort: off, low, medium, high, xhigh, or max — the set depends on the model. Allowed values come in GET /v1/models → capabilities.reasoning_efforts; the can_disable_reasoning flag shows whether the model accepts off.

• Reasoning is billed as output tokens and eats the max tokens budget — long answers need headroom.
• Depth is set in the request itself; config.yaml describes the model’s capabilities (e.g. tool_use for Agent mode), and if neither client nor request sets the depth, the model runs at its default.

Tips for agentic work

• Rules. Markdown files in .continue/rules/ at the project root are attached to the system message; frontmatter holds globs (rule activates for matching files), alwaysApply (always), and description (the agent decides when the rule fits). Files load alphabetically — numbered prefixes set the order. Rules apply in Agent, Chat, and Edit, but not in autocomplete or apply.

An example rule, .continue/rules/01-frontend.md:

---
globs: ["**/*.ts", "**/*.tsx"]
---
Functional components only, state via hooks.

• Slash commands. A markdown file with name, description, and invokable: true frontmatter becomes a command: type /name in Chat, Plan, or Agent mode. In config.yaml, commands are wired up in the prompts block — including local files via uses: file://….
• Agent mode. All Mixen chat endpoints support tools and tool_choice; the main things are declaring capabilities with tool_use for the model and picking one with a large context.
• Split the roles. Don’t hang a flagship on every role at once: chat/edit — GLM 5.3, autocomplete/apply — GLM 5.3 Flash, Agent mode — GPT-5.6 Sol or Claude Sonnet 5.

Frugal session checklist

• Roles apart: autocomplete/apply — GLM 5.3 Flash, chat/edit — GLM 5.3, Agent mode — GPT-5.6 Sol or Claude Sonnet 5.
• For Agent mode — don’t forget capabilities with tool_use on the model.
• Keep rules compact: they fly into every Agent/Chat/Edit request and are paid for on input (at cache price — from the second time).
• A new task means a new chat, not a continuation of a bloated history.
• Model IDs — re-check against the catalog when updating the config.

Useful documentation

• Rules — .continue/rules/, frontmatter, load order.
• Prompts / slash commands — invokable: true and calling via /.
• config.yaml reference — model roles, autocompleteOptions, the rules and prompts blocks.
• Mixen catalog — model IDs, prices, and cache columns.

Recommended models

Model	ID
GPT-5.6 Sol	openai/gpt-5.6-sol
Claude Opus 5	anthropic/claude-opus-5
GLM 5.3	z-ai/glm-5.3
DeepSeek V4 Pro	deepseek/deepseek-v4-pro
Kimi K3	moonshotai/kimi-k3

Full list — in the catalog.

Troubleshooting

• 401 Unauthorized — wrong apiKey: it must be a Mixen mxn-… key.
• The model doesn’t show up — check the YAML (indentation, quotes) and the schema: v1 field; the config is reloaded when the file is saved.
• Agent mode doesn’t call tools — add capabilities with tool_use to the model block.
• Errors on /responses — for o-series and gpt-5 models Continue calls /responses by default; Mixen supports /v1/responses, but if something goes wrong, switch the model back to chat completions with useResponsesApi: false.
• Autocomplete doesn’t go through Mixen — the model must have the autocomplete role in roles; there is no separate field for it in the current config.yaml.
• Rules don’t affect autocomplete and apply — by design: rules are attached only to Agent, Chat, and Edit.