Kimi K3 API — Fast, Open AI compatible, No Setup Required, Best pricing, One API for all models | Qubrid AI

Moonshot AI's Kimi K3 dropped on July 16, 2026, and it is the biggest open-weight model ever released - 2.8 trillion parameters, a 1 million token context window, native multimodal reasoning, and benchmark scores that put it in the same conversation as the top closed frontier models. It even took the #1 spot on Frontend Code Arena within days of launch.

At the same time, Hermes Agent from Nous Research has quietly become one of the most loved open-source autonomous AI assistants. It runs in your terminal, connects to Telegram, WhatsApp, and Discord, browses the web, executes shell commands, generates images, and works with any OpenAI-compatible API.

Put the two together and you get something genuinely powerful: a fully autonomous, frontier-class AI agent that lives on your machine and in your chat apps, powered by the strongest open-weight model on the planet.

This guide shows you exactly how to do that using the Qubrid AI Platform - a day-0 Kimi K3 provider with an OpenAI-compatible API & transparent pricing. By the end, you will have:

1. Kimi K3 running through the Qubrid API (with a working Python example, including vision)

2. Hermes Agent installed and connected to Kimi K3 via Qubrid

3. A production-ready agentic setup you can talk to from your terminal or your phone

Total time: about 10 minutes. Let's go.

Why Kimi K3 Is the Model Everyone Is Talking About

Before the setup, a quick reality check on why this specific pairing matters.

Kimi K3 is not an incremental release. Here is what Moonshot AI shipped:

• 2.8 trillion total parameters in a mixture-of-experts architecture with 896 experts (16 active per token) - the largest open-weight model ever published

• 1,048,576 token context window - roughly one million tokens, served flat across the full window

• Native multimodal reasoning - it accepts images directly, no separate vision model needed

• Kimi Delta Attention (KDA) and Attention Residuals - architectural changes Moonshot credits with roughly 2.5x better scaling efficiency over Kimi K2

• Quantization-aware training with MXFP4 weights and MXFP8 activations for broad hardware compatibility

• Open weights scheduled for public release by July 27, 2026

On benchmarks, K3 lands fourth among all frontier models on independent testing - behind only Claude Fable 5 and GPT-5.6 Sol, and ahead of Claude Opus 4.8 on several coding and agentic evaluations. On Artificial Analysis's long-horizon knowledge work evaluation, it reached an Elo of 1547, a jump of over 700 points from Kimi K2.6. It ranked #1 in Frontend Code Arena, beating every closed model on the leaderboard.

The part that matters for agents specifically: K3 was built for long-horizon agentic workflows. It is strong at navigating large repositories, calling tools, debugging, and iterating against logs, tests, and runtime feedback. That is exactly the workload Hermes Agent throws at a model all day.

In short: Kimi K3 is arguably the best open model you can put inside an autonomous agent right now. And with a 1M-token context window, Hermes can keep enormous amounts of conversation history, file contents, and tool output in play without losing the thread.

Why Hermes Agent

Hermes Agent by Nous Research is an open-source autonomous AI assistant that goes far beyond a chat window:

• Runs anywhere - Linux, macOS, WSL2, Termux, and native Windows

• Messaging-native - talk to your agent on Telegram, WhatsApp, Discord, Microsoft Teams, SMS, or email

• Real tools - web search, browser automation, shell execution, image generation, and text-to-speech

• Bring your own model - the full setup wizard supports any OpenAI-compatible endpoint

That last point is the key. Hermes does not lock you into one provider. You point it at a base URL, paste an API key, enter a model string, and it works. Which brings us to Qubrid.

Why Use Qubrid AI as Your Kimi K3 Provider

Qubrid AI offers serverless Kimi K3 inference through a fully OpenAI-compatible API. That means:

• Day-0 access to Kimi K3 - no waitlist, no enterprise sales call

• One base URL for everything: https://platform.qubrid.com/v1

• Drop-in compatibility - if your code works with the OpenAI SDK, it works with Qubrid by changing two lines

• Transparent, pay-as-you-go pricing (see the pricing section below)

• A full serverless model catalog - GLM, Qwen, GPT-OSS, MiniMax, and every released Kimi model, so you can swap models in Hermes without changing providers

• A built-in playground to test Kimi K3 in the browser before writing a single line of code: Try Kimi K3 in the Qubrid Playground

• Inference logs and usage tracking so you always know what your agent is spending

Get started: Create your Qubrid account and generate an API key in under 2 minutes. You can be sending your first Kimi K3 request before your coffee cools down.

Kimi K3 API Pricing on Qubrid

Kimi K3 on Qubrid is priced at the same rate as Moonshot's own API - no markup for the convenience of an OpenAI-compatible endpoint and a unified model catalog:

A few things worth noting about this pricing in an agentic context:

• Cached input at $0.30/M is the sleeper feature for agents. Hermes resends conversation history and system context on every turn. With prompt caching, repeated context costs 10x less than fresh input. Long agent sessions get dramatically cheaper.

• Flat pricing across the full 1M context. Some providers tier pricing up as context grows. Here, a 900K-token request is billed at the same per-token rate as a 9K-token one.

• For perspective: a typical agent turn with 20K input tokens (mostly cached) and 1K output tokens costs well under a cent.

Part 1: Use the Kimi K3 API on Qubrid (Python Quickstart)

Before wiring up Hermes, confirm the API works end to end. You need:

1. An account on the Qubrid AI Platform

2. An API key from the API Keys page (shown once - store it safely)

3. The OpenAI Python SDK: pip install openai

Your first Kimi K3 request (with vision)

Kimi K3 is natively multimodal, so let's make the hello-world example do something impressive - describe an image:

from openai import OpenAI

# Initialize the OpenAI client with the Qubrid base URL
client = OpenAI(
    base_url="https://platform.qubrid.com/v1",
    api_key="QUBRID_API_KEY",
)

response = client.chat.completions.create(
    # Must match the exact model ID from the docs - variations will cause errors.
    model="moonshotai/Kimi-K3",
    messages=[
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What is in this image? Describe the main elements."
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
            }
          }
        ]
      }
    ],
    max_tokens=300,
    temperature=0.7,
    stream=False,
    extra_body={
        "reasoning_effort": "max",
    }
)

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

Three details that trip people up:

1. The model string is case-sensitive: moonshotai/Kimi-K3, exactly. kimi-k3 or moonshotai/kimi-k3 will error.

2. reasoning_effort goes in extra_body when using the OpenAI SDK. Kimi K3 currently supports the max level, which is also the default, with more levels coming.

3. Images go in as image_url content parts - the same format as GPT-4o-style vision calls. You can also pass base64 data URLs for local images.

If that prints a description of the Statue of Liberty, your Qubrid + Kimi K3 pipeline is live. If your existing codebase already uses the OpenAI SDK, migrating to Kimi K3 is literally a two-line change: swap the base_url and the model string.

Text-only and streaming

For a plain chat completion, drop the content array down to a string, and set stream=True for token-by-token streaming:

stream = client.chat.completions.create(
    model="moonshotai/Kimi-K3",
    messages=[{"role": "user", "content": "Explain KDA attention in Kimi K3 in 3 sentences."}],
    max_tokens=500,
    stream=True,
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

That is the entire API surface you need. Now let's give this model a body.

Part 2: Install Hermes Agent and Connect It to Kimi K3

Hermes Agent ships with a one-line installer that handles all dependencies automatically - uv, Python 3.11, Node.js, ripgrep, ffmpeg, and a portable Git Bash on Windows. No admin rights required, and it will not touch your existing Git install.

Step 1: Run the installer

Linux, macOS, WSL2, or Termux:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Windows (native PowerShell):

iex (irm https://hermes-agent.nousresearch.com/install.ps1)

Windows note: if Smart App Control reports that parts of the app were blocked, you may need to review it under Settings → Privacy & security → Windows Security → App & browser control. Evaluate the security implications for your own machine before changing anything.

Step 2: Choose Full setup

When the wizard asks, type 2 for Full setup. This is the mode that lets you bring your own provider and API key - which is exactly what we want.

Step 3: Point Hermes at Qubrid

This is the heart of the integration. Walk through the wizard with these values:

Again: the model string must be exact. Copy moonshotai/Kimi-K3 character for character. If you want to browse other models to run alongside K3, every API model string is listed on Qubrid's Serverless Models docs page.

Step 4: Configure messaging platforms (or skip)

Hermes will offer to connect Telegram, WhatsApp, Discord, Microsoft Teams, SMS, and email. You can configure them now or skip and add them later - Hermes works fully from the CLI in the meantime.

This is where the setup gets fun: connect Telegram and you have Kimi K3, with tools, in your pocket. Send your agent a message from your phone and it can search the web, run commands on your machine, and reply with results.

Step 5: Pick your tools

Accept the default CLI tools (web search and image generation are pre-selected), choose Local browser for browser automation, pick a TTS provider if you want voice (Microsoft Edge TTS is free), and select a search provider.

Step 6: Launch

hermes

Send a test prompt. If the response comes back, you are now talking to Kimi K3 through Qubrid inside a fully autonomous agent. Welcome to the club.

What to Actually Do With Kimi K3 + Hermes

Here is where the 2.8T parameters and 1M context earn their keep. Try these:

1. Repo-scale coding sessions. Point Hermes at a large codebase and ask it to trace a bug across files. K3 was specifically trained for navigating large repositories and iterating against tests and logs, and the 1M context means Hermes can hold a huge slice of your repo in memory at once.

2. A research analyst on Telegram. With web search enabled, message your agent "compare the last 3 funding rounds of X and summarize the terms" from your phone. K3 scored 91.2% on BrowseComp in Moonshot's launch evaluations - it is genuinely good at multi-step web research.

3. Vision-in-the-loop debugging. Send Hermes a screenshot of a broken UI. K3's native multimodal reasoning means it can read the screenshot, reason about the layout, and propose the CSS fix - the same capability you tested in the Python example above.

4. Long-horizon automation. Give Hermes a multi-step task: "check this site daily, extract the pricing table, and message me on Discord if anything changes." K3's agentic benchmark performance (88.3 on Terminal-Bench 2.1, per Moonshot's launch numbers) is exactly this workload.

5. Frontend generation. K3 currently ranks #1 on Frontend Code Arena - ahead of every closed frontier model. Ask Hermes to scaffold a landing page and open it in the local browser to iterate visually.

Cost Control and Monitoring

Agents can rack up tokens fast, so treat observability as part of the setup:

• Review Inference Logs on the Qubrid platform to see full request history and debug misbehaving tool loops

• Check your credit balance before long-running or high-volume agent sessions

• Lean on caching - Hermes conversations naturally reuse context, and cached input on Qubrid is $0.30/M versus $3/M fresh

• Rotate your API key immediately if you suspect exposure - keys are shown once at creation for exactly this reason

Troubleshooting

Model verification fails during Hermes setup. Ninety percent of the time this is the model string. It must be moonshotai/Kimi-K3 - exact case, exact slashes. Also confirm your API key is active and has credits.

Responses error or come back empty in Python. Check that base_url is https://platform.qubrid.com/v1 (with /v1) and that reasoning_effort is passed inside extra_body, not as a top-level argument.

Hermes fails to start on Windows. Smart App Control may still be blocking components - review the Windows step above.

Responses are slow. K3 at max reasoning effort on complex prompts takes time to think - that is the tradeoff for its benchmark scores. For quick conversational replies, reduce max_tokens or use a lighter model from the Qubrid catalog for casual turns and reserve K3 for heavy tasks.

Kimi K3 on Hermes: FAQ

What is the model ID for Kimi K3 on Qubrid? moonshotai/Kimi-K3, used with the base URL https://platform.qubrid.com/v1. The string is case-sensitive.

Is the Qubrid Kimi K3 API OpenAI-compatible? Yes. Any OpenAI SDK, framework, or tool that supports a custom base URL works out of the box - including Hermes Agent, Cursor, Cline, Claude Code, Zed, Open WebUI, and Dify, all of which have dedicated integration guides in the Qubrid docs.

How much does the Kimi K3 API cost? $3 per million input tokens, $15 per million output tokens, and $0.30 per million cached input tokens on Qubrid - flat across the full 1M context window.

Does Kimi K3 support images through the API? Yes. K3 is natively multimodal. Pass images as image_url content parts in the standard OpenAI chat format, as shown in the code example above.

What context window do I get? 1,048,576 tokens - roughly one million. Leave the context length field blank during Hermes setup and it auto-populates.

Do I need a Moonshot AI account? No. A Qubrid account and API key are all you need. Qubrid serves Kimi K3 (and every released Kimi model) directly through its serverless inference platform.

Can I use other models in Hermes alongside Kimi K3? Yes. Re-run setup or edit your Hermes configuration to add more Qubrid models - the full catalog (GLM-5.2, Qwen3-Coder, GPT-OSS 120B, MiniMax, and more) is available through the same endpoint and API key.

Is Hermes Agent free? Yes, Hermes Agent is open source from Nous Research. You only pay for the inference tokens your agent consumes.

Start Building in the Next 10 Minutes

Here is the entire path, condensed:

1. Sign up for Qubrid AI - start with just $5

2. Generate an API key - store it safely, it is shown once

3. Test Kimi K3 in the Playground - zero code, instant results

4. Install Hermes with the one-line installer and plug in https://platform.qubrid.com/v1 + moonshotai/Kimi-K3

5. Say hello to your agent - from the terminal, or from Telegram on your phone

The largest open-weight model ever released, inside one of the best open-source agents ever built, on an API that speaks the format you already use. There has never been a lower-friction way to run a frontier-class autonomous agent.

Get your Qubrid API key and run Kimi K3 now →

Full setup reference: Hermes integration guide in the Qubrid docs. Questions? Join the Qubrid Discord community.