Docs/Interfaces
Interfaces

Coding agents against your own endpoint

By Samuel Seidel · Updated September 4, 2026 · 4 min read

By the end of this page, Continue, Cline and aider send their requests to a model on your own DGX Spark instead of a metered API. All three speak OpenAI's API shape, so each one needs only a base URL, a key and a model name. The code you paste into an agent then goes to a machine you rent, not to a third-party model provider.

You need:

On this page
  1. Start with a running endpoint
  2. Continue (VS Code / JetBrains)
  3. Cline (VS Code)
  4. aider (terminal)
  5. Which model to run
  6. What actually breaks

Start with a running endpoint

Every agent below needs an OpenAI-compatible base URL ending in /v1 and the exact model name the server reports. Set that up first.

  1. Pick the endpoint. With a console model preset, copy the HTTPS endpoint from the instance page in the console (it looks like https://app-<instance-id>.gpuwerk.com) and add /v1. Every request needs your inference-scope API key as a bearer token. With your own engine, start vLLM if several people will share it, or llama.cpp if it is just you, since it is faster for a single stream. In the samples below, <spark-host> is then your instance's hostname, <name>.gpuwerk.com.
  2. Protect your own engine. Each instance has its own public IPv4 address, assigned by GPUwerk, so an engine listening on 0.0.0.0 is reachable from the internet. Start it with an API key (vLLM's --api-key), or bind it to 127.0.0.1 and reach it through an SSH tunnel. The tunnel is the one step here that needs your own SSH key.
  3. Confirm it answers before you touch any editor config. For your own engine:
    curl http://<spark-host>:8000/v1/models
    For a console preset:
    curl https://app-<instance-id>.gpuwerk.com/v1/models \
      -H "Authorization: Bearer $GPUWERK_API_KEY"
    You should see JSON whose data list contains the model ID, for example qwen3-coder-30b on the Qwen3 Coder 30B preset. Use that ID as the model name in every config below.

Continue (VS Code / JetBrains)

  1. Open Continue's config.yaml (older installs use config.json).
  2. Add an openai provider entry pointed at your instance:
models:
  - name: My Spark
    provider: openai
    model: Qwen/Qwen3.8-27B-FP8
    apiBase: http://<spark-host>:8000/v1
    apiKey: not-needed-unless-you-put-a-gateway-in-front
  1. Set model to the ID from /v1/models. For a console preset, set apiBase to the preset's HTTPS endpoint plus /v1 and apiKey to your inference-scope API key. With LiteLLM in front for per-user keys and budgets, use the gateway's URL and a virtual key instead.
  2. Reload the editor window and pick My Spark in Continue's model selector. A test prompt should get a streamed answer from your instance.

Cline (VS Code)

  1. Open Cline's settings and choose the OpenAI Compatible provider.
  2. Set the base URL to your endpoint's /v1 URL.
  3. Paste your inference-scope API key for a console preset. For your own engine without a key, any non-empty string works.
  4. Enter the model ID exactly as /v1/models reports it. A first task should show Cline reading files and answering from your instance.

Cline runs longer tool-use chains and edits more files per turn than Continue, so it uses more context. Serve the model with a context window that fits your repository, not a short --max-model-len.

aider (terminal)

aider reads the endpoint from environment variables, so the simple case needs no config file. Set them and start aider; it should open a chat prompt and answer from your instance:

export OPENAI_API_BASE=http://<spark-host>:8000/v1
export OPENAI_API_KEY=not-needed-unless-you-put-a-gateway-in-front
aider --model openai/Qwen/Qwen3.8-27B-FP8

For a console preset, set OPENAI_API_BASE to the preset's HTTPS endpoint plus /v1, OPENAI_API_KEY to your inference-scope key, and use --model openai/qwen3-coder-30b. Keep the openai/ prefix in every case: it tells aider's LiteLLM client which API format to speak, even though no OpenAI service is involved.

Which model to run

Use a coding model rather than a general chat model. Qwen3 Coder 30B is the console preset for this: it is a mixture-of-experts model with about 3B active parameters, so it answers quickly and leaves most of the Spark's 128 GB free. The preset serves it as qwen3-coder-30b with a 32,768-token context window. If your agent needs more context than that, run the model yourself on a base image with a larger --max-model-len. See which models fit in 128 GB for the other options.

The preset does not start vLLM with tool-call parsing, so agents that work through OpenAI tool calls, such as pi and OpenCode, get their requests rejected by it. Running a coding agent on a rented Spark shows the llama.cpp setup that returns tool calls, with configs for both.

What actually breaks

See alsoPut a gateway in front for keys and budgets See alsoWhich models fit in 128 GB
First top-up: pay $20, get $30 in credit

Point your coding agent at a dedicated Spark.

Deploy a dedicated DGX Spark in Europe, North America or East Asia and point your editor at it in the time it takes to read this page.

Create account