← Back to blog
Technical guide · For developers

Qwen3.8 27B for developers: 1M context, coding agents and a private European API

Running coding agents on real repositories exposes three problems quickly: per-token bills spike during multi-turn tool loops, proprietary source code leaves Europe for providers with unclear retention rules, and local 4-bit quantization runs out of memory well before you can load a large codebase. Qwen3.8 27B (qwen3.8-27b) under Apache-2.0 closes much of the gap with larger closed models, and Vora Compute serves it in FP8 with a 1,000,000-token context window behind an OpenAI-compatible API hosted in the European Union with zero prompt retention.

Why Qwen3.8 27B works well for agentic coding

Qwen3.8 27B is a dense 27-billion-parameter vision-language model released by Alibaba's Qwen team under the Apache-2.0 license. Its 64-layer architecture interleaves Gated DeltaNet linear-recurrent blocks with full Gated Attention layers (16 × (3 × Gated DeltaNet → 1 × Gated Attention)), which keeps long-sequence inference practical without sacrificing multi-file code reasoning.

On coding, terminal work and document understanding, the official Qwen3.8-27B model card on Hugging Face reports the following benchmark results:

Qwen3.8 27B coding, agentic and document benchmark scores reported on Hugging Face
BenchmarkWhat it measuresReported score
LiveCodeBench v6Competitive programming and algorithmic code90.3
OmniDocBench 1.5Structured document and technical page reading91.1
GPQA DiamondGraduate-level technical and scientific reasoning89.2
QwenSWEBenchEnd-to-end software engineering tasks79.0
IFBenchStrict instruction following79.5
Terminal Bench 2.1 (Terminus)Multi-step shell and terminal execution73.0
SWE-bench ProRepository-level bug fixing and patches61.7
NL2Repo-BenchNatural language to repository-level code42.3
DeepSWE 1.1Long-horizon agentic coding (256K context)42.2

Those numbers put a 27B open-weight model into daily-driver territory for refactors, test generation, shell debugging, code review and reading large API specs—especially when paired with an agent harness that executes tools and verifies outputs against your test suite.

Understanding the 1M context window in practice

Qwen3.8 27B has a native context window of 262,144 tokens, extended to 1,000,000 tokens using the official YaRN factor-4 scaling. That distinction matters: 1M is an extended context window, not a native 1M pretraining length, and you should treat it accordingly.

On Inference:

  • The 1,000,000-token ceiling covers the exact rendered input (system prompt, tool schemas, conversation history, attached files and images) plus reserved output tokens.
  • Default output is 8,192 tokens, adjustable up to 32,768 tokens per request (max_tokens or max_completion_tokens).
  • The complete JSON request body must stay within 15 MiB. Oversized requests are rejected outright rather than silently truncated.
  • Prefix caching runs in volatile GPU memory, isolated strictly per account (accounts never share cache entries, and cache contents are never written to disk).

In practice, keep routine edits compact so prefill stays fast and accuracy stays sharpest, and reserve 256K–1M prompts for jobs that genuinely need them: auditing a whole module graph, searching across long build or incident logs, or loading an entire protocol specification in one pass.

For requests above 262,144 tokens, prompt preparation takes noticeably longer before the first token arrives. Vora allows up to 30 minutes before the first token and 60 minutes total on long-context requests, so configure your HTTP client or agent timeout to at least 61 minutes (3,660 s) when running very large prompts.

Tuning reasoning_effort in multi-turn coding loops

By default, Qwen3.8 27B thinks before answering. That helps on tricky debugging or architectural changes, and wastes time on trivial renames. On Vora, every API request accepts reasoning_effort:

  • none — Direct answer with no separate thinking phase. Best for mechanical edits, boilerplate, JSON extraction and fast commits.
  • low (alias: minimal) — Short reasoning trace for straightforward bug fixes and small refactors.
  • medium (default) — Balanced reasoning for day-to-day agentic coding and multi-file edits.
  • high (aliases: xhigh, max) — Deepest reasoning for gnarly concurrency bugs, migrations and architectural trade-offs.

Two details prevent common bugs in custom agent loops:

  1. Preserve reasoning_content separately in assistant history. With stream: true, reasoning arrives in choices[0].delta.reasoning_content and the final answer in choices[0].delta.content. Keep reasoning_content as its own field in the assistant turn you send back—never concatenate it into content. Preserving it separately maintains continuity and keeps prefix-cache hits intact.
  2. Remember that max_tokens covers both thinking and the final reply. If you pass a tight max_tokens with reasoning_effort: "high", the model can finish with finish_reason: "length" before writing any final answer. Raise max_tokens (up to 32,768) or lower the effort level.

See Models & limits for full parameter behaviour.

Connecting Qwen3.8 27B to your coding agent

Inference exposes an OpenAI-compatible Chat Completions endpoint at:

Base URL
https://api.voracompute.com/v1

Create a key in the Vora console and export it in the terminal session where you launch your agent:

Terminal
export VORA_API_KEY=vora_sk_...

OpenCode

Save the following as opencode.json in your project root (or ~/.config/opencode/opencode.json for all projects). It registers qwen3.8-27b with full 1M context limits, reasoning-field mapping and extended timeouts for long prompts (see OpenCode provider docs):

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "vora": {
      "package": "@opencode/ai/providers/openai-compatible",
      "name": "Vora Compute",
      "env": ["VORA_API_KEY"],
      "settings": {
        "baseURL": "https://api.voracompute.com/v1",
        "headerTimeout": 3660000,
        "chunkTimeout": 3660000,
        "timeout": 3660000
      },
      "models": {
        "qwen3.8-27b": {
          "name": "Qwen3.8 27B",
          "limit": { "context": 1000000, "output": 32768 },
          "capabilities": {
            "tools": true,
            "input": ["text"],
            "output": ["text"],
            "reasoning": {
              "supported": true,
              "toggle": true,
              "effort": ["none", "low", "medium", "high"]
            }
          },
          "compatibility": {
            "reasoningField": "reasoning_content",
            "maxTokensField": "max_tokens",
            "streamUsage": true
          }
        }
      }
    }
  },
  "model": "vora/qwen3.8-27b"
}

Launch with:

Terminal
opencode --model vora/qwen3.8-27b

Cline (VS Code)

In Cline's provider settings (Cline OpenAI-compatible docs), enter:

  • API Provider: OpenAI Compatible
  • Base URL: https://api.voracompute.com/v1
  • API Key: your vora_sk_... key
  • Model ID: qwen3.8-27b
  • Context Window: 1000000
  • Max Output Tokens: 32768

Continue

Add VORA_API_KEY=vora_sk_... to ~/.continue/.env and append this model entry to ~/.continue/config.yaml (Continue reference). Select Agent mode in your IDE when you want tool calling:

~/.continue/config.yaml
name: My Config
version: 0.0.1
schema: v1
models:
  - name: Qwen3.8 27B (Vora)
    provider: openai
    model: qwen3.8-27b
    apiBase: https://api.voracompute.com/v1
    apiKey: ${{ secrets.VORA_API_KEY }}
    useResponsesApi: false
    roles: [chat, edit, apply]
    capabilities: [tool_use]
    defaultCompletionOptions:
      contextLength: 1000000
      maxTokens: 8192

Aider

Create .aider.model.settings.yml in your repository so Aider knows the output limit (Aider OpenAI-compatible docs):

.aider.model.settings.yml
- name: openai/qwen3.8-27b
  extra_params:
    max_tokens: 8192

Then run Aider with the openai/ prefix:

Terminal
export OPENAI_API_BASE="https://api.voracompute.com/v1"
export OPENAI_API_KEY="$VORA_API_KEY"
aider --model openai/qwen3.8-27b

Delegating from Claude Code or Codex with Vora CLI

Claude Code requires an Anthropic Messages gateway (/v1/messages) and Codex uses the Responses API (/v1/responses), so neither connects directly to a Chat Completions endpoint today. Instead, you can keep Claude Code or Codex as your primary agent and offload bulky file searches, diff reviews, summaries and mechanical edits to Qwen3.8 27B with the Vora CLI (Node.js 22+, zero dependencies):

Terminal
npm install -g https://inference.voracompute.com/cli/vora-0.1.2.tgz
vora login

# Read-only by default; prints only the final report on stdout
vora run "Where is the session cookie set? Cite file and line."
git diff | vora run "Review this diff for bugs."

By default vora can only list, read and grep files inside the current directory. Pass --write to allow edits, --shell to run sandboxed commands (on macOS, confined to the folder with no network unless you also pass --net). Files that typically hold secrets (.env* except examples, key files, .npmrc) are always refused and credential-like environment variables are stripped from commands.

Custom agents and lightweight classification

The same https://api.voracompute.com/v1 base URL works directly with the OpenAI Python and Node SDKs, LangChain (langchain-openai), LlamaIndex (llama-index-llms-openai-like) and Vercel AI SDK (@ai-sdk/openai-compatible). See Set up your agent for ready-to-paste snippets.

If your pipeline also runs high-volume binary checks, routing or scoring over text (for example, triaging support tickets or flagging billing errors) where a full reasoning chat model is overkill, Vora also serves GLiDE 9B on a dedicated /v1/systemone endpoint returning probabilities.

Local hardware vs. a private European API

Many developers first evaluate Qwen3.8 27B locally via Ollama or llama.cpp in 4-bit GGUF (~17.8 GB of weights on a 24–32 GB GPU). Local inference works well for offline single-file coding, but hits practical walls quickly in agentic workflows: 4-bit quantization degrades long-context precision, KV cache memory caps real context far below 1M tokens on a single workstation GPU, and sharing that setup cleanly across a team adds operational overhead.

Comparison of local 4-bit GGUF, US per-token APIs and Vora Compute in Europe
FactorLocal workstation (4-bit GGUF)US per-token cloud APIsVora Compute (Europe)
QuantizationTypically 4-bit (Q4_K_M)Varies by providerFP8 with calibrated KV scales
Usable context windowBounded by local VRAM (often 32K–128K)Varies (often 128K–256K)Up to 1,000,000 tokens
Data locationYour machineOften US or multi-region routingEuropean Union
Prompt retentionNone (local)Depends on tier and opt-outZero API retention by default
Pricing modelUpfront GPU + power + maintenancePay per token (spikes in agent loops)€19/month or €192/year (€16/month) first year through 1 December 2026 (then €29/month or €288/year, excl. VAT); fair use: 2 requests at a time

On Vora's API, prompts, responses, images, reasoning traces and tool calls pass through memory to the model and back. Engine content logs, persistent prompt caches and image-processing caches are disabled. Full details are documented in Vora Privacy.

Honest limits and when to pick another model

No single model or deployment fits every workload. Before adopting Qwen3.8 27B on Vora, check these constraints:

  • Unsupported endpoints and parameters: /v1/responses and /v1/messages return 404. logprobs, top_logprobs, logit_bias, n > 1, audio and video are not supported.
  • Fair use and concurrency: Each account includes 2 concurrent requests across API keys and Chat, with at most 1 long request reserving more than 262,144 tokens. Excess account requests return 429 with Retry-After; waiting requests share a FIFO queue (30 s queue timeout, returning retryable 503 when full).
  • Image input limits: Up to 8 inline base64 images (JPEG, PNG or WebP) and 10 MiB decoded per request across conversation history. Remote URLs are never fetched.
  • When to switch models: For dense scientific papers, graduate-level maths, or interpreting multi-panel plots and figures, switch to nemotron-3.5-super-vl-120b — read our guide for scientists.

Frequently asked questions

Is Vora's Qwen3.8 27B API compatible with OpenAI SDKs and coding agents?
Yes. Point any OpenAI Chat Completions client at https://api.voracompute.com/v1 with model: "qwen3.8-27b". Direct configurations are documented and tested for OpenCode, Cline, Continue, Aider, Cherry Studio, LangChain, LlamaIndex and Vercel AI SDK.
Does Qwen3.8 27B really support 1M tokens on Vora?
Yes, up to 1,000,000 tokens including input, tool schemas, history and reserved output (extended from 262,144 native tokens via YaRN factor 4), with a 15 MiB JSON body limit and no silent truncation.
Does Vora store or train on my source code?
No. API requests are never written to disk, prompts and completions are not logged, prefix caching stays strictly in volatile GPU memory isolated per account, and inference runs on GPUs in the European Union.
How much does it cost on Vora Compute?
€29/month or €288/year (€24/month) per person, excl. VAT — or €19/month (and €192/year, €16/month) for the first year if you subscribe through 1 December 2026. That covers Chat and the API without counting tokens, within fair use (2 concurrent requests). Cancel anytime.

Try Qwen3.8 27B in your coding agent.

Flat rate on European GPUs with zero API retention: €19/month or €192/year (€16/month) for the first year through 1 December 2026 (then €29/month or €288/year, excl. VAT). Fair use: 2 requests at a time.

WhatsApp