Now on VeniceLLMReasoningOpen weights

Qwen 3.8 27B

Alibaba's compact open-weight flagship — a dense 27B vision-language model with tunable reasoning, agentic coding strength, and a 256K context window.

For agents
curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "e2ee-qwen3-8-27b",
    "messages": [{ "role": "user", "content": "Explain quantum tunneling simply." }]
  }'
Model IDe2ee-qwen3-8-27b
Maker
Alibaba (Qwen team)
Context
256K tokens
Reasoning
Supported
Privacy
E2EE

Overview

What is Qwen 3.8 27B

Qwen 3.8 27B is Alibaba's compact flagship from the Qwen3.8 generation — a dense 27-billion-parameter vision-language model released under Apache 2.0 in August 2026. It handles coding, agentic tasks, reasoning, and image understanding, with a flexible thinking mode and a 256K-token context window on Venice.

Running it privately on Venice

On Venice, Qwen 3.8 27B runs inside a trusted execution environment with end-to-end encryption and zero retention — your prompts are never stored, profiled, or used for training. Because the weights are open under Apache 2.0, you get sovereignty over the model itself: self-host it, or run it permissionless through Venice's API with no subscription gate. It is not positioned as an uncensored model, but the privacy pipeline is the strictest tier Venice offers.

PrivateNo prompt trainingTEE · hardware enclaveEnd-to-end encrypted

Agent quickstart

Three calls, copied straight out

The API is OpenAI-compatible: change the base URL and the model id and existing client code works unchanged.

Streaming chat

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "e2ee-qwen3-8-27b",
    "stream": true,
    "messages": [{ "role": "user", "content": "Draft the release note." }]
  }'

Tool calling

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "e2ee-qwen3-8-27b",
    "messages": [{ "role": "user", "content": "Find the rate limits." }],
    "tools": [{
      "type": "function",
      "function": {
        "name": "search_docs",
        "description": "Search the API documentation.",
        "parameters": {
          "type": "object",
          "properties": { "query": { "type": "string" } },
          "required": ["query"]
        }
      }
    }],
    "tool_choice": "auto"
  }'

Python SDK

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["VENICE_API_KEY"],
    base_url="https://api.venice.ai/api/v1",
)

resp = client.chat.completions.create(
    model="e2ee-qwen3-8-27b",
    messages=[{"role": "user", "content": "Build without permission."}],
)
print(resp.choices[0].message.content)

Specifications

Datasheet

Maker
Alibaba (Qwen team)
Open weights
Yes — Apache 2.0
License
Apache 2.0
Modes
Thinking on/off via reasoning_effort; preserve_thinking retains reasoning context across turns
Context window
256K tokens
Input images
Image input supported on Venice; the model card also describes video understanding (not exposed on Venice)
Released
August 14, 2026 (weights); listed on Venice September 6, 2026
Architecture
Dense causal language model with a native vision encoder (vision-language model)
Parameters
27B (≈28B including the vision encoder)
Max output
8K tokens
Capabilities
Vision, Function calling, Reasoning, Web search, Code-optimized
Privacy on Venice
Private — zero retention
Available on Venice since
Sep 2026

Assessment

Strengths and limitations

Strengths
  • Genuinely open weights under Apache 2.0: self-host, fine-tune, or build on it without licensing risk or retroactive billing.
  • Native vision: it accepts image input, so you can paste screenshots, UI mocks, and diagrams alongside code and text.
  • Strong agentic and coding profile: Qwen reports SWE-bench Pro 61.7 and DeepSWE 1.1 42.2, large jumps over the previous 27B generation.
  • Flexible thinking control: tune reasoning depth with reasoning_effort and preserve reasoning context across multi-turn agent runs.
  • Full tool-use stack on Venice: function calling, web search, and code-optimized inference in one model.
  • Cheap for its class: $0.47/$3.53 per 1M tokens, with cached input at $0.05, versus $18+ output pricing on comparable closed flagships.
Limitations
  • Every headline benchmark is vendor-reported by Alibaba on its own harnesses — no independent verification yet.
  • Independent testing found it roughly three times slower and more token-hungry than its predecessor, so expect higher latency per task.
  • The 1M-token context is a hosted-only feature; on Venice you get the native 256K window.
  • Not an uncensored model: Venice does not classify it in its uncensored tier.
  • Max output is capped at 8K tokens per response, so very long generations must be split across passes.

Use cases

What it is good for

  1. 01Agentic coding sessions — multi-step refactors, terminal tasks, and repo-level changes with function calling.
  2. 02Private code review over screenshots and pasted diffs, with nothing logged server-side.
  3. 03Long-document analysis within the 256K window — contracts, research corpora, codebases.
  4. 04Self-hosted deployments where Apache 2.0 licensing and zero per-token cost matter.
  5. 05Cost-sensitive production pipelines that need vision plus reasoning without closed-model pricing.

Prompting

Getting better results

Set reasoning_effort low for chat and summarization, high for hard coding or multi-step agent runs.

Use preserve_thinking in multi-turn agent loops so the model's reasoning context carries forward instead of restarting.

Paste screenshots or UI mocks as image input when debugging — the vision encoder reads them natively.

Define your tools explicitly via function calling and let the model plan terminal tasks step by step.

Keep long system prompts byte-identical across calls to hit the $0.05/1M cached-input rate.

Cap single responses at 8K output tokens — split large refactors into sequential, scoped passes.

Alternatives

How it compares

ModelBest forContextOpen weightsPrice (Venice)
Qwen 3.8 27BPrivate agentic coding & vision262K tokensYes$0.45 in · $3.20 out / 1M
Claude Sonnet 4.6Polished general-purpose work1M tokensNo$3.60 in · $18 out / 1M
Gemini 3.8 FlashFast multimodal at scale1M tokensNo$0.94 in · $4.69 out / 1M
Google Gemma 4 31B InstructCheapest open-weights option256K tokensYes$0.12 in · $0.36 out / 1M
Qwen 3.7 PlusLong-context Qwen on a budget1M tokensNo$0.50 in · $2 out / 1M

Pick Qwen 3.8 27B when you want open-weight, vision-capable coding and agentic muscle inside a private, zero-retention pipeline — at a fraction of closed-model pricing.

Pricing

What it costs on Venice

Billed per token on Venice: $0.47 per 1M input tokens and $3.53 per 1M output tokens.

Input / 1M tokens
$0.47
Per 1M tokens
Output / 1M tokens
$3.53
Per 1M tokens
Cached input / 1M
$0.05
Per 1M tokens

New Venice accounts include a free daily allowance and 500 welcome credits — no credit card required.

Getting a key

From nothing to a first call

  1. 01

    Create a key in API settings. Nothing else is required to start.

  2. 02

    Export it as VENICE_API_KEY so the snippets above run unedited.

  3. 03

    Point an existing OpenAI client at https://api.venice.ai/api/v1. The scheme is part of the value: an OpenAI client given a bare host does not resolve it.

  4. 04

    Pass e2ee-qwen3-8-27b as the model and send the request.

FAQ

Frequently asked questions

Qwen 3.8 27B is Alibaba's compact flagship from the Qwen3.8 open-model generation: a dense 27-billion-parameter vision-language model released under Apache 2.0 in August 2026. It combines coding and agentic strength with native image understanding, tunable reasoning depth, and a 256K-token context window on Venice.

Venice bills Qwen 3.8 27B per token: $0.47 per 1M input tokens and $3.53 per 1M output tokens, with cached input at just $0.05 per 1M. There is no subscription required — you pay only for what you use.

Yes. Qwen 3.8 27B ships open weights under the Apache 2.0 license, so you can self-host it, fine-tune it, and build commercial products on it. On Venice you can also use it as a managed, private endpoint without touching any infrastructure.

Yes. Qwen 3.8 27B is a native vision-language model with a built-in vision encoder, so it accepts image input — useful for screenshot review, UI analysis, and diagram understanding. On Venice the exposed capability is image input; the model card also describes video understanding, but that is not exposed on Venice.

Yes. On Venice, Qwen 3.8 27B supports function calling for agentic workflows, web search for grounded answers, and code-optimized inference. Its model card specifically highlights stronger autonomous planning and better handling of environment feedback for multi-step tasks.

Qwen 3.8 27B is the pick for open-weight, privacy-first coding and agentic work at $3.53 per 1M output tokens. Claude Sonnet 4.6 offers a 1M-token context and closed-model polish, but costs about five times more per output token and cannot be self-hosted. Choose Qwen for sovereignty and cost; choose Sonnet for maximum-context general-purpose polish.

It runs on Venice's strictest privacy tier: inference is isolated in a trusted execution environment, traffic is end-to-end encrypted, and prompts are never stored, profiled, or used for training — zero retention. You can use it in the Venice app or via the API without building a personal usage history.

No — Venice does not classify Qwen 3.8 27B as an uncensored model. It is a standard aligned assistant model. If uncensored output is your priority, check Venice's dedicated uncensored model tier instead.

On Venice, Qwen 3.8 27B runs with a 256K-token context window and an 8K-token output cap. The model card describes RoPE scaling up to 1M tokens, but that extended length is a hosted-only feature and is not offered on Venice.

Run Qwen 3.8 27B privately

One key, free to start, no credit card.

Start chat