DEV Community: AIHubMix

DeepSeek V4.1 Flash API Pricing: AIHubMix vs. OpenRouter

AIHubMix — Sun, 20 Sep 2026 14:23:50 +0000

If you are building an AI coding assistant or agent, model capability is only half the decision. The API route can change your cost, fallback behavior, and operational flexibility just as much.

DeepSeek V4.1 Flash is now available through AIHubMix and OpenRouter. It combines a roughly 1M-token context window with native image understanding, tool calling, structured JSON output, and agent-oriented workflows.

Pricing comparison

Prices checked on September 20, 2026:

Route	Input	Output	Cache read
OpenRouter	$0.13 / 1M	$0.52 / 1M	$0.0026 / 1M
AIHubMix — ByteDance off-peak	$0.0986 / 1M	$0.3942 / 1M	$0.002 / 1M

The AIHubMix figures include a current 30% promotion, reducing the regular off-peak input price from $0.1408 to $0.0986 per 1M tokens and output from $0.5632 to $0.3942. The promotion is currently listed through September 27, 2026, so verify the live model page before committing production traffic.

For 10M input tokens and 2M output tokens, the discounted off-peak route costs about $1.7756. The comparable peak route is about $3.548, while the same off-peak workload before the discount would be about $2.9764.

What makes DeepSeek V4.1 Flash useful?

1M-token context

DeepSeek V4.1 Flash supports approximately 1,048,576 tokens of context. This is useful for large repositories, long technical documents, multi-step research, browser workflows, and large log or business-data inputs.

Native image understanding

The model accepts both text and images and returns text. That supports visual document analysis, chart interpretation, screenshot-aware coding, and image-aware customer-support workflows.

Tool calling and structured output

It supports tool calling, tool_choice, and JSON Schema-based structured output. A typical agent loop can therefore look like this:

The model interprets the task.
It selects a tool and returns structured arguments.
Your application executes the tool.
The result is sent back to the model for the next step.

AIHubMix vs. OpenRouter

AIHubMix provides an OpenAI-compatible API, a unified model ID, multiple provider routes, peak and off-peak pricing, provider monitoring, retries, fallback, streaming, tool calling, structured output, and multimodal input.

OpenRouter exposes the model as deepseek/deepseek-v4.1-flash, with provider selection and exclusion, automatic failover, and public provider-level pricing and performance data.

The practical choice depends on your priorities:

Choose OpenRouter if provider selection and a broad routing layer are central to your workflow.
Choose AIHubMix if you want an OpenAI-compatible endpoint, scheduled pricing, and the current discount on the eligible route.

Quick start with AIHubMix

The endpoint is OpenAI-compatible:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ[AIHUBMIX_API_KEY],
    base_url=https://aihubmix.com/v1,
)

response = client.chat.completions.create(
    model=deepseek-v4.1-flash,
    messages=[
        {role: user, content: Analyze this codebase and identify the highest-priority reliability risks.}
    ],
    max_tokens=1024,
    stream=False,
)

print(response.choices[0].message.content)

The AIHubMix model ID is deepseek-v4.1-flash; the OpenRouter model ID is deepseek/deepseek-v4.1-flash.

Best-fit workloads

The model is a good fit for:

Coding assistants and repository-level code analysis
Terminal, browser, and computer-use agents
Document and chart understanding
Structured extraction
Research agents
Multi-step automation with repeated tool calls

Takeaway

DeepSeek V4.1 Flash combines long context, vision, tool calling, and structured output at a relatively low per-token cost.

Before estimating production spend, check the current provider route, the GMT+9 peak/off-peak schedule, and whether the promotion is still active. Prices and availability can change.

Source: AIHubMix pricing comparison

Why did Gemini turn Chinese for no reason?

AIHubMix — Sun, 20 Sep 2026 08:31:47 +0000

Gemini can occasionally return Chinese text in its reasoning content or final response even when the expected language is English. The most useful diagnosis is usually multilingual language-control drift—not an automatic switch to a separate Chinese model, and not an effect caused by response streaming.

This article explains the behavior, the likely context signals, and the limits of what can be concluded from a single unexpected response.

Problem statement

Consider a multi-turn workflow with these characteristics:

The current prompt is written in English.
The expected response language is English.
The context includes Chinese sources, quotes, entities, or earlier messages.
Gemini returns some chinese text during reasoning or in the final answer.

The failure is observable, but its cause is not directly exposed. A language change alone cannot establish that the serving system selected a different model.

A practical model of the behavior

Gemini is multilingual and generates output token by token. The next token is conditioned on the available conversation context, which can contain competing language signals.

At a high level:

system and task instructions
        +
conversation history
        +
retrieved sources and quotations
        +
current user turn
        ↓
context-conditioned generation
        ↓
response language

The intended language may be English, while nearby source material is Chinese. In sufficiently long, complex, or retrieval-heavy contexts, those signals can reduce language consistency. This is a conceptual explanation, not a disclosed description of Gemini's internal routing or implementation.

Likely contributing factors

Chinese source material

Chinese webpages, product information, and source documents supply vocabulary and sentence patterns that may influence the generated continuation.

Conversation history

Language state can carry across turns. A prior Chinese quote or answer may influence a later English turn; the final instruction is not the only text shaping how the model will respond.

Token-by-token multilingual generation

Language selection should not be treated as an absolute binary switch. A strong English instruction can coexist with local Chinese signals in the prompt context.

Context complexity

Long-context reasoning and retrieval-based tasks require the model to reconcile more text and more linguistic cues. The supplied project note identifies these scenarios as places where consistency may decrease.

What `stream` does—and does not do

The API-style distinction is straightforward:

stream=true   → return the response incrementally
stream=false  → return the response all at once

Neither value is a language parameter. It controls response delivery, not whether Gemini uses English or Chinese. If Chinese text appears during a streamed response, disabling streaming does not address the underlying language-control issue.

Correlation in one request is not causation: a streamed response can drift, but the streaming setting does not directly determine the language.

Mitigation checklist

When reproducible language consistency matters:

Inspect the full context, not only the latest message.
Identify Chinese sources, quotations, named entities, and earlier turns.
Place the output-language requirement close to the current task.
Use an explicit instruction such as:

   Respond only in English, including the final answer.

Retry in a clean conversation when the existing context is long or multilingual.
Keep stream configured for delivery needs, not as a language-control workaround.

These are context-management measures inferred from the likely causes. They reduce relevant sources of ambiguity but should not be represented as a guarantee.

Reproduction and diagnosis limits

A useful incident record should preserve the prompt, preceding turns, retrieved content, language instruction, stream value, and exact output. Without that context, a screenshot of one Chinese phrase is insufficient to identify the cause.

Public users have reported unexpected changes involving Chinese, Japanese, and Portuguese. The reports support the existence of a broader multilingual symptom, but community anecdotes cannot reveal internal implementation details or prove the cause of a particular request.

Conclusion

Treat unexpected Chinese output as a language-consistency failure first. Separate the generation problem from the transport setting, audit every relevant turn, and make the desired response language explicit. The evidence described here supports multilingual drift as the more consistent explanation; it does not support claiming that Gemini switched to a dedicated Chinese model.

References: community case 1 and community case 2.

Exploring Jev: A Hands-On Look at TypeSafe AI’s New Decision Model

AIHubMix — Fri, 18 Sep 2026 07:19:53 +0000

Jev is one of those models that makes more sense once you stop comparing it with chatbots.

It does not generate prose. It takes some application state, evaluates questions you define, and returns typed answers with probabilities. That makes it less like a writing assistant and more like an AI decision function you can drop into a workflow.

In this article, we will take a first look at the API, run through the LangChain integration, and explore a few places where this new model could be useful.

Jev in plain English

Jev is a new model from TypeSafe AI and the company’s first “System One Model.” You send it:

A state: the context it needs to read.
A set of questions: the decisions you want it to make.

It sends back probabilities, choices, and scores that code can use directly. There is no free-form completion to parse.

A good mental model is an AI-powered if statement:

messy real-world context
    -> Jev understands the context
    -> typed decision + probability
    -> your code chooses the next action

This is not a drop-in replacement for an LLM. It is a different building block for classification, routing, scoring, verification, and guardrails.

The three question types

Jev exposes three decision primitives:

Noul: evaluates a yes-or-no statement and returns the probability that it is true.
Choice: selects from predefined options and returns a probability distribution plus confidence.
Score: rates ordered levels and returns a continuous score, its distribution, and confidence.

The model evaluates multiple questions in a request in parallel. That is useful when one piece of state needs several independent judgments. For example, a support ticket might need a category, severity score, abuse flag, and human-review flag.

Why the API shape is useful

Jev’s functional advantage is not only speed. The interface removes several pieces of glue code that usually sit around a generative model:

Schema-first output: developers define the allowed structure in advance. TypeSafe says Jev cannot invent extra fields, return malformed JSON, or swap an expected value for the wrong data type.
Parallel decisions: several independent questions can share one state and one request instead of becoming a chain of separate generations.
Probabilities as control signals: an application can use thresholds to execute, escalate to an LLM, or request human review.
Clear division of labor: Jev handles classification, scoring, routing, and risk checks while generative models keep the open-ended reasoning and writing work.

This is a stronger software contract, not a guarantee that every decision is correct. Jev can still select the wrong valid option. The advantage is that your application receives a predictable value and can decide how much trust to place in it.

Install the LangChain integration

You need Python, TypeSafe API access, and langchain-typesafe:

pip install langchain-typesafe
export TYPESAFE_API_KEY="your-api-key"

Keep the key in an environment variable or secret manager rather than source control.

Make the first decision

Let us start with the simplest question: does this incident need attention right now?

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()

response = classifier.invoke(
    state=(
        "The deploy failed twice and customers are seeing 500s. "
        "Can someone look now?"
    ),
    questions={
        "urgent": Noul(
            instructions="Does this need attention right now?"
        ),
    },
)

urgency = response.nouls["urgent"].noul

urgency is a probability, not a paragraph. Your application can decide what it means:

if urgency >= 0.9:
    page_on_call_engineer()
elif urgency >= 0.6:
    send_for_review()
else:
    add_to_normal_queue()

Those thresholds are examples, not universal defaults. You should choose them using labeled cases from your own workflow.

Explore several decisions in one request

The more interesting shape is one state with multiple questions:

Support ticket state
    |-- Choice: billing, technical, sales, spam
    |-- Score: severity
    |-- Noul: possible abuse?
    `-- Noul: human review required?

Traditional agent code might make several sequential model calls for those judgments. Jev evaluates the questions in parallel. Extra question text still counts toward input, but the design avoids generating a separate written response for every branch.

This pattern could work well for content checks too: ask whether an answer is relevant, whether it contains sensitive data, whether it follows policy, and whether it needs escalation—all against the same trace.

Use case 1: route work to the right model

One practical use is model routing. A lookup or extraction task may not need the same model as an architecture review. LangChain’s experimental ModelRouterMiddleware lets Jev choose among models using criteria you define:

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import (
    ModelChoice,
    ModelRouterMiddleware,
)

router = ModelRouterMiddleware(
    choices={
        "fast": ModelChoice(
            model="openai:luna",
            criteria="Direct lookups, extraction, and localized changes.",
        ),
        "powerful": ModelChoice(
            model="openai:sol",
            criteria="Architecture and high-stakes decisions.",
        ),
    },
    instructions="Choose the least costly model that can complete the task.",
)

agent = create_agent("openai:gpt-5.6-luna", middleware=[router])

The selected model, probabilities, and confidence remain available in agent state. That gives you useful data for checking whether the router actually saves cost without hurting outcomes.

Use case 2: check tool calls before they run

Another interesting use is the safety layer around an agent. LangChain’s experimental AutoModeMiddleware uses Jev to examine proposed tool calls and block actions it classifies as risky:

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import AutoModeMiddleware

guardrail = AutoModeMiddleware(tools=["bash"])

agent = create_agent(
    "openai:gpt-5.6-luna",
    middleware=[guardrail],
)

I would treat this as an extra checkpoint, not a complete security boundary. A classifier can be wrong. Sensitive tools still need deterministic permissions, sandboxing, scoped credentials, and human approval where appropriate.

Use case 3: build a fast first-pass reviewer

Jev also looks useful as the first layer of a cascade:

incoming state
    -> Jev makes a fast decision
        -> clear + low-risk: continue automatically
        -> uncertain: verify with a stronger LLM
        -> high-risk: request human review

Possible inputs include support tickets, agent traces, invoices, expense reports, search candidates, and generated content. The important part is that the allowed decisions are known in advance.

This setup does not ask Jev to do everything. It uses Jev for volume, an LLM for difficult reasoning or explanation, and humans for consequential edge cases.

What makes the model technically interesting?

TypeSafe says Jev gives up arbitrary string generation and produces all requested outputs in parallel. The company reports 70–500 ms end-to-end latency and input pricing of $0.042 per million tokens, with output not metered.

In TypeSafe’s four published workflow evaluations, Jev averaged 67.8% at about $0.0004 and 0.4 seconds per sample. GPT-5.6 Terra reached 67.9% in the same harness at $0.0304 and 10.1 seconds. GPT-5.6 Sol reached a higher 74.1% at $0.0836 and 23.3 seconds.

So the technical story is not “Jev is always more accurate.” It is “Jev may offer a useful accuracy, latency, and cost tradeoff for decision-shaped workloads.”

TypeSafe also says Jev is trained with Reinforcement Learning for Calibrated Decisions (RLCD), with the goal of making reported probabilities reflect actual correctness. Detailed training methods and standard public calibration results are not yet available, so this is an area worth testing rather than assuming.

A small evaluation plan

If you want to explore Jev, start with one reversible decision that already runs at meaningful volume. Run it in shadow mode before letting it take action.

For each case, record:

The input and versioned question schema.
Jev’s answer, probability, and confidence.
The current system’s answer.
The eventual labeled outcome.
Latency and total cascade cost.

Then compare accuracy, precision and recall by class, calibration, escalation rate, and p50/p95/p99 latency. Include an unknown or none_of_the_above option if the choice set may be incomplete.

One important detail: TypeSafe’s published workflow benchmark uses the average predictions of GPT-6 Astra and Fable 5.1 as reference probabilities, not human-labeled ground truth. TypeSafe also acknowledges possible workflow-author bias and says its largest headline gains are probably at the high end of real-world improvements. Your own labeled data is the test that matters.

What Jev does not do

Jev is not designed for conversation, summarization, code generation, or detailed explanations. A typed response can also be semantically wrong even when its schema is perfect.

Public material does not yet provide the model’s parameter count, detailed architecture, full RLCD recipe, standard calibration curves, or complete production SLA. And for a stable, narrow domain, a conventional small classifier may still be the simpler choice.

These are not reasons to ignore Jev. They are the questions that make exploring a new model useful.

Final thoughts

Jev introduces a clean separation that is easy to miss when every AI product is built around chat: sometimes software needs language, and sometimes it only needs a decision.

For developers, the fun part is figuring out where that decision layer belongs. Try it on routing, triage, scoring, or a low-risk guardrail. Keep the first experiment measurable. Let Jev handle the fuzzy judgment, then let code decide what happens next.

Read TypeSafe AI’s System One and Jev announcement for the original model claims and caveats, and LangChain’s Jev harness guide for the integration examples used here.

Build with Jev on AIHubMix

AIHubMix now supports Jev. Visit AIHubMix to access the model and start testing decision-shaped workloads without adding another standalone model provider to your workflow.

Begin with a single Noul, Choice, or Score task, capture the returned probabilities, and compare them with your existing classifier or LLM path. Once the results hold up on your own labeled data, you can expand the experiment into routing, triage, scoring, and agent guardrails.

How I Built an AI Product Ad Pipeline with Claude Code and AIHubMix

AIHubMix — Wed, 16 Sep 2026 15:50:18 +0000

The goal was straightforward: start with one product image, generate three references of the same character, and create a 20-second, 720p vertical ad.

The engineering work happens between the model calls: passing character identity from one image to the next, registering a photorealistic virtual person as a usable asset, recovering asynchronous tasks, and ensuring that multiple asset IDs reach the video endpoint as separate arguments.

This article breaks down a working Python implementation built on AIHubMix. Claude Code helped organize prompts and execute the workflow; the script sent every API request through AIHubMix.

AIHubMix is useful here for more than sharing one Base URL. It covers most mainstream models through one API service, so the image stage can use Seedream, the video stage can switch to Seedance, and later versions can select another model without rebuilding authentication and request entry points for every supplier.

AIHubMix connects to multiple suppliers and automatically selects an available low-latency route, reducing the effect of a single supplier's instability. For asynchronous image and video jobs, one entry point is easier to maintain and fits a multi-stage workflow orchestrated with Claude Code. Actual model availability, routes, and latency still depend on the platform state at request time.

The code, model IDs, and schema details come from a project snapshot dated September 16, 2026. Check the current API before reusing them. No online generation API was called while preparing this publication package.

Download the Code and Run the Shortest Path

Download the Complete Starter

You need Python 3, your own AIHubMix API key, access and quota for the required models, and public URLs for the three reference images. The script uses only the Python standard library; no SDK installation is required.

After extracting the package, enter seedance-starter and run:

cp .env.example .env

Edit .env and add your key. Upload assets/frame-01.jpg, assets/frame-02.jpg, and assets/frame-03.jpg to your own public image hosting, then replace these three URLs:

REF_A='https://your-host.example/frame-01.jpg'
REF_B='https://your-host.example/frame-02.jpg'
REF_C='https://your-host.example/frame-03.jpg'
python3 flow.py check "$REF_A" "$REF_B" "$REF_C"
python3 flow.py assets "$REF_A" "$REF_B" "$REF_C"

After the assets become active, read their saved IDs and generate the video:

python3 - <<'PYCODE'
import json
import subprocess
import sys
from pathlib import Path

state = json.loads(Path("state.json").read_text())
refs = ["asset://" + asset_id for asset_id in state["asset_ids"]]
subprocess.run([sys.executable, "flow.py", "video", *refs], check=True)
PYCODE

The completed result is saved to out/video.mp4. This shortest path reuses the included images and covers asset registration plus video generation. To regenerate the images for another product, follow the dependency chain below.

1. Model the Workflow as Explicit State

Product image and prompts
  → three character reference images
  → publicly accessible image URLs
  → active virtual-portrait assets in one group
  → asset:// references
  → video task ID
  → completed
  → local MP4

The script exposes one command for each state transition:

Command	Responsibility
`stills`	Generate and download the reference images in order
`check URL...`	Verify HTTP 200 and an image Content-Type
`assets URL...`	Create or reuse an asset group, register images, and wait for activation
`video asset://...`	Create a video task, poll it, and download the result
`status [ID]`	Resume polling or download an existing task
`tasks`	List recent tasks when a create response was lost

Public image hosting is a manual step; the script does not push files to GitHub.

2. Image Generation Is a Dependency Chain

prompts.json defines these reference relationships:

A: prompt-a.txt → frame-01.jpg
B: product image + frame-01.jpg + prompt-b.txt → frame-02.jpg
C: product image + frame-02.jpg + prompt-c.txt → frame-03.jpg

A establishes the person, wardrobe, setting, and lighting. B introduces the product. C introduces its use action. B and C both reference the original product image to constrain packaging.

To switch products, replace assets/product.png, update the runtime prompts, back up and move the three old reference images, then run:

python3 flow.py stills

Existing image files are skipped. If you edit a prompt and rerun without moving its output, nothing may happen. After changing A, decide whether B and C also need regeneration.

character-lock.txt is a writing reference; the script never reads it. Editing that file alone does not change an API request.

The script skips existing files. If you change a prompt, back up and move the corresponding output before rerunning. Changing A may also require regenerating B and C.

The three images establish character identity, product presentation, and the use action.

3. One API Does Not Mean One Request Schema

The project uses these full model IDs:

IMAGE_MODEL = doubao-seedream-5-0-pro-260628
VIDEO_MODEL = doubao-seedance-2-5-260628

In the bundled schema snapshot, image generation uses size, while video generation uses aspect_ratio. They can coexist in the local configuration, but the script must build two different request bodies.

A unified API solves model access and switching; it does not make model-specific parameters interchangeable. This project keeps shared authentication and task handling in flow.py, then assembles Seedream and Seedance requests separately.

Here is the video request structure. Replace ACTIVE_ASSET_ID with an asset ID registered and activated in your account:

{
  "model": "doubao-seedance-2-5-260628",
  "prompt": "the complete contents of prompts/prompt-video.txt",
  "duration": 20,
  "resolution": "720p",
  "aspect_ratio": "9:16",
  "generate_audio": true,
  "input_references": [
    {"type": "image_url", "url": "asset://ACTIVE_ASSET_ID"}
  ]
}

The request is sent to POST /ai/v1/videos. The real script creates one input_references item per asset.

preflight() checks the cached schema for unknown top-level fields and catches accidental parameter mixing locally. It is not a complete JSON Schema validator and does not validate every type, enum, or range.

4. Register a Photorealistic Virtual Person Before Referencing It

Passing the photorealistic character references directly as image URLs produced this error in the project:

doubao_real_person_required

Because the character in this example was AI-generated, the correct classification was virtual_portrait. The script then performs these steps:

POST /ai/v1/asset-groups creates a virtual-portrait group.
POST /ai/v1/asset-groups/{group_id}/assets registers each public image URL.
GET /ai/v1/assets/{asset_id} polls until the asset becomes active.
The video request uses an asset:// reference.

All references in one video request should belong to the same group. A photograph of a real person must follow the identity-verification path and must not be classified as a virtual person.

The URL must return the actual image. A GitHub /blob/ page can return HTTP 200 while its Content-Type is HTML, so the script checks both status and media type.

The references were generated and all three assets were active; the video task was still running when this screenshot was captured.

5. Do Not Pass Three Asset IDs as One String

The source project encountered asset_invalid in zsh because multiple references stored in a plain string reached the program as one argument.

The quick-start command calls the script with a Python argument list:

subprocess.run([sys.executable, "flow.py", "video", *refs], check=True)

Each reference becomes a separate argument without relying on shell word splitting.

6. Recover an Async Task Instead of Creating Another One

Video generation is asynchronous. An HTTP 200 from the create endpoint does not mean that the video is complete.

The script saves the returned video_id to state.json, polls the task's status, and downloads only after it reaches completed. Resume after a local timeout with:

python3 flow.py status

If the create response was lost, list recent tasks first:

python3 flow.py tasks
python3 flow.py status VIDEO_TASK_ID

video() never automatically retries the create request, because the server may already have created the task. Read-only status requests can be retried; creation should be handled differently.

7. Give the Prompt Testable Constraints

Once the API works, the output still needs to satisfy the ad brief.

The final video prompt divides one continuous take into four actions: present, spray, react, and present again. The camera may push in only to a mid-close shot. The product must stay visible, and the label should remain legible during the first and last three seconds.

The full text is in prompts/prompt-video.txt. Resolution and duration belong in configuration; character action and camera limits belong in the prompt. Both must be verified in the generated result.

Reusing the Structure

The starter preserves the source implementation. Its documentation calls out a stale code comment, existing-output skips, output-file replacement, and asset-group reuse.

Offline checks can verify local configuration, dependencies, and request assembly. They cannot prove account permissions, current endpoint availability, routing behavior, or output quality. Run the shortest path with the included references before replacing the product and character so that failures are easier to isolate.

To switch image or video models later, select the target model in AIHubMix, read its current schema, and update the model ID, parameters, and result handling. A unified entry point lowers the switching cost, but it does not remove differences in model capability or request fields.

See the starter package for the complete workflow. README.md contains the runbook, while docs/PROMPTS.md and docs/TROUBLESHOOTING.md cover prompt adaptation and failure modes.

Amp Reopens BYOK After a Year: Connecting and Configuring AIHubMix

AIHubMix — Tue, 15 Sep 2026 07:25:14 +0000

Amp has reopened BYOK (Bring Your Own Key), and AIHubMix now supports it. This guide uses Anthropic's Claude models as the example and walks through pointing Amp at the AIHubMix API via Custom URL and Model Routing — covering the API key, model name mapping, and project setup.

If you're searching for "Amp BYOK setup", "connect Amp to AIHubMix", "AIHubMix API key", "Amp Custom URL", or "Amp Model Routing", the steps below cover it.

What is Amp good for?

Multi-model workflows: assign different models to different modes and agents — Claude, GPT, or a fast model for lightweight work.
Whole-project context: Amp reads across the codebase, edits files, runs commands, and executes tests.
BYOK and custom routing: pick your own models and providers through Model Routing, Custom URL, and third-party API services.
Web and CLI together: configure models in the browser, then keep working from the terminal.
Built for teams: share any thread and work through it alongside your teammates.
Cloud-synced threads: every thread syncs to the cloud automatically, so your team always picks up from the same state.

The rest of this guide uses Anthropic's Claude models to show how to connect AIHubMix to Amp.

Why route Amp through AIHubMix? One key and one Base URL reach 400+ models across providers, the endpoint is Anthropic Messages API–compatible (so Amp talks to it natively), and per-key model name mapping plus error fallbacks let you adapt to whatever naming a client expects. Create an account →

Part 1 — Connect the API

Step 1: Open Personal Settings

From the Amp home screen, click Personal Settings in the bottom-left corner.

Step 2: Add a custom model route

Find Model Routing in the left sidebar, click Add on the right, and choose Custom URL.

Step 3: Create an API key and set up model name mapping

Head to the AIHubMix console and create an API key, then configure a model name mapping on it.

Amp expects model names in provider/model form — for example anthropic/claude-fable-5-1. AIHubMix model IDs carry no provider/ prefix, so add a mapping that rewrites the name Amp sends to the model ID AIHubMix serves:

Alias (what Amp sends)	Target (AIHubMix model ID)
`anthropic/claude-fable-5-1`	`claude-fable-5-1`

Requests using the alias are rewritten to the target model ID. Each key supports up to 5 mappings, and you can optionally add fallback models that are retried, in order, when a request errors.

Step 4: Fill in the connection details

Back on Amp's Custom URL screen, fill in the fields:

API Key: the key you just created in AIHubMix.
API Format: select Compatible with the Anthropic Messages API.
Base URL: https://aihubmix.com — Amp confirms below the field that requests go to https://aihubmix.com/v1/messages.
Models: list the aliases you mapped, one per line (e.g. anthropic/claude-fable-5-1). Amp resolves each one and shows its display name underneath.

Leave Activate after creation checked so new requests start routing through the provider immediately, then click Create.

Step 5: Verify the connection

Once saved, the Model Routing page lists your new Custom URL. Click Check Access to test the connection.

A working key returns Valid Key along with the GET https://aihubmix.com/v1/models probe, an HTTP 200 response, and a count of visible models. The model list below then shows everything this Custom URL can reach.

Part 2 — Create a project and a thread

Step 6: Create a project

Click the projects entry in the bottom-left corner, then the new-project button in the top right.

Choose Start from scratch, enter a project name, and finish creating the project.

Step 7: Create a thread

Inside the project, click New Thread to start a task.

Part 3 — Assign models and start working

Step 8: Assign a model to each role

Go back to Personal Settings and open Mode Dial. Each mode picks its models automatically; here you can pin a specific model and reasoning effort for a mode's Main Agent, its Oracle, and its Subagents. Anything left on Auto keeps following Amp's own routing.

Step 9: Pick a mode and start the conversation

Click New Thread, choose the mode and model you want, and start chatting or hand Amp a development task.

That's the full setup. With one AIHubMix key, Amp can reach Claude, GPT, and every other model on the platform — and you can swap the model behind any mode without touching the rest of your configuration.

Get your AIHubMix API key →

AIHubMix — https://aihubmix.com/
Amp — https://ampcode.com/

GLM-5.3-Flash API Pricing: AIHubMix vs OpenRouter, Including the 5.5% Fee

AIHubMix — Tue, 01 Sep 2026 12:17:26 +0000

GLM-5.3-Flash targets coding agents, long-context reasoning, and extended software-engineering workflows. Those workloads often send a large amount of repeated context, so a useful price comparison needs to include both prompt caching and platform-level fees.

This post compares the public rates available on September 1, 2026.

Base API rates

Route	Input / 1M	Output / 1M	Cache read / 1M	Platform fee
Z.ai API	$0.075	$0.250	$0.015	None listed
OpenRouter, Z.ai provider	$0.075	$0.250	$0.015	5.5%
AIHubMix	$0.056	$0.197	$0.014	None listed

AIHubMix, OpenRouter, and Z.ai are all running a limited-time 50% promotion through September 9, 2026 at 16:00 UTC.

Applying OpenRouter's platform fee

OpenRouter lists a 5.5% platform fee for pay-as-you-go accounts. Its model catalog still shows the provider's unmarked-up inference rate, so the effective cost of fully used credits can be modeled as:

effective_cost = model_cost * 1.055

For GLM-5.3-Flash, that produces effective rates of approximately:

input:     $0.075 * 1.055 = $0.0791 / 1M
output:    $0.250 * 1.055 = $0.2638 / 1M
cache read:$0.015 * 1.055 = $0.0158 / 1M

Adding prompt-cache ratios

Z.ai automatically identifies reusable prompt prefixes. A cache hit is part of the total input-token count, but is charged at the lower cache-read rate instead of the normal input rate.

For a workload with I total input tokens, cache ratio r, and O output tokens:

standard_input = I * (1 - r)
cached_input   = I * r

cost = standard_input * input_rate
     + cached_input * cache_read_rate
     + O * output_rate

The following examples use one million total input tokens and one million output tokens. Both platforms are assigned the same cache ratio to isolate the rate difference.

Cache ratio	AIHubMix	OpenRouter before fee	OpenRouter after fee	AIHubMix savings
0%	$0.253	$0.325	$0.343	26.2%
50%	$0.232	$0.295	$0.311	25.5%
80%	$0.219	$0.277	$0.292	24.9%

At an 80% cache ratio, for example, the one million input tokens consist of 200,000 standard input tokens and 800,000 cached tokens.

Reproduce the calculation

const platforms = {
  aihubmix: { input: 0.056, output: 0.197, cache: 0.014, fee: 0 },
  openrouter: { input: 0.075, output: 0.25, cache: 0.015, fee: 0.055 }
};

function cost({ input, output, cache, fee }, cacheRatio) {
  const modelCost =
    (1 - cacheRatio) * input +
    cacheRatio * cache +
    output;

  return modelCost * (1 + fee);
}

for (const ratio of [0, 0.5, 0.8]) {
  console.log({
    ratio,
    aihubmix: cost(platforms.aihubmix, ratio),
    openrouter: cost(platforms.openrouter, ratio)
  });
}

Prices in the code are dollars per million tokens, and the example fixes both total input and total output at one million tokens.

Takeaway

Caching reduces both bills. Because the cache-read rates are close, AIHubMix's relative price advantage narrows slightly as the cache ratio increases. After including OpenRouter's pay-as-you-go fee, AIHubMix remains approximately 24.9% to 26.2% less expensive across the scenarios above.

OpenRouter may still be the right choice when its unified provider ecosystem is the deciding feature. Z.ai remains the direct vendor route. For cost-sensitive GLM-5.3-Flash coding agents and batch jobs, AIHubMix currently has the lowest effective cost in this comparison.

Pricing can change, so verify the linked model pages before deploying a long-running workload.

GPT-5.6 Sol at 50% Off: AIHubMix vs. OpenRouter Pricing, Fees, and Setup

AIHubMix — Wed, 19 Aug 2026 11:43:16 +0000

OpenAI's GPT-5.6 Sol is currently available at a limited-time 50% discount for short-context API requests. AIHubMix and OpenRouter show the same discounted token rates, but the final pay-as-you-go cost is not identical.

The difference comes from the platform fee.

TL;DR

Discounted model: GPT-5.6 Sol
AIHubMix model ID: gpt-5.6-sol-disc
Short-context rate: $2.50/M input, $0.25/M cached input, $15/M output
AIHubMix platform fee: No separate platform fee added to the displayed model price
OpenRouter pay-as-you-go fee: 5.5% according to its public pricing page
Long-context threshold: Inputs above 272K tokens use a different pricing tier

All prices in this article were checked on August 19, 2026. Pricing and availability can change, so verify the linked pages before committing to a large workload.

The advertised token rates are the same

For requests with up to 272K input tokens, both platforms currently display:

Token type	Price per million tokens
Input	$2.50
Cached input	$0.25
Output	$15.00

These rates are 50% below OpenAI's standard short-context rates of $5/M input and $30/M output.

At the model-rate level, AIHubMix and OpenRouter look identical. The difference appears when you fund a standard pay-as-you-go account.

What the 5.5% fee means in practice

Consider a workload that consumes one million input tokens and one million output tokens.

Input:  1 x $2.50 = $2.50
Output: 1 x $15.00 = $15.00
Model usage:         $17.50

On AIHubMix, the displayed cost for that usage is $17.50.

On OpenRouter, funding $17.50 of pay-as-you-go usage costs approximately $18.46 before tax after the published 5.5% platform fee.

The gap becomes more visible at production volume. Suppose an agent workflow uses 10 million input tokens and 2 million output tokens:

Input:  10 x $2.50 = $25.00
Output:  2 x $15.00 = $30.00
Model usage:          $55.00

Route	Approximate final cost
AIHubMix	$55.00
OpenRouter pay-as-you-go	$58.03 before tax

That $3.03 difference comes from the platform fee, not from a different model token rate.

For coding agents, repository analysis, deep research, evaluation suites, and other long-running workflows, a small percentage compounds quickly.

Use the discounted AIHubMix model ID

The promotion is exposed through a separate AIHubMix model ID:

gpt-5.6-sol-disc

The regular gpt-5.6-sol route remains available at the standard price. Your application must explicitly select the discounted model ID to receive the promotion.

AIHubMix provides an OpenAI-compatible endpoint, so an existing OpenAI SDK integration only needs a different base URL, API key, and model name:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AIHUBMIX_API_KEY"],
    base_url="https://aihubmix.com/v1",
)

response = client.chat.completions.create(
    model="gpt-5.6-sol-disc",
    messages=[
        {
            "role": "user",
            "content": "Review this implementation and identify reliability risks.",
        }
    ],
)

print(response.choices[0].message.content)

The discounted route supports OpenAI-compatible Chat Completions and Responses APIs, including streaming.

Explore the model page: GPT-5.6 Sol Disc on AIHubMix

Long context has a different tier

GPT-5.6 Sol supports a context window of approximately 1.05 million tokens and a maximum output of 128K tokens. Requests with more than 272K input tokens use the long-context tier.

Current AIHubMix discount-route pricing:

Input size	Input	Cached input	Output
Up to 272K tokens	$2.50/M	$0.25/M	$15.00/M
More than 272K tokens	$5.00/M	$0.50/M	$22.50/M

The long-context tier is also 50% below OpenAI's corresponding standard rates of $10/M input and $45/M output.

A million-token window is useful for large repositories, document collections, research material, and long agent histories. It is not a reason to stop managing context. Removing irrelevant content and reusing stable prompt prefixes still improves both cost and latency.

Price is not the only routing decision

For a standard pay-as-you-go user focused on final cost, the current public terms favor AIHubMix: the token discount is the same, while the fee structure is different.

Production teams should still consider operational requirements:

AIHubMix lists OpenAI and Azure providers for this model and can retry another provider when a request fails or becomes too slow.
OpenRouter may be convenient for teams already using its routing stack. Enterprise fee terms may differ.
Direct OpenAI access may be preferable when a company needs a direct commercial relationship or specific account controls.
Reliability, routing behavior, support, account terms, and migration cost can matter more than a small price difference for some workloads.

Where the discount makes the most sense

GPT-5.6 Sol is the flagship model in the GPT-5.6 family. It is designed for demanding work such as advanced coding, complex reasoning, long-horizon agents, science, cybersecurity, and professional knowledge tasks.

The discount is especially useful for:

Repository-level code review
Command-line and coding agents
Deep research and multi-step synthesis
Large-document analysis
Automated evaluations that require a frontier model

For extraction, classification, support, or high-volume routing, a smaller model may still deliver a lower total cost. A 50% discount makes Sol more accessible, but it does not make Sol the right model for every request.

Takeaway

AIHubMix and OpenRouter currently advertise the same discounted GPT-5.6 Sol token rates. The final pay-as-you-go bill differs because OpenRouter publishes a 5.5% platform fee, while AIHubMix does not add a separate platform fee to its displayed model price.

For AIHubMix users, the practical step is simple: call gpt-5.6-sol-disc to use the limited-time discount.

Read the original pricing analysis on the AIHubMix blog.

This comparison is based on public pricing information. Prices, fees, and availability may change.

GLM-5.3 API Guide: Always-On Thinking, 3 Effort Levels, and the Support Matrix

AIHubMix — Sat, 15 Aug 2026 07:25:28 +0000

GLM-5.3 is Z.ai's August 2026 flagship model for coding and long-horizon agentic work. It uses the same base model as GLM-5.2; the gains come from post-training.

On AIHubMix, the limited-time preview model ID is coding-glm-5.3. It is available through OpenAI-compatible Chat Completions, OpenAI Responses, and Claude-compatible Messages.

The important migration change is simple but consequential: thinking is always on. You can no longer disable it. Instead, you select one of three reasoning_effort levels: low, high, or max (the default).

The findings below come from live AIHubMix calls made on August 14, 2026. The full hands-on guide includes every request, observed response, and the complete verification notes.

Specs and migration changes

Item	GLM-5.3
Context window	1,048,576 tokens
Maximum output	131,072 tokens
Input	Text
Thinking	Always on
Reasoning effort	`low`, `high`, `max`; default `max`
AIHubMix model ID	`coding-glm-5.3`

The maximum output value is enforced. Sending max_tokens=999999 returned HTTP 400 with the valid range [1,131072].

Compared with GLM-5.2:

thinking.type supports enabled only. The old disabled behavior is gone.
reasoning_effort is now a three-level control instead of the previous compatibility mapping.
Z.ai recommends max for coding tasks.

In our AIHubMix test, sending thinking: {"type": "disabled"} still returned 200, but thinking continued and reasoning_content was present. Treat it as converted behavior, not a successful off switch. To reduce reasoning tokens, use reasoning_effort="low".

1. Thinking output across the three APIs

Chat Completions

Thinking text is returned in reasoning_content; in streaming responses it arrives as delta.reasoning_content.

from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key="<AIHUBMIX_API_KEY>",
)

completion = client.chat.completions.create(
    model="coding-glm-5.3",
    reasoning_effort="max",  # low / high / max
    extra_body={"thinking": {"type": "enabled"}},
    messages=[{
        "role": "user",
        "content": "Compute the square root of (17*23-19*11), rounded down. Digits only.",
    }],
)

print(completion.choices[0].message.reasoning_content)
print(completion.choices[0].message.content)  # 13

On the same arithmetic question, usage reported 27 reasoning tokens with low and 39 with max.

Responses

Responses returns a reasoning output item. The visible reasoning summary is a summary_text entry inside its summary array.

response = client.responses.create(
    model="coding-glm-5.3",
    input="What is the capital of France? City name only.",
)

# Observed item types: ["reasoning", "message"]
# The reasoning item contains:
# {"type": "reasoning", "summary": [{"type": "summary_text", ...}]}

No opt-in is required. The default request, with no reasoning parameter, already returned the reasoning item and 80 reasoning tokens in this test.

Messages

The Claude-compatible Messages API returns native thinking content blocks before the text block.

from anthropic import Anthropic

client = Anthropic(
    api_key="<AIHUBMIX_API_KEY>",
    base_url="https://aihubmix.com",
)

response = client.messages.create(
    model="coding-glm-5.3",
    max_tokens=4096,
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

# Observed content block types: ["thinking", "text"]

2. Tool calls and parallel execution

Function calling worked on all three APIs. The Responses API also produced two parallel calls in one turn when asked for weather in two cities.

response = client.responses.create(
    model="coding-glm-5.3",
    input="Check today's weather in Shanghai and Beijing",
    parallel_tool_calls=True,
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Get weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    }],
)

# Observed: two function_call output items in one turn

Two practical details matter:

The upstream accepts up to 128 function definitions and documents tool_choice: auto as the native mode.
Chat Completions correctly honors tool_choice: "none". On Messages, tool_choice: {"type": "none"} still produced a tool call in testing. Remove the tools parameter entirely when tools must be disabled on Messages.

3. JSON output

Chat Completions supports response_format: json_object:

completion = client.chat.completions.create(
    model="coding-glm-5.3",
    messages=[{
        "role": "user",
        "content": "What is the capital of France? Answer in JSON with key answer.",
    }],
    response_format={"type": "json_object"},
)

# {"answer": "Paris"}

Responses uses text.format:

response = client.responses.create(
    model="coding-glm-5.3",
    input="What is the capital of France? Answer in JSON with key answer.",
    text={"format": {"type": "json_object"}},
)

The upstream does not list a strict json_schema mode. For schema-critical applications, include the schema in the prompt and validate the result client-side. Messages produced valid JSON when prompted, but has no equivalent dedicated field in this test.

4. Automatic context caching

Caching is implicit; there is no parameter to enable. Two consecutive requests sharing an identical long prefix produced 960 cached tokens on Chat Completions and Responses.

Chat: usage.prompt_tokens_details.cached_tokens
Responses: usage.input_tokens_details.cached_tokens
Messages: usage.cache_read_input_tokens

The Messages field was present, but we did not reproduce a hit in this round. Caches warm per channel, so a load-balancer switch can produce a miss.

5. Sampling validation differs by API

GLM endpoints use temperature in [0,1] with default 1.0, and top_p in [0.01,1] with default 0.95. Z.ai recommends tuning only one.

The API surfaces do not validate these values consistently. Messages rejected temperature=3 with HTTP 400 and explicitly reported [0,1]. Chat Completions and Responses silently accepted the same out-of-range value with 200.

Validate sampling values in your client instead of relying on the gateway.

Capability x API matrix

Capability	Chat Completions	Responses	Messages
Generation / streaming	Yes	Yes	Yes
Thinking content	`reasoning_content`	`reasoning` item / `summary_text`	`thinking` block
Thinking intensity	`reasoning_effort`	`reasoning_effort`	Accepted with 200
Disable thinking	No; `disabled` still thinks	No toggle	No; same behavior as Chat
Function calling	Yes	Yes	Yes
Parallel tool calls	Not verified	Yes; 2 calls observed	Not verified
Disable tool calls	`tool_choice: "none"`	No calls observed	Remove `tools`; typed `none` failed
JSON mode	`response_format`	`text.format`	Prompt convention
Strict `json_schema`	Not listed upstream	Not listed upstream	Not listed upstream
Cache accounting	`prompt_tokens_details.cached_tokens`	`input_tokens_details.cached_tokens`	Field present; no hit reproduced
Max-output validation	400 with `[1,131072]`	Not tested	Not tested
Out-of-range sampling	Silently accepted	Silently accepted	400 with `[0,1]`

Production checklist

Remove any code path that assumes thinking can be disabled.
Use reasoning_effort="low" when you need lower reasoning spend.
Read thinking from the protocol-specific response field.
Remove tools entirely to disable tools on Messages.
Validate JSON Schema client-side.
Validate temperature and top_p before sending requests.
Normalize the three cache-accounting field names in observability code.

GLM-5.3's model behavior is consistent in its core capabilities, but protocol compatibility is not field-for-field. Treat Chat Completions, Responses, and Messages as three adapters around the same model, especially for thinking, tools, JSON output, and usage accounting.

Current pricing and availability are on the AIHubMix model page. For all examples and observed responses, read the complete GLM-5.3 hands-on guide.

DeepSeek V4 Pro (0813) Across 3 APIs: Thinking Passback, Tool Calls, and Hidden 400s

AIHubMix — Fri, 14 Aug 2026 11:58:00 +0000

DeepSeek V4 Pro (0813) is available on AIHubMix through three protocol surfaces:

OpenAI-compatible Chat Completions
OpenAI Responses
Claude-compatible Messages

They reach the same model, but the request and response shapes are not interchangeable. The largest production trap is thinking history: on tool-using multi-turn conversations, dropping the previous turn's thinking content causes a hard HTTP 400.

The findings below come from calls made on August 13, 2026 against the AIHubMix production APIs. The full hands-on guide includes complete examples, observed responses, and the full capability matrix.

The short version

Capability	Chat Completions	Responses	Messages
Endpoint	`/v1/chat/completions`	`/v1/responses`	`/v1/messages`
Thinking off	`thinking.type="disabled"`	`reasoning.effort="none"`	`thinking.type="disabled"`
Thinking passback	`reasoning_content`	`type="reasoning"` item	`thinking` block
Tool schema	nested `function`	flat definition	`input_schema`
Structured output	`response_format`	`text.format`	no native field
Web search	no	`web_search`	`web_search_20250305`

The model has a 1M-token context window, accepts text input, and thinks by default. Sending an excessive max_tokens value is rejected instead of silently truncated; a request with max_tokens=9999999 returned 400 and identified the ceiling as 393,216.

One subtle input warning: Responses does not reject image parts. Unsupported image and file inputs are replaced with placeholder text. "No error" does not mean the model saw the image.

1. Preserve thinking history verbatim

In thinking mode, the previous turn's thinking is part of the conversation state. This matters most in agent loops where the model emits a tool call and the client sends the tool result back.

Chat Completions

Preserve reasoning_content on the historical assistant message:

messages = [
    {"role": "user", "content": "What is 1 + 1? Remember the result."},
    {
        "role": "assistant",
        "content": "2",
        "reasoning_content": "<reasoning_content from the previous response>",
    },
    {"role": "user", "content": "Add 1 to the result."},
]

Dropping reasoning_content returned HTTP 400. Restoring it made the same request continue normally.

Responses

Append the prior response.output without filtering its items:

input = previous_input + response.output + [
    {"role": "user", "content": "Add 1 to the result."}
]

A common framework pattern is to retain only items where type == "message". That silently removes the reasoning item and triggers the next-turn 400.

Messages

Pass the previous response.content back as the assistant message:

messages = [
    {"role": "user", "content": "What's the weather in Paris?"},
    {"role": "assistant", "content": response.content},
    {"role": "user", "content": [tool_result_block]},
]

Keep both the thinking and tool_use blocks. Removing the thinking block returned an invalid_request_error.

2. Turning thinking off requires different fields

Thinking is enabled by default. The off switch depends on the protocol:

# Chat Completions
extra_body={"thinking": {"type": "disabled"}}

# Responses
reasoning={"effort": "none"}

# Messages
extra_body={"thinking": {"type": "disabled"}}

The result is observable. Chat and Messages stop returning their thinking fields. Responses reports zero reasoning tokens and omits the reasoning output item.

low, high, and max were accepted, but token counts for the same prompts did not vary monotonically and the selected level was not echoed. The only level whose effect was unambiguous from the caller side was Responses none.

3. Tool schemas are protocol-specific

Chat Completions wraps a function definition inside function:

tools=[{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

Responses uses a flat definition:

tools=[{
    "type": "function",
    "name": "get_weather",
    "description": "Get weather for a city",
    "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
    },
}]

Messages uses input_schema.

There are two more gotchas:

tool_choice: "required" returns 400 on Chat and Responses while thinking is enabled. Use a named-function choice, or disable thinking before using required.
Parallel tool calling cannot be disabled. DeepSeek documents the relevant switches as ignored on Responses and Messages. Serialize calls in your client if ordering matters.

Tool definitions also consume context in full. A request containing 200 definitions succeeded in testing, but the prompt reached 6,105 tokens. Route only the tools relevant to the current task.

4. Structured output, caching, and web search

Chat Completions supports JSON mode through response_format. Responses supports strict JSON Schema through text.format:

response = client.responses.create(
    model="deepseek-v4-pro-0813",
    input="Return the number 1 under key a.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"a": {"type": "integer"}},
                "required": ["a"],
            },
        }
    },
)

Messages has no equivalent structured-output field. Carrying a schema in a forced tool is possible, but use Chat or Responses when hard schema guarantees are central.

Context caching is automatic. Repeated long prefixes produced cache hits under different usage fields:

Chat: prompt_tokens_details.cached_tokens
Responses: input_tokens_details.cached_tokens
Messages: cache_read_input_tokens

Put stable system instructions, knowledge snippets, and tool definitions at the front of the request.

Server-side web search worked on Responses and Messages. Chat accepted unknown search-like fields without error, but did not perform retrieval. Route search workloads to Responses or Messages.

Production checklist

Persist thinking content as normal conversation state.
Do not filter Responses output down to message items before passback.
Avoid tool_choice: "required" while thinking is enabled.
Keep the three tool-definition schemas separate.
Do not infer image support from the absence of an error.
Serialize parallel tool calls on the client when required.
Branch on HTTP status, not only error.type, for Responses errors.
Do not use the echoed model field as the sole routing or attribution signal.

DeepSeek V4 Pro's multi-protocol support is useful, but compatibility is a client-side responsibility. Treat thinking as durable conversation state and isolate protocol adapters around history, tools, usage, and errors.

For the complete 3-API matrix, additional code samples, logprobs behavior, current-path deviations, and FAQs, read the full AIHubMix guide. Current pricing and status are on the model page.

Nemotron 3.5 Lightning Is Now Free on AIHubMix

AIHubMix — Tue, 11 Aug 2026 14:15:37 +0000

NVIDIA Nemotron 3.5 Lightning is now available to use for free on AIHubMix.

Try Nemotron 3.5 Lightning on AIHubMix

Built for the execution layer of AI agents

Long-running agents spend much of their time on frequent operational work: calling tools, validating outputs, writing and reviewing code, formatting results, and delegating tasks to sub-agents. Using a large frontier model for every one of those steps can add unnecessary latency and cost.

Nemotron 3.5 Lightning is designed for this execution layer. It is an open 30B Mixture-of-Experts model with only 3B active parameters, combining the capacity of a larger model with a much smaller active compute footprint.

Key capabilities include:

30B total parameters with 3B active parameters
Context windows of up to 1 million tokens
Tool calling and tool-output validation
Coding and specialized task execution
Long-running autonomous-agent workflows
Fast, high-volume inference
Local deployment on supported NVIDIA hardware

Lightning for execution, larger models for planning

Nemotron 3.5 Lightning is the smallest member of the Nemotron 3 family. While larger models such as Nemotron 3 Super and Ultra are suited to advanced reasoning, orchestration, and complex planning, Lightning focuses on the high-frequency execution steps that dominate an agent's workload.

That makes it a practical workhorse for sub-agents, coding assistants, tool-driven workflows, and always-on agent systems.

Start using it for free

The free route is currently available on AIHubMix with zero input and output token pricing:

Model ID: nemotron-3.5-lightning-free
Input: $0 / 1M tokens
Output: $0 / 1M tokens
Context: up to 1M tokens

It works through AIHubMix's OpenAI-compatible API:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AIHUBMIX_API_KEY"],
    base_url="https://aihubmix.com/v1",
)

response = client.chat.completions.create(
    model="nemotron-3.5-lightning-free",
    messages=[
        {"role": "user", "content": "Help me validate this tool output."}
    ],
)

print(response.choices[0].message.content)

Explore Nemotron 3.5 Lightning and start building on AIHubMix

Seedance 2.5 vs MiniMax H3 vs Wan 3.0: An API-First Comparison

AIHubMix — Sat, 08 Aug 2026 14:49:37 +0000

Choosing an AI video model from demo clips is a poor engineering decision. A production team needs to know which inputs the model accepts, how long it can maintain continuity, how billing works, and how many attempts are required before an output becomes usable.

Seedance 2.5, MiniMax H3, and Wan 3.0 are now all available on AIHubMix. That makes it possible to evaluate the three models behind one API key and a common asynchronous task workflow.

This article compares confirmed product capabilities and proposes a repeatable test plan. It does not claim a universal visual-quality winner because no common public blind benchmark covers all three models.

Model matrix

Capability	Wan 3.0	MiniMax H3	Seedance 2.5
Provider	Alibaba Tongyi Lab	MiniMax	ByteDance Seed
AIHubMix model ID	`wan3.0-video`	`minimax-h3`	`doubao-seedance-2-5-260628`
Maximum single generation	30 seconds	15 seconds	30 seconds
Confirmed resolution	480p, 720p, 1080p on AIHubMix	Up to 2K	Not specified in the official launch post
Audio	Audio references and sound-aware video workflow	Native stereo generation	Joint audio-video generation
References	Text, image, audio, video, documents, and webpages	Text, image, video, and audio	Up to 30 images, 10 videos, and 10 audio clips
Editing focus	Unified reference, editing, replication, and motion driving	Multimodal editing and V2V motion transfer	Timestamp, green-screen, perspective, and reference editing
Best initial fit	Flexible production and ecommerce	Short 2K commercial clips with sound	Multi-shot narrative and targeted edits

One specification deserves caution: third-party pages frequently describe Seedance 2.5 as a 4K model, but ByteDance Seed's July 31 launch post does not state an output resolution. Treat resolution as platform-specific until the active API documentation confirms it.

Model 1: Wan 3.0

Wan 3.0 is the flexible production option. It supports a single generation of up to 30 seconds, and AIHubMix exposes 480p, 720p, and 1080p output tiers.

The broader Wan 3.0 workflow supports text, image, audio, and video references as well as structured sources such as documents, spreadsheets, presentations, PDFs, and webpages. This is useful when a generation needs to stay grounded in product documentation or an existing brand page.

Start with Wan 3.0 for:

ecommerce and product videos;
character animation centered on one stable subject;
continuous 10-to-30-second shots;
workflows that iterate at 480p before rendering at 1080p.

The primary failure mode to test is long-horizon continuity. A 30-second prompt should describe a temporal sequence, camera path, and explicit continuity constraints.

Model 2: MiniMax H3

MiniMax H3 generates up to 15 seconds of native 2K video with stereo audio. MiniMax highlights instruction following, accurate text and brand rendering, reference-based editing, and video-to-video motion transfer.

Start with H3 for:

product ads containing logos or small text;
sound-led short-form video;
2K product or interface shots;
transferring motion or camera language from a source video.

Its engineering tradeoff is duration. For longer narratives, treat each H3 generation as a shot and assemble the sequence in an external editor.

Model 3: Seedance 2.5

Seedance 2.5 generates up to 30 seconds of synchronized audio and video and supports multi-round extension. Its official launch material focuses on story structure, transitions, multimodal references, and post-generation control.

A single request can use up to 30 images, 10 video clips, and 10 audio clips. The model also supports timestamp-level instructions and targeted edits to characters, actions, camera perspective, and green-screen backgrounds.

Start with Seedance 2.5 for:

multi-shot 30-second narratives;
projects with multiple characters and locations;
audiovisual work with several references;
workflows where a local edit is cheaper than regenerating the entire clip.

Reference count is not the same as control. Every asset should have one defined purpose, such as character identity, location, camera movement, or voice.

Calling the models through AIHubMix

The three current model IDs are:

wan3.0-video
minimax-h3
doubao-seedance-2-5-260628

AIHubMix documents an asynchronous video workflow. Enable Async Tasks for the account before submitting jobs.

curl -X POST https://aihubmix.com/ai/v1/videos \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "A controlled product shot with one slow camera orbit",
    "resolution": "720p"
  }'

Save the returned task ID, poll the task endpoint, and download the completed artifact.

curl https://aihubmix.com/ai/v1/tasks/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

curl https://aihubmix.com/ai/v1/tasks/{task_id}/content \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  --output result.mp4

Model-specific parameters may differ. Switching the model value is useful for an initial harness, but validate supported duration, resolution, and reference fields on each live model page before treating the request schema as identical.

Current AIHubMix billing

Prices checked on August 8, 2026:

Model tier	Price	Ten-second reference cost
Wan 3.0 480p	$0.0338/second	$0.3380
Wan 3.0 720p	$0.06768/second	$0.6768
Wan 3.0 1080p	$0.1352/second	$1.3520
MiniMax H3 768p	$0.07744/second	$0.7744
MiniMax H3 2K	$0.12397/second	$1.2397
Seedance 2.5 without video input	$10.85/million tokens	Usage-dependent
Seedance 2.5 with video input	$6.51/million tokens	Usage-dependent

The two Seedance rates are alternative billing paths, not additive charges. The displayed video-input rate being lower is counterintuitive, and the launch-day model page contains some ambiguity between its input-modality labels and video-reference pricing. Confirm the actual metered usage with a small job before estimating production volume.

Do not compare Seedance's per-token number directly with the per-second prices. Normalize after collecting actual task usage.

A repeatable evaluation harness

Use the same three briefs for every model.

Test A: character continuity

Provide one character reference. Require a turn, a hand interaction, and a camera move. Score face identity, wardrobe, hands, motion, and voice over time.

Test B: product fidelity

Provide one product reference. Require a close-up and an orbit. Score silhouette, logo, small text, materials, reflections, and unwanted redesign.

Test C: temporal instruction following

Define three actions and two camera transitions with explicit timing. Score event order, transition quality, subject continuity, and audiovisual sync.

Persist these fields for every task:

{
  "model": "minimax-h3",
  "brief_id": "product-orbit-v1",
  "attempt": 1,
  "duration_seconds": 10,
  "resolution": "2k",
  "latency_seconds": 0,
  "billed_cost_usd": 0,
  "usable": false,
  "repair_minutes": 0,
  "failure_labels": []
}

The key metric is not price per generation. It is:

cost per usable result = total generation cost / number of accepted outputs

Track manual repair time separately. A cheap model that needs repeated generations and post-production can be more expensive than a model with a higher listed rate.

Decision rules

Pick Wan 3.0 when duration, resolution-based cost control, and broad source grounding are the main requirements.
Pick MiniMax H3 when the deliverable is a short 2K commercial shot with native sound, text, or brand details.
Pick Seedance 2.5 when narrative structure, many references, continuation, and targeted editing matter more than a simple request schema.

Since all three models are now on AIHubMix, the safest selection process is an API-level A/B test using the same brief, acceptance criteria, and cost accounting.

References

Capabilities and prices were checked on August 8, 2026. Verify live documentation before production use.

Wan AI 3.0 API Tutorial: Use Alibaba Wan 3.0 on AIHubMix

AIHubMix — Thu, 06 Aug 2026 14:17:00 +0000

Alibaba's Wan AI has moved from teasers to a public beta. Wan 3.0 can generate videos up to 30 seconds in a single run, render more expressive characters, and use references from multiple input types. Better still, developers can already call the model through AIHubMix instead of waiting for a separate Wan API rollout.

This tutorial shows how to generate a Wan 3.0 video with the AIHubMix API, poll the asynchronous job, download the result, estimate the cost, and write prompts that take advantage of the model's longer shot length.

Launch status: Alibaba announced the Wan 3.0 public beta on August 6, 2026. AIHubMix lists the model as wan3.0-video. Features and prices in this guide reflect the launch-day API and may change during the beta.

What Is Wan AI 3.0?

Wan AI is Alibaba's video generation model family. The Wan 3.0 public beta focuses on three improvements:

Native 30-second generation: one request can produce a video up to 30 seconds long.
Reality-grade rendering: Alibaba highlights more expressive characters, stronger reference consistency, and better rendering of digital content.
Omni-Reference: Wan 3.0 can reason over text, images, audio, video, and structured sources such as documents, spreadsheets, slides, PDFs, and webpages.

Alibaba describes these features in the official Wan 3.0 launch thread. The AIHubMix launch announcement confirms that Wan 3.0 is live on its platform with text, image, audio, and video inputs.

Wan 3.0 on AIHubMix at a glance

Item	Value
Model ID	`wan3.0-video`
Endpoint	`https://aihubmix.com/ai/v1/videos`
Maximum duration	Up to 30 seconds
Resolutions	480p, 720p, 1080p
Inputs listed by AIHubMix	Text, image, audio, video
Output	Video
Job type	Asynchronous

The wider Wan 3.0 beta also advertises document and webpage references. At launch, however, the AIHubMix model page explicitly lists text, vision, audio, and video modalities. Check the current documentation before sending document-native inputs through the gateway.

Why Use Alibaba Wan Through AIHubMix?

AIHubMix provides a single API key and a consistent developer workflow across many AI models. For Wan 3.0, the practical advantages are immediate access, an asynchronous task endpoint, and launch pricing below Alibaba's published public-beta rates.

The AIHubMix Wan 3.0 model page currently lists:

IHubMix price
480p:price per second $ 0.04225;
720p: price per second $0.0846;
1080p: price per second $0.169.

Alibaba's launch thread lists $0.05, $0.10, and $0.20 per second for the same resolutions. That makes the launch-day AIHubMix rates about 15.5% lower. Always verify the live model page before estimating production costs.

Prerequisites

You need:

An AIHubMix account and API key.
The Async Tasks feature enabled for your account in the AIHubMix console.
curl for the REST example, or Python 3.9+ for the SDK example.

Store the key in an environment variable instead of placing it in source code:

export AIHUBMIX_API_KEY="your_api_key_here"

Do not commit .env files or API keys to Git.

Generate a Wan 3.0 Video With cURL

Wan 3.0 generation is asynchronous. The workflow has three steps:

Submit a video job.
Poll the returned task ID until the job completes.
Download the generated MP4.

Step 1: Submit the video job

curl -X POST https://aihubmix.com/ai/v1/videos \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "A continuous cinematic tracking shot follows a cyclist through a rain-soaked Tokyo side street at night. Neon signs reflect in the pavement. The camera begins wide, moves alongside the cyclist, then slowly pushes in as steam rises from a food stall. Natural motion, realistic skin and fabric, physically accurate reflections, no cuts.",
    "seconds": "10",
    "size": "720p"
  }'

The response contains a task identifier. Save it as task_id for the next request.

Step 2: Poll the task status

curl https://aihubmix.com/ai/v1/tasks/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

Poll at a reasonable interval, such as every 10 to 15 seconds. Stop when the status becomes completed, failed, or canceled. Aggressive polling does not make generation faster and may trigger rate limits.

Step 3: Download the video

curl https://aihubmix.com/ai/v1/tasks/{task_id}/content \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  --output wan3-result.mp4

Open wan3-result.mp4 locally and review subject consistency, camera motion, unwanted cuts, and visual artifacts before using it in a production workflow.

Use Wan 3.0 With Python

AIHubMix also documents an OpenAI-compatible Python workflow. Install or update the SDK:

pip install -U openai

Create generate_wan_video.py:

import os
import sys
import time

from openai import OpenAI


API_KEY = os.environ.get("AIHUBMIX_API_KEY")
if not API_KEY:
    sys.exit("Set AIHUBMIX_API_KEY before running this script.")

client = OpenAI(
    api_key=API_KEY,
    base_url="https://aihubmix.com/v1",
)

prompt = (
    "A single uninterrupted product shot of a silver smartwatch on black "
    "volcanic stone. Soft morning light moves across the brushed metal. "
    "The camera makes a slow 180-degree orbit while condensation gathers "
    "on the surface. Premium commercial realism, restrained reflections, "
    "stable logo placement, no text overlays, no cuts."
)

video = client.videos.create(
    model="wan3.0-video",
    prompt=prompt,
    seconds="10",
    size="720p",
)

print(f"Created task: {video.id}")

while video.status in ("queued", "in_progress"):
    progress = getattr(video, "progress", 0) or 0
    print(f"Status: {video.status}; progress: {progress}%")
    time.sleep(10)
    video = client.videos.retrieve(video.id)

if video.status != "completed":
    error = getattr(getattr(video, "error", None), "message", "Unknown error")
    sys.exit(f"Generation ended with status {video.status}: {error}")

content = client.videos.download_content(video.id)
content.write_to_file("wan3-result.mp4")
print("Saved wan3-result.mp4")

Run it:

python generate_wan_video.py

For a production service, move polling into a background worker, add exponential backoff, persist the task ID, and make downloads resumable. A web request should not remain open while a 30-second AI video is rendering.

How to Write Better Wan AI Prompts

A good Wan 3.0 prompt reads like a compact shot brief, not a list of style adjectives. Use this order:

Subject + action + setting + lighting + camera movement + shot progression + continuity constraints

1. Describe movement over time

A 30-second clip needs progression. Explain how the action and camera evolve from the opening to the final frame.

Weak:

A cinematic woman in a futuristic city.

Better:

A courier walks through a crowded futuristic market at dawn. Begin with a wide establishing shot, track backward at walking speed as she approaches, then arc to her left when she stops at a glowing map kiosk. Steam crosses the foreground while the crowd continues moving naturally. One continuous take, no cuts.

2. Name a specific camera move

Replace vague words such as "cinematic" with a physical direction:

slow push-in
lateral tracking shot
handheld follow shot
crane down to eye level
180-degree product orbit
locked-off wide shot

Use one main move and one transition. Too many camera instructions often create unstable motion.

3. Protect identity and product details

When using a reference image or video, explain its role:

Use the first reference for the character's face, hair, and clothing. Use the second reference for the cafe interior and color palette. Preserve the same character identity, jacket details, and table layout throughout the shot.

Do not assume the model knows which reference controls the person, location, or product.

4. Use constraints sparingly

Add only constraints that can be checked in the final video:

One continuous take, no scene cuts, stable facial identity, natural hand motion, no text overlays.

Long negative-prompt lists can compete with the main direction. Start with four or five important constraints, generate a short test, and refine from the visible failure.

Three Wan 3.0 Prompt Examples

Cinematic character scene

A tired detective enters a quiet all-night diner during heavy rain. The camera starts outside the window, slowly pushes through the doorway behind him, and follows as he removes his wet coat and sits at the counter. Fluorescent light mixes with red neon from the street. Keep his face, charcoal coat, and age consistent throughout. Subtle natural expression, realistic wet fabric, one continuous take, no cuts.

Ecommerce product video

A white running shoe rests on a wet track before sunrise. Begin with an extreme close-up of water droplets on the mesh, pull back into a low three-quarter view, then make a smooth half-orbit as warm sunlight reaches the sole. Preserve the shoe silhouette, material, color, and logo placement. Premium commercial lighting, physically accurate reflections, no extra text, no cuts.

Social media food clip

A chef plates handmade ramen in a compact open kitchen. Start overhead as noodles enter the bowl, descend to counter height when broth is poured, then track sideways as the chef adds egg and scallions. Warm practical lighting, visible steam, natural hand movement, appetizing realistic texture. One continuous 10-second take, no text overlay.

A Cost-Smart Testing Workflow

Do not begin prompt development with a 30-second 1080p render. Use a staged workflow:

Test composition and motion at 480p for 5 seconds.
Fix identity, hand, camera, and continuity problems.
Validate the final prompt at 720p for 10 seconds.
Render the 30-second 1080p version only after the shot is stable.

At current AIHubMix pricing, a 5-second 480p test costs about $0.21, while a 30-second 1080p render costs $5.07. Iterating at the lowest useful setting can reduce prompt-development cost substantially.

Common API Problems

The request returns an authorization error

Confirm that AIHUBMIX_API_KEY is set in the same shell that runs the command. Also check that the header uses Bearer followed by a space and the key.

The asynchronous endpoint is unavailable

Enable Async Tasks for the account in the AIHubMix console. The video endpoint depends on that account-level feature.

The task stays queued

Longer and higher-resolution videos need more processing time, especially during a public-beta launch. Keep the task ID, poll less frequently, and retry status requests rather than submitting duplicate paid jobs.

The Python client has no `videos` attribute

Update the openai package. Video methods require a recent SDK version:

pip install -U openai

If your environment must stay on an older SDK, use the REST workflow shown earlier.

A long video loses consistency

Reduce competing actions, specify one camera path, state which reference controls each element, and test a shorter version first. A 30-second generation magnifies ambiguity in the prompt.

Wan 3.0 FAQ

Is Wan 3.0 available now?

Yes. Alibaba announced Wan 3.0 as a public beta on August 6, 2026, and AIHubMix made wan3.0-video available the same day.

Is Wan 3.0 an Alibaba model?

Yes. Wan AI is developed by Alibaba's Tongyi Lab. Search terms such as Wan Alibaba, Alibaba Wan, and Wan AI refer to the same model family.

Can Wan 3.0 generate a 30-second video?

Yes. The public beta supports native video generation up to 30 seconds in a single run.

Does AIHubMix support image-to-video with Wan 3.0?

The AIHubMix model page lists vision, audio, and video alongside text as supported input modalities. The launch-day quick start demonstrates text-to-video. Check the latest API documentation for the current upload and reference schema before building a multimodal production pipeline.

How much does the Wan 3.0 API cost?

At publication time, AIHubMix lists $0.04225 per second for 480p, $0.0846 for 720p, and $0.169 for 1080p. A 30-second clip therefore costs approximately $1.27, $2.54, or $5.07, depending on resolution.

Start Building With Wan 3.0

Wan 3.0 changes the useful unit of AI video generation from a short visual beat to a complete 30-second shot. The best way to evaluate it is to start with a tightly directed 5-second test, refine the motion and continuity, and scale only the prompts that hold together.

Use the wan3.0-video model page on AIHubMix to verify current pricing and API availability, then submit your first asynchronous generation with the examples above.

Sources: Alibaba Wan 3.0 public-beta announcement, AIHubMix Wan 3.0 announcement, and AIHubMix Wan 3.0 model details.
``

DEV Community: AIHubMix

DeepSeek V4.1 Flash API Pricing: AIHubMix vs. OpenRouter

Pricing comparison

What makes DeepSeek V4.1 Flash useful?

1M-token context

Native image understanding

Tool calling and structured output

AIHubMix vs. OpenRouter

Quick start with AIHubMix

Best-fit workloads

Takeaway

Why did Gemini turn Chinese for no reason?

Problem statement

A practical model of the behavior

Likely contributing factors

Chinese source material

Conversation history

Token-by-token multilingual generation

Context complexity

What stream does—and does not do

Mitigation checklist

Reproduction and diagnosis limits

Conclusion

Exploring Jev: A Hands-On Look at TypeSafe AI’s New Decision Model

Jev in plain English

The three question types

Why the API shape is useful

Install the LangChain integration

Make the first decision

Explore several decisions in one request

Use case 1: route work to the right model

Use case 2: check tool calls before they run

Use case 3: build a fast first-pass reviewer

What makes the model technically interesting?

A small evaluation plan

What Jev does not do

Final thoughts

Build with Jev on AIHubMix

How I Built an AI Product Ad Pipeline with Claude Code and AIHubMix

Download the Code and Run the Shortest Path

1. Model the Workflow as Explicit State

2. Image Generation Is a Dependency Chain

3. One API Does Not Mean One Request Schema

4. Register a Photorealistic Virtual Person Before Referencing It

5. Do Not Pass Three Asset IDs as One String

6. Recover an Async Task Instead of Creating Another One

7. Give the Prompt Testable Constraints

Reusing the Structure

Amp Reopens BYOK After a Year: Connecting and Configuring AIHubMix

What is Amp good for?

Part 1 — Connect the API

Step 1: Open Personal Settings

Step 2: Add a custom model route

Step 3: Create an API key and set up model name mapping

Step 4: Fill in the connection details

Step 5: Verify the connection

Part 2 — Create a project and a thread

Step 6: Create a project

Step 7: Create a thread

Part 3 — Assign models and start working

Step 8: Assign a model to each role

Step 9: Pick a mode and start the conversation

GLM-5.3-Flash API Pricing: AIHubMix vs OpenRouter, Including the 5.5% Fee

Base API rates

Applying OpenRouter's platform fee

Adding prompt-cache ratios

Reproduce the calculation

Takeaway

GPT-5.6 Sol at 50% Off: AIHubMix vs. OpenRouter Pricing, Fees, and Setup

TL;DR

The advertised token rates are the same

What the 5.5% fee means in practice

Use the discounted AIHubMix model ID

Long context has a different tier

Price is not the only routing decision

Where the discount makes the most sense

Takeaway

GLM-5.3 API Guide: Always-On Thinking, 3 Effort Levels, and the Support Matrix

Specs and migration changes

1. Thinking output across the three APIs

What `stream` does—and does not do

The Python client has no `videos` attribute