How to Use Open-Weight AI Models in November 2026: Kimi K3.1 Pro, Tencent Hy4, and What You Can Really Run, Try, and Build With

The images in this article are AI-generated concept illustrations. They are not photographs of real products, real software screens, or real people.

This guide explains how to use open-weight AI models in a practical way, without hype and without pretending that you can download a frontier model onto an ordinary laptop. In November 2026, two releases made this topic urgent for ordinary users as well as developers. Moonshot AI published the full weights of Kimi K3.1 Pro on Hugging Face on 4 November 2026, and Tencent launched Hy4, its new Hunyuan model, on the same day. Those two events sound similar, but they are not the same kind of release, and the difference decides what you should do first. Kimi K3.1 Pro is a model you can now download in principle, if you have data-centre hardware, and use through chat and an API right away. Hy4, at launch, was a hosted model you could try through Tencent products and API partners, while its weights and system card were promised for the coming days. This guide keeps that distinction clear throughout, because confusing a hosted launch with a downloadable release is the fastest way to waste a weekend, a download quota, and a budget.

1. What Open-Weight Really Means, in Plain English

Open-weight means the trained model files, called weights, are published so that other people can download, inspect, and run them, subject to the licence that comes with them. Think of weights as the learned settings inside a model. A model is trained on vast amounts of data, and the result of that training is a huge set of numbers. When those numbers are published, you are no longer limited to whatever chat window or API a company chooses to offer. You can, in principle, run the model on your own hardware, fine-tune it for a particular task, study how it behaves, or serve it to your own users. That is a real and important freedom, and it is why open-weight releases attract so much attention from developers, researchers, and small teams who do not want to be locked into one provider forever.

Open-weight does not mean small, free in every sense, or easy. The weights may be enormous, the hardware needed to run them may cost more than a house, and the licence may still restrict some commercial uses. It also does not mean that everything about the model is public. The training data, the training code, and the full evaluation setup may remain private. So the right mental picture is this: open-weight gives you the finished engine, not necessarily the factory that built it. You can drive the engine, study it, modify it within the licence, and in some cases rebuild parts of it, but you cannot automatically reproduce the original training run from the weights alone. Keeping that picture in mind will save you from the two most common misunderstandings in this field: that open-weight means you can run anything at home, and that open-weight means there are no rules at all.

2. Open-Weight Is Not the Same as Open-Source

Open-weight and open-source overlap, but they are not synonyms, and using them interchangeably can lead to a costly legal mistake. In software, open-source usually means the source code is available under a recognised open-source licence, with rights to use, study, modify, and share it. A language model is not just code. It is code plus weights plus, often, training data and evaluation data. A release can publish the weights while keeping the training data private, or publish the code for running the model while keeping the weights behind an API. Companies sometimes use the word open-source loosely in announcements, while the actual licence file tells a narrower story. That is why this guide insists on reading the licence file itself, not the press release headline.

Kimi K3.1 Pro is a good example. Moonshot AI describes it on its Hugging Face model card as an open-weight model, and it is released under its own custom licence, the Kimi K3.1 Pro License, rather than a standard licence such as Apache 2.0 or MIT. Reports on that licence describe it as MIT-style, allowing use, modification, and sale, with extra conditions for very large commercial operations. That is still a generous licence for most readers, but it is not the same as saying there are no conditions at all. Tencent Hy4 is a different case again. Tencent described Hy4 in its announcement as joining leading open-source models, and said it plans to release model weights and system cards in the coming days. Until those files actually appear, you cannot check the licence for the full Hy4 model itself, and you should not assume that the terms of an earlier preview automatically apply to the full release. The preview and the full model are different releases, and licences can change between them.

3. What Actually Landed in November 2026

The November 2026 story is two releases on the same day with very different immediate consequences for you. Moonshot AI launched Kimi K3.1 Pro on 23 October 2026 as a hosted model in the Kimi app, Kimi Work, Kimi Code, and the Kimi API, and then published its weights on Hugging Face on 4 November 2026, meeting the date it had promised. Tencent launched Hy4 on 4 November 2026 as its latest Hunyuan model, with visual understanding and computer-use capabilities for the first time in the Hunyuan line, available through Tencent products and API partners, while its weights were promised for the coming days. If you only read headlines, you might think both models became downloadable on 4 November. They did not. Kimi K3.1 Pro did, in the sense that its weights became publicly downloadable. Hy4 became usable through hosted services, with the download still to come.

That distinction shapes the whole guide. The Kimi sections can talk about weights, file size, and serving engines, because those facts exist. The Hy4 sections must talk about hosted trying, API access, and what to check for when the weights arrive, because that is what exists today. Anyone who tells you to download Hy4 and run it locally right now, without noting that the weights were still pending at launch, is either out of date or guessing. Check the model page again before you act, because a promised release can land at any time, and this guide is written from the position on 5 November 2026, when the Hy4 weights had been promised but not yet confirmed as downloadable in the sources reviewed.

Model	What you can do today	Key size and context figures	First step for a normal reader
Kimi K3.1 Pro	Try in chat, use through the API, or download the weights if you have server hardware	2.8 trillion total parameters, 104 billion active per token, 1,048,576-token context	Try it in the Kimi chat app, then try one API call
Tencent Hy4	Try through hosted Tencent products and API partners; weights promised for the coming days	770 billion total parameters, about 49 billion active per token as reported from preview material, context above 1 million tokens	Try it in WorkBuddy, CodeBuddy, Yuanbao, or ima, or through an API partner
A small local model	Download and run on a capable laptop or desktop, fully offline after download	Typically a few billion parameters, a few gigabytes to tens of gigabytes depending on the model and precision	Install a local runner and try one small model

4. Start With One Real Job, Not a Download

Before you install anything or create any account, write down one real job you want the model to do, and how you will know whether it did that job well. A good first job is specific and checkable. Examples include: summarise a ten-page report into five bullet points with page references, turn a rough outline into a first draft of a product description, explain a spreadsheet formula in plain language, or fix a small bug in a short piece of code and explain the fix. A poor first job is vague, such as asking the model to be smart, or uncheckable, such as asking it to write something impressive. Vague jobs produce vague results, and vague results make every model look equally good or equally bad, which teaches you nothing.

Once you have a job, keep the same job for every route you test. Use the same prompt, the same input document, and the same success criteria in chat, through the API, and locally. That discipline turns a casual try into a fair comparison. It also protects you from the most common beginner mistake, which is to test a hosted frontier model on a hard task and a small local model on an easy task, and then conclude that local models are useless or that hosted models are magic. Neither conclusion follows from an unfair test. Keep the job fixed, change only the route, and write down what happened: how long it took, whether the answer was correct, whether you had to correct it, and whether anything private left your machine.

5. Try Kimi K3.1 Pro in Chat First

The fastest honest way to meet Kimi K3.1 Pro is to try it in chat, with no download, no API key, and no hardware decision. Moonshot AI offers Kimi through its chat app and website, as well as through Kimi Work and Kimi Code for deeper work. Start there, because chat is where you learn the model's style, its strengths, and its failure modes, at the lowest possible cost in time and money. You can test whether it follows long instructions, whether it handles images sensibly, whether it stays on task across a long conversation, and whether its answers need checking. Those are exactly the qualities that matter later, when you decide whether to pay for API access or to build anything on top of it.

Pay attention to thinking effort as well. The Hugging Face model card notes that Kimi K3.1 Pro supports reasoning effort settings of low, high, and max, with max as the default, and that its published evaluation results use max effort. That matters for expectations. A chat answer produced at max effort may be slower and longer than you expect, because the model is doing more internal reasoning before it answers. If a chat interface lets you adjust effort or speed, try the same question at a lower effort and compare. For many everyday jobs, a faster, shorter answer is better than a maximally reasoned one, and learning that trade-off in chat will save you API money later. Do not judge the model only on its slowest, most expensive setting, and do not judge it only on its fastest setting either. Judge it on the setting you would actually use.

6. Try Tencent Hy4 Through Its Hosted Apps First

For Hy4, the honest first step in November 2026 is hosted use, because that is the route Tencent actually opened at launch. Tencent said Hy4 is available across Tencent Cloud TokenHub, WorkBuddy, CodeBuddy, Yuanbao, the WeCom assistant Dayuan, and ima, with its API also available through third-party platforms such as OpenRouter, Hermes, and OpenCode. If you already use one of those Tencent products, start there, because you will meet Hy4 inside a workflow you already understand, rather than learning a new tool and a new model at the same time. If you do not use those products, pick the one that matches your job: CodeBuddy for coding, WorkBuddy for office and collaboration work, Yuanbao or ima for general chat and document work, and TokenHub or an API partner if you want to build something.

For your first Hy4 test, choose a visual job that a text-only model could not do fairly. For example, upload a chart from a report you already understand, and ask Hy4 to explain what the chart shows, what trend it supports, and what it does not prove. Then check its answer against the chart yourself. Or give it a screenshot of a simple interface and ask it to describe the steps needed to complete a task in that interface, without letting it actually click anything yet. That kind of test teaches you whether the visual understanding is genuinely useful, or whether it is just describing the obvious. Keep the same discipline as before: same job, same success criteria, and a written note of what went right and what went wrong. If you want the full news background on Hy4, rather than a repeat of it here, read the earlier guide linked in the Sources section, and keep this guide focused on use.

7. Try Hy4 and Kimi Through an API Gateway

An API gateway is a useful middle step between chat and a direct provider API, because it lets you try several models through one account and one billing setup. For Hy4, Tencent named OpenRouter, Hermes, and OpenCode among the third-party platforms carrying its API at launch. For Kimi K3.1 Pro, the direct route is the Kimi API platform, but gateways and other hosts may also carry the model, and their prices and limits can differ from the provider's own prices. A gateway does not change the model itself, but it does change who bills you, what rate limits apply, and what data handling terms apply. Read those terms before you send anything important through a gateway, just as you would before using a provider directly.

Be careful with prices quoted from gateways. Tencent's own announcement gives Hy4 pricing of approximately 0.90 US dollars per million input tokens, 2.70 US dollars per million output tokens, and 0.045 US dollars per million cached input tokens, with the TokenHub discount noted above. Some gateway listings and secondary reports quote slightly different figures, around 0.834 dollars input and 2.501 dollars output, which appear to reflect a gateway or discounted listing rather than Tencent's standard price. Neither figure is wrong in its own context, but they are not interchangeable, and you should budget from the price shown on the exact route you will actually use, on the day you use it. The same caution applies to Kimi pricing, covered in Section 20. Always confirm the live price on the billing page before a large job, because launch discounts, gateway markups, and currency differences can all change the final bill.

8. The Hardware Truth About a 2.8 Trillion Parameter Model

You cannot run Kimi K3.1 Pro on a home PC, and you cannot run the full Hy4 model on a home PC either, and that is not a criticism of your computer. These are data-centre models. Their weights alone are enormous, and running them at a usable speed needs far more memory, far more graphics processing power, and far more supporting infrastructure than any normal desktop or laptop provides. Accepting that fact early is liberating, because it stops you from spending days downloading files you cannot use, and it lets you focus on the routes that actually work: hosted chat, hosted APIs, and small local models that are designed for home hardware.

The Kimi numbers make the point clearly. The Hugging Face model card lists 2.8 trillion total parameters, and secondary coverage of the release reports 96 weight files totalling about 1.56 terabytes, stored in MXFP4 precision after quantization-aware training. That figure is reported, not confirmed from the model card text reviewed for this guide, but it is consistent with the parameter count and the precision, and multiple independent reports give the same total. To put 1.56 terabytes in perspective, it is larger than the entire storage of many laptops, and that is before you add space for the operating system, the serving software, temporary files, and the extra memory needed while the model is actually thinking. Downloading it on a typical home connection would take a very long time, storing it would fill or exceed a normal drive, and loading it into memory would require a cluster of high-end server graphics cards, not a single consumer card.

Reports on the serving recipes for Kimi K3.1 Pro describe multi-GPU setups, including recipes using eight graphics cards at server scale, and coverage of the release mentions roughly eight high-end server graphics cards with several terabytes of combined graphics memory. Treat the exact card count as recipe-dependent, because different serving engines, precisions, and context lengths change the requirement, but do not treat the overall conclusion as uncertain. Whether the recipe needs eight cards or a different multi-card setup, it is not a home setup. The same logic applies to Hy4. A 770-billion-parameter model is smaller than Kimi K3.1 Pro, but it is still far beyond home hardware in its full form. A smaller, distilled, or heavily quantized version of such a model might one day run on powerful workstations, but that future version, if it appears, will be a different artefact with different capabilities, and it should be judged on its own evidence, not on the full model's headlines.

9. Total Parameters, Active Parameters, and Why the Difference Matters

Total parameters tell you how big a model is overall, while active parameters tell you how much of it actually works on each token, and for mixture-of-experts models the gap between those two numbers is the whole story. Both Kimi K3.1 Pro and Hy4 use a mixture-of-experts design. In simple terms, the model contains many specialist sub-models, called experts, and for each piece of text it processes, only a subset of those experts is activated. Kimi K3.1 Pro has 896 experts, with 16 selected per token, plus shared experts, according to its model card. That is why its total is 2.8 trillion parameters, while only 104 billion are active per token. Hy4, as reported from preview material, has 770 billion total parameters with about 49 billion active per token. The active figure is a better guide to the computation needed for each token, while the total figure is a better guide to the storage and memory needed to hold the whole model.

Figure	Kimi K3.1 Pro	Tencent Hy4	What it means for you
Total parameters	2.8 trillion	770 billion	How much you must store and load; drives disk and memory needs
Active parameters per token	104 billion	About 49 billion, as reported	How much computation happens per token; drives speed and cost per token
Context length	1,048,576 tokens	Above 1 million tokens, as reported	How much text and image context the model can consider at once
Home PC verdict	Not runnable at home in full form	Not runnable at home in full form	Use hosted chat or API, and run a small local model instead

10. Quantization in Plain English

Quantization is a way of storing a model's numbers with less precision, so that the model takes less space and runs faster, at some cost to accuracy that is usually small if done carefully. Imagine writing a measurement as 3.14159265, then rounding it to 3.14. You have lost some detail, but for many purposes the rounded value is good enough, and it is much shorter to write and faster to use. Quantization does something similar for model weights. Instead of storing each weight at high precision, it stores a compressed version, often at 4 bits per weight, which is why you will see terms such as 4-bit quantization, MXFP4, or GGUF files when you explore local models. Kimi K3.1 Pro, according to its model card, uses MXFP4 weights with MXFP8 activations, after quantization-aware training, which means the precision reduction was built into the training process rather than applied as an afterthought. That detail matters, because quantization-aware training generally preserves more quality than simply rounding a finished model after the fact.

11. What You Can Actually Run at Home

At home, you can run small and medium local models well, and that is a genuinely useful capability, even though it is not the same as running Kimi K3.1 Pro or full Hy4. A small local model is typically a few billion parameters, quantized to 4 bits, and packaged for a laptop or desktop. It can draft text, summarise your own documents, answer questions about notes you provide, help with simple coding tasks, and act as a learning tool for how models behave. It will not match a frontier hosted model on hard reasoning, long multi-step agent tasks, or specialised professional work, and pretending otherwise will only disappoint you. Its strengths are different: privacy, offline availability, no per-token bill, and full control over when and how it runs.

12. Ollama or LM Studio: Picking Your Local Runner

For most beginners, the choice is between Ollama, which is a clean command-line tool with a local API, and LM Studio, which is a polished graphical app, and either one is a fine first choice. Ollama is free and open-source, runs on Windows, macOS, and Linux, and is designed around simple commands: you pull a model, you run it, and you chat in the terminal. It also exposes a local API, so other applications on your machine can use the same model. LM Studio is a free graphical application that lets you search for models, download them, chat in a window, and switch on a local server so other apps can use the model, without using the terminal at all. If you are comfortable with a terminal, Ollama will feel fast and precise. If you prefer buttons, windows, and visual settings, LM Studio will feel friendlier. Neither choice locks you in, because both ultimately run model files you can move or replace, and you can try both on the same machine.

When you pick a runner, check three practical points before you commit. First, does it support your operating system and hardware, including Apple Silicon Macs, Windows with a graphics card, or Linux, as relevant? Second, does it let you see the exact model tag, file size, and quantization before you download? Third, does it let you run fully offline after the download, if privacy is your reason for going local? Both Ollama and LM Studio meet those tests for normal use, but versions change, and a quick check of the official download page is worth more than any general statement. Use only the official sites for downloads, linked in the Sources section, because model files are large, executable-adjacent downloads, and a fake download site is a real security risk. Never download a model runner from a link in a random video description or forum post without verifying it against the official site.

13. Your First Local Run, Step by Step

Your first local run should take under an hour, use a small model, and end with a written note about what worked, because a small success you understand beats a large download you cannot use. Follow these steps in order, and stop at any step that does not make sense, rather than pushing ahead and hoping the next step fixes it. Step one: check your free disk space and memory, and close unnecessary applications. You need room for the runner, the model, and some working space, and you need memory free for the model to actually run. Step two: download the runner from its official site only, and install it following the official instructions for your operating system. Step three: inside the runner, search the model library for a small model that fits your memory, and read its description, size, and licence before downloading. Step four: download that one model, and wait for the download to finish completely before trying to chat. Step five: run your standard test job from Section 4, with the same prompt you used in chat, and write down the result.

For Ollama, the concrete commands are simple, and they are worth learning even if you later prefer a graphical app. After installing Ollama, you open a terminal and run a pull command for your chosen model, then a run command for the same model, which opens a chat session. A widely documented example uses a small Llama model, and a November 2026 local guide uses a small Gemma model as its example for modest hardware. Use the exact tag shown in the Ollama library on the day you try, because tags change, and a tag that worked last month may now point to a different version. Type a short prompt, read the answer, and exit the chat with the command the app shows you, usually a slash command or a keyboard shortcut. If the answer is very slow, try a smaller model or a shorter prompt before concluding that local models are useless. Speed depends heavily on model size, context length, and hardware, and a small change in any of those can transform the experience.

14. Your First API Run, Step by Step

Your first API run should be a single, cheap, fully understood call, not a full application, because an API is a billing relationship as well as a technical one. Start by choosing the provider route that matches your earlier chat test. For Kimi K3.1 Pro, that is the Kimi API platform, where the model identifier is kimi-k3.1-pro, as given on the Hugging Face model card. For Hy4, it may be Tencent Cloud TokenHub or an API partner, depending on which route you tested in Section 7. Create an account on that route only, read its pricing page, and set a spending limit or alert if the platform offers one. If it does not offer a limit, decide your own hard budget in advance, write it down, and stop when you reach it. A five-dollar test that teaches you the workflow is worth far more than a fifty-dollar accident that teaches you about billing.

Next, create an API key, and treat it like a password. Never paste a key into a public chat, a shared document, a screenshot, or a code repository. Store it in the provider's recommended way, usually an environment variable or a secure secret store, not in the code file itself. Then make one call with your standard test job, using the provider's quickstart example as a template, and changing only the model name, the prompt, and the key. Check that the response arrives, that it answers your test job, and that the usage dashboard shows the tokens and cost you expected. If the cost surprises you, stop and investigate before making more calls. Common surprises include a reasoning model generating many internal tokens before its visible answer, a long context being resent on every turn of a conversation, and a tool-calling loop making repeated calls without you noticing. All three are normal API behaviours, but they must be understood before they scale.

For Kimi K3.1 Pro specifically, note two behaviours documented on its model card. First, it is a thinking model, with reasoning effort settings of low, high, and max, and max as the default. That means your first API call may generate substantial reasoning before it answers, and you should try a lower effort setting for simple jobs to compare cost and speed. Second, for multi-turn conversations and tool calls, the model card says you must pass back the complete assistant message as returned by the API, including reasoning content and tool calls, not just the visible text. If you strip the reasoning content and send only the visible answer back, the next turn may behave inconsistently. That is a detail you would not discover in chat, where the app handles history for you, and it is exactly why a small API test before building an application matters.

15. Using Open Models for Coding Work

For coding work, the most useful open-weight workflow in November 2026 is a hosted frontier model for hard tasks, plus a small local model for quick, private, and repetitive tasks, with every change tested before it is trusted. Kimi K3.1 Pro is explicitly presented as an agentic coding model, and its model card reports a Terminal-Bench 4.0 score of 65.7, as measured with the Claude Code harness, compared with 66.4 for Claude Opus 5.5 and 58.2 for GPT-6 Astra in the same table. Those are Moonshot's own reported figures, with the harness noted on the card, and they should be read as vendor-reported results, not as independent proof. They do suggest, however, that Kimi K3.1 Pro is a serious coding model, not a general chat model with coding added as an afterthought. Hy4, meanwhile, is presented by Tencent as strong for development work, with CodeBuddy as its coding product, and its computer-use capabilities extend coding into operating software and interfaces. Both models are worth testing on real coding jobs, not just on toy examples.

A good coding test has three parts: a real bug or a real feature, a test that proves whether the change works, and a review step where you read the changed code yourself. Start with a small, safe task, such as explaining a function you already understand, writing a test for a function you already trust, or refactoring a short piece of code with no external side effects. Do not start by asking an agent to rewrite a whole project, migrate a database, or change authentication code, because those tasks have irreversible consequences if the model misunderstands a requirement. When the model proposes a change, read the diff, run the tests, and check edge cases yourself. An agent that writes plausible code quickly is useful. An agent that writes plausible code you never review is a liability.

16. Using Open Models in Agent Workflows Without Losing Control

An agent is a model given tools, a goal, and permission to take multiple steps, and the difference between a useful agent and a dangerous one is almost entirely about permission and oversight. Open-weight models are attractive for agents because you can choose the model, control the deployment, and inspect the setup, rather than accepting a closed provider's agent product as a black box. That control is valuable, but it is also a responsibility. An agent that can read files, send messages, run commands, or operate a graphical interface can also read the wrong file, send the wrong message, run the wrong command, or click the wrong button. The model does not know which actions are reversible and which are not, unless you tell it, and even then it can misunderstand. Your job is to design the workflow so that a misunderstanding causes a small, recoverable problem, not a large, irreversible one.

Start agent work with three guardrails, and do not remove them until you have evidence that the agent respects them. First, give the agent a narrow goal in writing, with a clear definition of done, and a list of things it must not do. Second, give it access only to the data and tools it needs for that goal, in a test environment or a copy of your data, not in your live system. Third, require a human checkpoint before any irreversible action, such as sending an email, publishing a post, deleting files, changing settings, or making a payment. If your agent tool does not support checkpoints, create them manually by running the agent in steps, reviewing its proposed actions, and only then allowing it to proceed. That may feel slow at first, but it is far faster than recovering from an automated mistake.

17. Privacy Checks Before You Paste Anything Important

Privacy in AI use is not a single switch. It is a series of decisions about where your data goes, who can see it, how long it is kept, and what it may be used for afterwards. A local model, once downloaded, offers the strongest privacy position for prompts, because the prompt does not need to leave your machine at all. A hosted chat app and a hosted API both send your prompt to a provider, and that provider's terms decide what happens next. Some providers offer data-retention controls, enterprise terms, or zero-retention options for certain plans, while others may retain prompts for safety, abuse prevention, or product improvement, depending on the plan and the region. Do not assume that a free chat tier and a paid API tier have the same data policy. They often do not, and the difference may matter more than the price difference.

Before you paste anything important into a hosted model, ask five questions, and write down the answers. What exactly are you sending: a public document, your own draft, a client's data, or someone else's personal information? Who runs the service, and under which jurisdiction's laws? Does the provider retain your prompts, and for how long? Can your prompts be used to train future models, and can you opt out? And what happens if the service is breached, acquired, or shut down? If you cannot answer those questions from the provider's own documentation, treat the data as sensitive and keep it local, or anonymise it before sending it. Anonymising means removing names, addresses, account numbers, and other identifying details, and replacing them with placeholders, so that even if the prompt is retained, it does not identify a real person or a real business.

18. Safety Checks Before You Automate Anything Important

Safety is the habit of assuming the model can be wrong, and designing your workflow so that a wrong answer causes inconvenience, not harm. That habit matters for every model, open or closed, hosted or local, because all current models hallucinate, misunderstand instructions, and reflect biases in their training data. The Kimi model card itself, in its evaluation tables, shows that even a strong model scores far from perfectly on many benchmarks, and that its scores vary widely by task. A model that scores well on coding may score poorly on a science task, and a model that handles a short document well may lose track in a very long one. Your workflow should expect that variation, not be surprised by it.

Apply a simple safety ladder to every job. Low-stakes jobs, such as brainstorming titles or drafting a social post, can be checked quickly by reading the output once. Medium-stakes jobs, such as summarising a report for a meeting, writing a product description, or drafting an email to a client, should be checked against the source, edited, and approved by a human before use. High-stakes jobs, such as medical, legal, financial, or safety-critical decisions, should not be delegated to a model alone at all. A model can help you gather information, organise notes, or draft a summary for a qualified professional to review, but it cannot replace that professional's judgement, and its output should never be presented as professional advice. This guide gives general information about using AI tools. It is not financial, legal, or medical advice, and no model output should be treated as such without independent verification by a qualified person.

19. Licences and Commercial Use: Read the Actual Text

Before you sell anything built on an open-weight model, read the licence file for that exact model version, and do not rely on a summary, a headline, or another model's licence. This section explains how to do that check, using Kimi K3.1 Pro and Hy4 as examples, but it does not replace legal advice for your specific situation. For Kimi K3.1 Pro, the Hugging Face model card states that the model is released under the Kimi K3.1 Pro License, and it links to that licence text. Secondary coverage describes that licence as MIT-style, permitting use, modification, and sale, with extra conditions for very large commercial operations. One reported condition is that a company offering the model as a hosted service with more than 20 million US dollars in revenue over twelve months must reach a separate agreement with Moonshot AI. Another reported condition concerns very large products, which may need to display the model name. Treat those reported conditions as prompts to read the licence yourself, not as a substitute for reading it, because the exact thresholds, definitions, and obligations are in the licence text, and summaries can omit details that matter for your case.

For Hy4, the licence check is, at the time of writing, incomplete, and that incompleteness is itself important information. Tencent said it plans to release Hy4 weights and system cards in the coming days, but until those files appear, you cannot verify the full model's licence from the model artefact itself. Earlier preview material was reported as Apache 2.0 in some coverage, but that does not prove that the full Hy4 release will carry the same licence, and you should not build a commercial product on an assumed licence. Wait for the weights and licence to appear, read them, and only then decide on commercial use. If you need to start building now, build on the hosted API under its commercial terms, which are a separate agreement from any future weights licence, and keep your hosted work separable from any future self-hosted work, so that a licence change does not force a rebuild.

Check	Question to answer	Where to look	Do not assume
Licence identity	What is the exact licence name and version for this model?	The licence file on the model page	That a preview and a full release share a licence
Commercial use	May you sell a product or service built on it, and under what conditions?	The licence text, plus the provider's commercial terms	That open-weight always means unrestricted commercial use
Attribution	Must you credit the model, and in what form?	The licence text and any model card notice	That no credit is needed because the weights are public
Redistribution	May you share the weights, a fine-tuned version, or a hosted service?	The licence text, especially any service threshold	That downloading implies a right to re-host for others
Data and safety	What data may you send, and what safeguards apply?	The provider's terms and the system card, when available	That a weights licence covers hosted data handling

20. Costs Compared, Plus Your 7-Day Starter Plan

The cheapest route is not always the cheapest outcome, because a free local run that takes all day, a cheap API call that needs five corrections, and an expensive hosted run that gets it right first time have very different total costs. Cost comparison must therefore include time, corrections, and risk, not just the price per token or the price of hardware. Hosted chat is usually the cheapest way to try a model, because many chat apps offer a free tier with limits, and paid chat plans are a flat monthly cost for personal use. API use is pay-as-you-go, which is cheap for occasional jobs and expensive for large, repeated, or reasoning-heavy jobs, especially when a thinking model generates many internal tokens. Local use has no per-token bill, but it has hardware, electricity, storage, and time costs, and it requires a machine capable enough to run the model at a usable speed. The right comparison is total cost for your actual job, measured over a week or a month, not the headline price for a single token.

Route	Typical cost shape	Best for	Watch out for
Hosted chat	Free tier with limits, or a flat monthly plan	Trying, learning, and everyday personal work	Rate limits, data terms, and plan differences by region
Hosted API, Kimi K3.1 Pro	About 2 dollars per million input tokens and 10 dollars per million output tokens, with cached input lower, as reported from Kimi API pricing	Building apps and agent workflows on a frontier model	Reasoning tokens, long contexts resent each turn, and tool loops
Hosted API, Hy4	About 0.90 dollars per million input tokens and 2.70 dollars per million output tokens, as stated by Tencent, before any TokenHub discount	Visual, office, coding, and computer-use work through Tencent routes	Gateway prices may differ, and launch discounts expire
Local small model	No per-token bill, but hardware, electricity, and time costs	Private drafts, offline work, and learning	Hardware limits, download sizes, and lower capability on hard tasks

Now, the 7-day starter plan that ties this guide together. Day one: choose your real test job, write down your success criteria, and try Kimi K3.1 Pro in chat and Hy4 in a hosted app, using the same job in both. Day two: compare those two chat results, note what each model did well and badly, and decide which hosted route, if either, deserves an API test. Day three: make one small API call on your chosen route, check the usage dashboard, and write down the model identifier, settings, tokens, and cost. Day four: install Ollama or LM Studio, download one small local model that fits your machine, and run the same test job locally. Day five: compare hosted, API, and local results on the same job, and decide your division of labour: which jobs stay hosted, which move local, and which need a human checkpoint. Day six: build one tiny, real workflow, such as a local draft summariser or a hosted coding helper with a test step, and use it on a real but low-risk task, with a human review before anything is shared. Day seven: review your notes, your costs, your privacy decisions, and your licence checks, and write a one-page plan for the next month, naming the models, routes, and guardrails you will actually use. If a step fails, do not skip it. Fix it, note the fix, and move on, because a plan built on skipped steps is not a plan.

Common mistakes, collected from across this guide, are worth a final checklist before you start that week. Do not download a giant model before trying it in chat. Do not assume Hy4 weights are downloadable just because Kimi weights are. Do not compare models on different jobs, different settings, or different versions. Do not paste sensitive data into a hosted model before checking its data terms. Do not let an agent act without a checkpoint on irreversible actions. Do not assume a licence from a headline. Do not judge a local model by a task that needs live web access it does not have. And do not publish a model's output, especially one containing numbers, names, or claims about real people or products, without checking it against a trusted source. Avoid those mistakes, and you will already be ahead of most new users, not because you know more about AI, but because you have a workflow that respects what these models are, and what they are not.

Frequently Asked Questions

Can I run Kimi K3.1 Pro on my home computer?

No, not in full form, because its reported weights total about 1.56 terabytes and serving needs server-scale multi-GPU hardware. Use it through chat or its API, and run a small local model at home instead.

Can I download and run Tencent Hy4 today?

Not from the launch position in this guide, because Tencent said Hy4 weights and system cards would follow in the coming days. Try Hy4 through hosted products and API partners, and recheck the official page before downloading.

What is the difference between open-weight and open-source?

Open-weight means the trained model files are published, while open-source usually means source code is available under a recognised licence. A release can be one without fully being the other, so read the exact licence.

Is open-weight the same as free?

No, because hosted use may be billed per token or by subscription, and local use still costs hardware, electricity, storage, and time. Open-weight reduces lock-in; it does not remove all costs.

Which should I try first, Ollama or LM Studio?

Choose Ollama if you are comfortable with a terminal, and LM Studio if you prefer a graphical app. Both run small models locally, and you can try the other later without losing your notes.

How much does a typical API job cost?

It depends on input, output, and reasoning tokens, plus repeated context, so measure your own jobs. A short job costs a fraction of a cent in token terms at the Section 20 prices, while a long agent job can cost many times more.

Is a local model private?

A fully local model keeps prompts on your machine after download, which is a real privacy advantage, but it does not make every output private. Avoid cloud-tagged models if privacy is the point, and check outputs before sharing them.

Can I use an open-weight model in a product I sell?

Possibly, but only under the exact licence for that model version, which you must read before launch. Kimi uses a custom licence, and Hy4's full licence was not verifiable from a weights file at launch.

Why do benchmark scores differ between sources?

Scores differ because harnesses, settings, prompts, and model versions differ, and many scores are vendor-reported. Treat benchmarks as a starting point and trust a test on your own job more than any leaderboard.

What is the safest first agent task?

A small, reversible task in a test environment, with a written goal, limited access, and a human checkpoint before irreversible actions. Never start on live accounts, live data, or your main machine unsupervised.

Sources

Sources are listed so readers can verify key facts themselves; recheck prices, licences, and availability before a large or commercial decision.

• Moonshot AI Kimi K3.1 Pro model card on Hugging Face — total and active parameters, context length, vision encoder, quantization, evaluation table including Terminal-Bench 4.0, recommended engines, and licence name.
• Tencent official Hy4 launch announcement — visual understanding, computer use, hosted availability, pricing, free window, TokenHub discount, and the promised weights and system card.
• Tencent Hy4 full release guide on MyThrift Hub — earlier news coverage of Hy4, linked here instead of repeated in this how-to guide.
• How to use AI agents in 2026 on MyThrift Hub — fuller agent setup background, linked here instead of repeated.
• How to use Gemini file editing on MyThrift Hub — related how-to on a different hosted AI feature, for readers building a broader workflow.
• Kimi chat and apps from Moonshot AI — the hosted route for trying Kimi K3.1 Pro in chat.
• Kimi API platform from Moonshot AI — the direct API route for Kimi K3.1 Pro, using the model identifier kimi-k3.1-pro.
• Ollama official site — local model runner for Windows, macOS, and Linux, with a model library and local API.
• LM Studio official site — graphical local model app for searching, downloading, chatting, and serving local models.
• vLLM serving recipes for Kimi K3.1 Pro — server-scale serving guidance referenced on the model card.
• Report on the Kimi K3.1 Pro weights release — secondary reporting of the 96 files, about 1.56 terabytes total, and multi-GPU serving scale.
• Honest explainer on Tencent Hy4 hosted availability — secondary reporting that Hy4 weights were promised, not yet downloadable, at launch, with hosted routes and free-window dates.

Figures marked reported, not confirmed, include the about 1.56 terabyte Kimi weights total, multi-GPU serving scale, Hy4 active parameters, and Kimi API prices; recheck the live model card and pricing page before downloading or budgeting.

Bottom Line

Try the big models hosted, run small models locally, and let a written test job, a licence check, and a human checkpoint decide what you actually build on.