# Qwen4 Max, GLM 5.3, Hunyuan Hy4, MiMo V2.6 Flash and Muse Ember

> Qwen4 Max, GLM 5.3, Hunyuan Hy4, MiMo V2.6 Flash and Muse Ember on FlyMy.AI: chat models of Alibaba, Z.ai, Tencent, Xiaomi and Meta with reasoning levels, function tools, private mode, the OpenAI-compatible API, agent use and pricing.

Qwen4 Max (Alibaba), GLM 5.3 (Z.ai), Hunyuan Hy4 (Tencent), MiMo V2.6 Flash (Xiaomi) and Muse Ember (Meta)
are FlyMy.AI chat models, each with its own endpoint id. Call them with your
FlyMy.AI key, on the same wallet as every other model: through the
OpenAI-compatible API, where they also call your function tools, or through the
native FlyMy.AI API. Each one can also be an agent's model.

They reason by default, as hard as `reasoning_effort` says, and answer in text
only: use the image, video and audio models to create media.

| Model | Maker | Endpoint id | Reads | Context (tokens) | Longest answer (tokens) |
| --- | --- | --- | --- | --- | --- |
| Qwen4 Max | Alibaba | `flymyai/qwen4-max` | Text, images | 1,000,000 | 131,072 |
| GLM 5.3 | Z.ai | `flymyai/glm-5_3` | Text | 1,000,000 | 131,072 |
| Hunyuan Hy4 | Tencent | `flymyai/hy4` | Text, images | 1,048,576 | 65,536 |
| MiMo V2.6 Flash | Xiaomi | `flymyai/mimo-v2_6-flash` | Text, images | 1,000,000 | 131,072 |
| Muse Ember | Meta | `flymyai/muse-ember` | Text, images | 1,048,576 | 524,288 |

The models that read images take them in `messages` as `image_url` parts, on the
OpenAI-compatible API and the FlyMy.AI API alike. Send an image as a base64
`data:` URL: a public URL works only when the model's host can fetch it. Other
content parts, such as video or audio, are not taken.

## Qwen4 Max

Qwen4 Max (Alibaba) is Alibaba's flagship Qwen4 model for agentic coding, tool use and long documents. It reads text and images: `image_url` parts in `messages`.

| | |
| --- | --- |
| Endpoint id | `flymyai/qwen4-max` |
| Model page | https://app.flymy.ai/models/flymyai/qwen4-max |
| OpenAI `base_url` | `https://api.flymy.ai/api/v1/flymyai/qwen4-max/openai/v1` |
| Native route | `POST https://api.flymy.ai/api/v1/flymyai/qwen4-max/predict` |
| `reasoning_effort` | `none`, `low`, `high` or `xhigh`; `high` when you send none |
| Context | 1,000,000 tokens, up to 131,072 per answer |
| Price per 1M tokens | $1.50 input, $0.075 cached input, $4.50 output |
| Agent model id | `qwen4-max` |

```bash
curl https://api.flymy.ai/api/v1/flymyai/qwen4-max/openai/v1/chat/completions \
  -H "Authorization: Bearer $FLYMYAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "qwen4-max", "messages": [{"role": "user", "content": "Write a haiku about rain."}], "reasoning_effort": "low"}'
```

## GLM 5.3

GLM 5.3 (Z.ai) is Z.ai's flagship GLM model for agentic coding and long-horizon tool use. It reads text only.

| | |
| --- | --- |
| Endpoint id | `flymyai/glm-5_3` |
| Model page | https://app.flymy.ai/models/flymyai/glm-5_3 |
| OpenAI `base_url` | `https://api.flymy.ai/api/v1/flymyai/glm-5_3/openai/v1` |
| Native route | `POST https://api.flymy.ai/api/v1/flymyai/glm-5_3/predict` |
| `reasoning_effort` | `low`, `medium`, `high` or `max`; `medium` when you send none |
| Context | 1,000,000 tokens, up to 131,072 per answer |
| Price per 1M tokens | $1.40 input, $0.26 cached input, $4.40 output |
| Agent model id | `glm-5.3` |

```bash
curl https://api.flymy.ai/api/v1/flymyai/glm-5_3/openai/v1/chat/completions \
  -H "Authorization: Bearer $FLYMYAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "glm-5.3", "messages": [{"role": "user", "content": "Write a haiku about rain."}], "reasoning_effort": "low"}'
```

## Hunyuan Hy4

Hunyuan Hy4 (Tencent) is Tencent's Hy4, the release of Hunyuan Hy4 Preview, a reasoning model for agents, coding and long documents. It reads text and images: `image_url` parts in `messages`.

Function tools work through the OpenAI-compatible Chat Completions endpoint; leave `tool_choice` at `auto`, since a named or a `required` one finds no endpoint.

| | |
| --- | --- |
| Endpoint id | `flymyai/hy4` |
| Model page | https://app.flymy.ai/models/flymyai/hy4 |
| OpenAI `base_url` | `https://api.flymy.ai/api/v1/flymyai/hy4/openai/v1` |
| Native route | `POST https://api.flymy.ai/api/v1/flymyai/hy4/predict` |
| `reasoning_effort` | `none`, `low` or `high`; `high` when you send none |
| Context | 1,048,576 tokens, up to 65,536 per answer |
| Price per 1M tokens | $0.834 input, $0.042 cached input, $2.501 output |
| Agent model id | `hy4` |

```bash
curl https://api.flymy.ai/api/v1/flymyai/hy4/openai/v1/chat/completions \
  -H "Authorization: Bearer $FLYMYAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "hy4", "messages": [{"role": "user", "content": "Write a haiku about rain."}], "reasoning_effort": "low"}'
```

## MiMo V2.6 Flash

MiMo V2.6 Flash (Xiaomi) is Xiaomi's fast, low-cost MiMo model for agents and coding. It reads text and images: `image_url` parts in `messages`.

| | |
| --- | --- |
| Endpoint id | `flymyai/mimo-v2_6-flash` |
| Model page | https://app.flymy.ai/models/flymyai/mimo-v2_6-flash |
| OpenAI `base_url` | `https://api.flymy.ai/api/v1/flymyai/mimo-v2_6-flash/openai/v1` |
| Native route | `POST https://api.flymy.ai/api/v1/flymyai/mimo-v2_6-flash/predict` |
| `reasoning_effort` | `none`, `low`, `medium` or `high`; `medium` when you send none |
| Context | 1,000,000 tokens, up to 131,072 per answer |
| Price per 1M tokens | $0.14 input, $0.0028 cached input, $0.28 output |
| Agent model id | `mimo-v2.6-flash` |

```bash
curl https://api.flymy.ai/api/v1/flymyai/mimo-v2_6-flash/openai/v1/chat/completions \
  -H "Authorization: Bearer $FLYMYAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "mimo-v2.6-flash", "messages": [{"role": "user", "content": "Write a haiku about rain."}], "reasoning_effort": "low"}'
```

## Muse Ember

Muse Ember (Meta) is Meta's low-cost Muse model for agents and high-volume tasks. It reads text and images: `image_url` parts in `messages`.

Function tools work through the OpenAI-compatible Chat Completions endpoint; leave `tool_choice` at `auto`, since a named or a `required` one finds no endpoint.

| | |
| --- | --- |
| Endpoint id | `flymyai/muse-ember` |
| Model page | https://app.flymy.ai/models/flymyai/muse-ember |
| OpenAI `base_url` | `https://api.flymy.ai/api/v1/flymyai/muse-ember/openai/v1` |
| Native route | `POST https://api.flymy.ai/api/v1/flymyai/muse-ember/predict` |
| `reasoning_effort` | `low`, `medium`, `high`, `xhigh` or `max`; `medium` when you send none |
| Context | 1,048,576 tokens, up to 524,288 per answer |
| Price per 1M tokens | $0.10 input, $0.004 cached input, $0.50 output |
| Agent model id | `muse-ember` |

```bash
curl https://api.flymy.ai/api/v1/flymyai/muse-ember/openai/v1/chat/completions \
  -H "Authorization: Bearer $FLYMYAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "muse-ember", "messages": [{"role": "user", "content": "Write a haiku about rain."}], "reasoning_effort": "low"}'
```

## OpenAI SDK

```python
import os
from openai import OpenAI

BASE_URLS = {
    "qwen4-max": "https://api.flymy.ai/api/v1/flymyai/qwen4-max/openai/v1",
    "glm-5.3": "https://api.flymy.ai/api/v1/flymyai/glm-5_3/openai/v1",
    "hy4": "https://api.flymy.ai/api/v1/flymyai/hy4/openai/v1",
    "mimo-v2.6-flash": "https://api.flymy.ai/api/v1/flymyai/mimo-v2_6-flash/openai/v1",
    "muse-ember": "https://api.flymy.ai/api/v1/flymyai/muse-ember/openai/v1",
}
MODEL = "qwen4-max"

client = OpenAI(base_url=BASE_URLS[MODEL], api_key=os.environ["FLYMYAI_API_KEY"])

response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {"role": "system", "content": "Answer briefly."},
        {"role": "user", "content": "Write a Python one-liner that reverses a string."},
    ],
    reasoning_effort="low",
    max_tokens=2000,
)

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

The model is selected by the `base_url`; `model` is echoed back. The key is your
FlyMy.AI key as a `Bearer` token.

With `stream=True`, the answer arrives as one content chunk when the model has
finished, followed by a chunk with `finish_reason`, the `usage` chunk and
`data: [DONE]`.

`usage` follows the OpenAI convention: `completion_tokens` includes the
reasoning tokens, itemized in `completion_tokens_details.reasoning_tokens`;
`prompt_tokens_details.cached_tokens` shows the part of the prompt read from
the cache, and `usage.cost` is the price of the call.

## Function tools

```python
client = OpenAI(base_url=BASE_URLS["mimo-v2.6-flash"], api_key=os.environ["FLYMYAI_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]
messages = [{"role": "user", "content": "What's the weather in Paris right now?"}]

first = client.chat.completions.create(
    model="mimo-v2.6-flash", messages=messages, tools=tools
)
call = first.choices[0].message.tool_calls[0]
messages += [
    first.choices[0].message,
    {"role": "tool", "tool_call_id": call.id, "content": '{"temp_c": 14, "sky": "light rain"}'},
]
final = client.chat.completions.create(
    model="mimo-v2.6-flash", messages=messages, tools=tools
)
print(final.choices[0].message.content)
```

Qwen4 Max, GLM 5.3 and MiMo V2.6 Flash take `tool_choice` `auto` (the default), `required` or a
named function. On Hunyuan Hy4 and Muse Ember, leave `tool_choice` at `auto`: a named or
a `required` one finds no endpoint, and the call fails. Send the assistant message
with its `tool_calls` back as it came, then one `tool` message per call. A call
takes up to 128 function `tools`.

## Native API

The native route takes form fields or a JSON body and answers with one
Server-Sent Event carrying the result:

```bash
curl -X POST https://api.flymy.ai/api/v1/flymyai/muse-ember/predict \
  -H "X-API-KEY: $FLYMYAI_API_KEY" -H "Content-Type: application/json" \
  -d '{"prompt": "Write a haiku about rain.", "reasoning_effort": "low"}'
```

`output_data` holds `output` (the answer), `finish_reason`, `model`,
`service_tier`, `stream_details` (`input_tokens`, `output_tokens`,
`cached_tokens`, `reasoning_tokens`), `reasoning` when the model shows it, and
`charge_usd`, the price of the call.

These models do not use `/predict/stream/`. For long jobs, `/predict/async/`
works as for other models, except in private mode.

## Parameters

| Parameter | Values |
| --- | --- |
| `prompt` | One user message |
| `messages` | Chat history in the Chat Completions format (a JSON array in form data); used instead of `prompt`. The parts each model reads are in its section |
| `system_prompt` | Instructions for the whole chat, added unless `messages` already has a system message |
| `reasoning_effort` | One of the model's levels, listed in its section; the model's default when you send none |
| `max_tokens` | Most tokens to generate, reasoning included, from 1 to the model's longest answer (`max_completion_tokens` works too) |
| `private_mode` | `true` keeps the prompt and the answer out of FlyMy.AI storage and logs |

The OpenAI-compatible route also accepts function `tools`, `tool_choice` and
tool-result messages (see [Function tools](#function-tools)).

## Private mode

Send `private_mode: true` - `extra_body={"private_mode": True}` in the OpenAI
SDK, or a form or JSON field on the native route. FlyMy.AI then keeps neither
the prompt nor the answer: the request history shows the call, its token
counts and its price, without the text. Private mode works with synchronous
calls only; an async request with it is refused, because an async request is
replayed from storage.

The host that serves the call keeps its own retention policy.

## From an AI assistant

An assistant connected to FlyMy.AI quotes each of these models with
`get_pricing`, which also returns its OpenAI `base_url`, and asks it with
`run_model` (`endpoint_id: flymyai/qwen4-max`, the same input as `/predict`).
The result is the answer as text, followed by its token counts and `charge_usd`.

## As an agent's model

Choose one of them in the agent model picker, or pass its agent model id as
`model`: on the REST API, or on the Agents MCP to `projects_plan` and
`projects_create` for a new project's agent, or to `update_agent` or
`projects_agent` for an existing agent.

| Model | Agent model id | Reasoning levels | Default |
| --- | --- | --- | --- |
| Qwen4 Max | `qwen4-max` | `low`, `high` and `xhigh` | `high` |
| GLM 5.3 | `glm-5.3` | `low`, `medium` and `high` | `medium` |
| Hunyuan Hy4 | `hy4` | `low` and `high` | `high` |
| MiMo V2.6 Flash | `mimo-v2.6-flash` | `low`, `medium` and `high` | `medium` |
| Muse Ember | `muse-ember` | `low`, `medium` and `high` | `medium` |

These are the levels `list_agent_models` lists for agents, with each model's list
price per 1M tokens; they can differ from the levels of the chat API above. The
agent can call tools and continue after context compression. Each model call is
debited from the agent owner's FlyMy.AI balance as it completes; you do not need
a key from the model's maker.

Gemini 4 Hydrogen (`gemini-4-hydrogen`) can be an agent's model too, with the levels `low`, `medium` and `high` (`medium` by default): see [Claude, GPT and Gemini](https://docs.flymy.ai/guides/claude-gpt-gemini.md#as-an-agents-model).

## Pricing

| Model | Input | Cached input | Output |
| --- | --- | --- | --- |
| Qwen4 Max | $1.50 | $0.075 | $4.50 |
| GLM 5.3 | $1.40 | $0.26 | $4.40 |
| Hunyuan Hy4 | $0.834 | $0.042 | $2.501 |
| MiMo V2.6 Flash | $0.14 | $0.0028 | $0.28 |
| Muse Ember | $0.10 | $0.004 | $0.50 |

Prices are per 1M tokens. Reasoning tokens are billed as output. The price of
every call is in `charge_usd` (native) or `usage.cost` (OpenAI-compatible) and in
your [usage](https://docs.flymy.ai/api/usage.md).

## Errors

| What you see | Meaning |
| --- | --- |
| `422` on the OpenAI route | A parameter is out of range, `service_tier` asks for `priority` (these models have one tier), or `messages` is malformed; the message says which |
| `400 unsupported_parameter` on the OpenAI route | A content part other than text and `image_url`, such as video or audio |
| `500 model_error` on the OpenAI route | On Hunyuan Hy4 and Muse Ember, usually a named or a `required` `tool_choice`: leave it at `auto` |
| HTTP 200 with `status_code: 400` from `/predict/stream/` | Use `/predict` or the OpenAI-compatible route |
| `private mode does not support async requests` | Send the private call synchronously |
| `403 Insufficient funds` | Top up your balance |

## Related guides

- [OpenAI-Compatible API](https://docs.flymy.ai/guides/llm-openai-compat.md)
- [Using LLMs](https://docs.flymy.ai/guides/use-llms.md)
- [Claude, GPT and Gemini](https://docs.flymy.ai/guides/claude-gpt-gemini.md)
- [Kimi K3.1 Pro](https://docs.flymy.ai/guides/kimi-k3-1-pro.md)
- [DeepSeek V4.1 Flash](https://docs.flymy.ai/guides/deepseek-v4-1-flash.md)
