What Is Inkling 2 Small? Open Weights and Apache 2.0

In short: Inkling 2 Small is a Mixture-of-Experts (MoE) model from Thinking Machines Lab with 594 billion total parameters, of which 17 billion are active per token. It takes text and images as input, produces text and does not accept audio. Its weights have been available for download on Hugging Face since November 12, 2026, and according to its model card it is licensed under Apache 2.0. Running the recommended NVFP4 version on your own hardware takes at least 500 GB of total GPU memory.

Thinking Machines Lab announced Inkling 2 Small on November 5, 2026, as the first member of its second model generation. For the first week, the model was available with closed weights and only on Tinker, the company's fine-tuning platform, and the weights reached Hugging Face on November 12. Open weights means the parameters a model learned in training are published as files anyone can download. The Apache 2.0 license lets you run those files on your own servers, adapt them with fine-tuning and distribute them inside a product. So what does that freedom mean for a company? Three things decide it: the terms of the license and of the usage policy that comes with the model, hardware that needs at least 500 GB of GPU memory, and where the data you feed the model is processed.

Inkling 2 Small is a general-purpose AI model that takes text and images and generates text. According to the Inkling 2 Small model card, it is a 48-layer, decoder-only transformer. Its feed-forward layers form a sparse MoE backbone, and each token is routed to 8 of 384 experts. Attention is a hybrid of local and global layers. Images are encoded by a vision transformer and processed together with text in a shared hidden space.

Of the 594 billion total parameters, only 17 billion run for each token. That keeps the compute per token small, but all of the experts' weights still have to sit in GPU memory for the model to run. In an MoE model, compute per token depends on the active parameters and memory depends on the total. That is why Inkling 2 Small's hardware threshold is so high.

Thinking Machines' Inkling family page introduces it as "Our most capable model, and the first of our second generation." The first generation has two models: Inkling, with 975 billion total and 41 billion active parameters, and Inkling-Small, with 276 billion total and 12 billion active. Both are published on Hugging Face under Apache 2.0, in the thinkingmachines/Inkling and thinkingmachines/Inkling-Small repositories, and both take text, images and audio. There is no Inkling 2 model without "Small" in its name yet. In its announcement, the company says Inkling 2 Small is part of a ladder of models and that it looks forward to sharing more rungs soon.

Inkling 2 Small's official language description is English with general multilingual support, and it takes text and images as input. The model card says the model is intended for use in English and other languages, and its languages line reads "English, general multilingual support." The Hugging Face card says "English, with general multilingual capabilities across other languages." None of the official pages names Turkish. The model card recommends that developers evaluate the model's performance, safety and fairness for their own use case, language and population before deployment. For a team working in Turkish, that means testing the model on its own Turkish data.

The model's output is text only. For the best results, the card recommends that each image dimension be between 40 and 4,096 pixels, and according to the announcement, images are processed by a 292-million-parameter vision encoder. Unlike the first-generation Inkling models, Inkling 2 Small does not accept audio. The card gives a context window of up to 1 million tokens, while the versions on Tinker come with 64K and 256K context.

Inkling 2 Small supports variable effort, which means you can set how much the model thinks before it answers. According to the Thinking effort page in the Tinker docs, effort is a number from 0.0 up to, but not including, 1.0. The presets are none (0.0), minimal (0.1), low (0.2), medium (0.7), high (0.9) and xhigh (0.99). When no effort is given, the default is high. The page says 0.0 steers the model toward no reasoning but does not turn reasoning off completely. Thinking Machines ran its own benchmarks at effort 0.99 (xhigh), temperature 1.0 and a limit of 1 million tokens per task.

On the Artificial Analysis Intelligence Index, an independent benchmark, Inkling 2 Small scores 31 and ranks sixth out of 36 models. Thinking Machines' announcement gives the same score of 31, while the benchmark table on the model card lists 30.6 for version 5.0 of the index. Artificial Analysis's own page shows the score and the rank for version 5.0.1.

The announcement is open about the model's limitations too. Inkling 2 Small is easier to use than the earlier Inkling, but it is not the most succinct communicator, and it does not always choose the best tools for the job, especially in codebases with a large number of skills. The model is also less optimized for chat. The company says it has seen issues there such as worse organization and presentation of content, overuse of slashes, and overreaction to mental health and other safety-related queries. The areas the company highlights are agentic coding, vision and knowledge work. If you are planning a chat assistant that talks to customers directly, test these limitations in your own scenarios first.

Yes. Nothing in the Apache 2.0 text restricts commercial use, and the license's patent grant explicitly lists the right to sell the work. Commercial use depends on meeting the license's conditions. On top of that, Thinking Machines' model usage policy prohibits certain uses.

The license is stated in two official places. The model card's license line reads "Apache 2.0," and the card metadata of the Hugging Face repository carries the license: apache-2.0 tag along with a link to the Apache Software Foundation's official text. The repositories have no separate LICENSE file, so the license is defined in the card metadata. In its November 5 announcement, the company had said it intended to release the full weights under an Apache 2.0 license the following week.

Under section 2 of the Apache License 2.0, published by the Apache Software Foundation and approved by the Open Source Initiative, each contributor grants you, subject to the license's terms and conditions, a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license. It covers reproducing the work, preparing derivative works, publicly displaying, publicly performing, sublicensing, and distributing the work and those derivative works in source or object form. Section 3 grants a patent license on the same terms and lists the rights to make, have made, use, offer to sell, sell, import and otherwise transfer the work. If you file a patent lawsuit (including a cross-claim or counterclaim) alleging that the work or a contribution incorporated in it infringes a patent, the patent licenses granted to you under the license for that work terminate as of the date the litigation is filed.

The conditions for redistribution are in section 4. When you pass the work or a derivative on, you must give recipients a copy of the license, mark any files you modified with a prominent notice that you changed them, and keep all copyright, patent, trademark and attribution notices from the original in the source form of the derivative works you distribute. If the work includes a NOTICE file as part of its distribution, the derivative works you distribute must include a readable copy of the attribution notices in that file. Section 6 grants no permission to use the licensor's trade names or trademarks, apart from reasonable and customary use in describing the origin of the work. Section 7 provides the work "AS IS," without warranties or conditions of any kind, express or implied, unless required by applicable law or agreed to in writing. We compare open model licenses in Open-weight model licenses and commercial use.

The weights come with Thinking Machines' Model Acceptable Use Policy, and both the model card and the Hugging Face card link to it. The policy, last updated July 15, 2026, says that by accessing, downloading or using the model weights, parameters, associated materials or any modified version, you agree to be bound by it, unless the company has agreed otherwise in writing. If you use the model through Tinker, Tinker's terms of service apply too, and where the two conflict, the policy controls.

The policy permits use of the model for lawful purposes in line with the policy. It makes you responsible for the compliance of the products you build with the model, including use by others through those products. The prohibitions cover illegal activity, export control and sanctions violations, child exploitation, weapons with mass-casualty potential, attacks on critical infrastructure and malicious code, hate and harassment, collecting information about or surveilling people without authorization, violating third-party rights, and deceptive content. The clause that matters most to companies in banking, insurance and HR prohibits automated (non-human) decisions that affect an individual's rights, including financial, legal, employment, healthcare, housing, insurance or social services decisions. If you deploy the model in a product for end users, you must disclose the model's known material limitations and, where the law requires it or it would be material to them, that users are interacting with an AI system. Because the license and the policy are both published with the model, a company planning to distribute it or build it into a product should read the two together with its legal team.

The recommended NVFP4 version needs at least 500 GB of total GPU memory (VRAM), and according to the model card you can meet that with 2 NVIDIA B300 or 4 NVIDIA H200 GPUs. The update added on November 12 to Thinking Machines' Inkling 2 Small announcement says the weights are now available for download on Hugging Face, and the announcement's Hugging Face button opens this NVFP4 repository, thinkingmachines/Inkling-2-Small. Because the model was trained in NVFP4 from pretraining through post-training, the company recommends this version for all use cases.

The second option is the MXFP8 version in the Inkling-2-Small-MXFP8 repository. It needs at least 800 GB of VRAM, with example configurations of 4 B300 or 8 H200 GPUs. According to the company, MXFP8 gains only a "very marginal" 1 to 2 percentage points over NVFP4 on evals, which it does not consider meaningful in practice. NVFP4 stores the weights as 4-bit floating-point numbers and MXFP8 as 8-bit ones. That is why the memory requirement differs so much between the two. We explain how a model fits into fewer bits and what that does to memory in How a big model fits in fewer bits. Planning GPU capacity and sizing hardware for a model is what RuneLab's GPU Capacity Planning and Hardware Sizing for LLM Inference course covers.

To run the weights on your own GPUs, you need an inference framework. The model card lists SGLang, vLLM, TokenSpeed, Unsloth and Hugging Face, each with its own dependencies. The November 12 update also says the model is integrated with Unsloth, SGLang, vLLM and TokenSpeed. As of November 13, 2026, there is no Inkling model in the Ollama library. Serving a model in production with one of these frameworks, vLLM, is the subject of RuneLab's LLM Serving with vLLM: Production Inference Deployment course.

The 500 GB threshold takes several data-center GPUs, while most companies are looking for an open model that fits their own hardware. For those teams, smaller models are a more realistic starting point. RuneLab's Hati Glint SQL is one example: an open model fine-tuned from Qwen3.5-9B, released under Apache 2.0 like Inkling 2 Small and published on Hugging Face, that turns Turkish questions into SQL and can call tools.

There are two ways to use the model without downloading the weights: Tinker, Thinking Machines' own platform, and the API providers that serve the model. According to the announcement, the model is available on Tinker for fine-tuning and sampling, while Tinker Playground offers inference-only access. The November 12 update and the Hugging Face card say the model can be post-trained with Miles, SkyRL and Snowflake Cortex Training and is available through the API at NVIDIA, Fireworks, Together, Baseten, Nebius, Modal and Cloudflare. Each provider lists its prices on its own page.

Tinker prices are given in dollars per million tokens. As of November 13, 2026, Tinker's Models & Pricing page lists these prices:

Prefill is the processing of input tokens, cached prefill applies to input tokens that hit the prompt cache, sample is generating output tokens, and train is the forward and backward pass in training. According to the page, extended context costs more for training only, and prefill and sampling prices stay the same as for the standard context. The table shows that Inkling 2 Small is cheaper on Tinker than even Inkling-Small, the smaller first-generation model. On Tinker's serverless inference service, which is in beta, Inkling 2 Small is listed at 256K context for $0.30 per million input tokens, $0.03 for cached input and $1.00 for output.

Running Inkling 2 Small on your own hardware makes sense when you want to keep an Apache 2.0 model entirely within your own infrastructure and adapt it as you like. That takes a GPU cluster that meets the 500 GB VRAM threshold of the NVFP4 version. If you do not have such a cluster, 64K or 256K of context is enough for your work, and fine-tuning on Tinker suits you, then Tinker or an API provider is a faster start. For work that needs audio input, Inkling 2 Small does not fit, while the first-generation Inkling and Inkling-Small also take audio.

This choice weighs license terms, dense versus MoE architecture and how well the model fits your work together. RuneLab's Open-Weight LLM Selection, Licensing and Benchmarking for Enterprise Use course covers choosing open-weight models such as Llama, Qwen, Mistral, Gemma and DeepSeek by license terms, the trade-offs between dense and MoE architectures, Turkish performance and tool calling.

The biggest difference is that Inkling 2 Small's weights can be downloaded. As of November 13, 2026, Qwen's official Hugging Face account has no Qwen4 weights, and the family's only available model, Qwen4-Max, is offered as a cloud preview on Alibaba's Token Plan subscription. According to Alibaba Cloud Model Studio's Qwen4-Max-Preview page, the model takes text, images and video and offers a context of 1 million tokens. The preview ends at 7:00 p.m. Istanbul time on November 25, 2026. If you want a model you can run on your own servers, Inkling 2 Small gives you that option today and Qwen4-Max does not. We cover the preview in detail in When is Qwen4 coming out?

Not on its own. Running the weights on your own servers decides where the data is processed, but whether the processing complies with KVKK, Turkey's personal data protection law, depends on which data is processed and on what basis. Using a model that runs in the cloud is not a KVKK breach on its own either.

When you use Inkling 2 Small on Tinker or through an API provider, the text and images you send to the model go to that provider. When you run the weights on your own hardware, that data can stay inside your organization, depending on the architecture you build. Either way, settle two questions with your legal team before a trial: will the text or images going into the model contain personal data, and if so, on what basis will that data be processed? We cover what to check before entering personal data into generative AI tools in our KVKK generative AI guide, and which work goes to the cloud and which stays in-house in Local LLM vs ChatGPT.

For work where data must never leave the organization, the model has to run in-house. RuneLab's RuneBox is on-premise LLM infrastructure installed on the company network. Models, RAG and agent workflows run on a box with NVIDIA GPUs, in a closed network with no external connection needed. Questions, documents and answers do not leave. Because data is processed within the organization's boundaries, it makes your BDDK and KVKK assessments easier. Compliance remains your organization's own assessment.

Inkling 2 Small is an open-weight MoE model from Thinking Machines Lab with 594 billion total and 17 billion active parameters. It takes text and images, generates text and does not accept audio. Its weights have been available for download on Hugging Face under Apache 2.0 since November 12, 2026.

Yes, nothing in the Apache 2.0 text restricts commercial use, and its patent license also lists the right to sell the work. When you redistribute, you must include a copy of the license, mark modified files and keep the copyright, patent, trademark and attribution notices. Thinking Machines' model usage policy, however, prohibits some uses, such as automated decisions that affect people's rights.

The recommended NVFP4 version needs at least 500 GB of total GPU memory, for example 2 NVIDIA B300 or 4 H200 GPUs. The MXFP8 version needs at least 800 GB, for example 4 B300 or 8 H200 GPUs. The model card lists SGLang, vLLM, TokenSpeed, Unsloth and Hugging Face for inference, and as of November 13, 2026, there is no Inkling model in the Ollama library.

As of November 13, 2026, Inkling 2 Small on Tinker costs $0.30 per million tokens for prefill, $0.03 for cached prefill, $1.00 for sampling and $1.50 for training. On the 256K-context version, only the training price rises, to $3.00. The model card gives a context of up to 1 million tokens, and the versions on Tinker come with 64K and 256K context.

The model card describes its languages as English with general multilingual support, and the Hugging Face card mentions general multilingual capabilities across other languages. The official pages do not name Turkish. A team working in Turkish needs to test the model on its own Turkish data.

Not on its own. Running the model in-house decides where the data is processed, while KVKK compliance depends on which data is processed and on what basis. Using a model that runs in the cloud is not a KVKK breach on its own either.

No. According to Thinking Machines' announcement, Inkling 2 Small natively supports image input but does not support audio. If you need audio input, the first-generation Inkling and Inkling-Small take text, images and audio.

Effort is a number from 0.0 up to, but not including, 1.0 that sets how much the model thinks before it answers. The presets in the Tinker docs are none 0.0, minimal 0.1, low 0.2, medium 0.7, high 0.9 and xhigh 0.99, and the default is high. Thinking Machines ran its benchmarks at effort 0.99.

• Thinking Machines Lab, Introducing Inkling 2 Small: the November 5 announcement and the November 12 update, the release of the weights on Hugging Face, the integrated inference frameworks, post-training tools and API providers, Tinker access, the effort and benchmark settings, the Artificial Analysis score, the vision encoder, the ladder of models and the limitations
• Thinking Machines Lab, Inkling 2 Small Model Card: the license, languages, architecture, parameters, inputs, context window, hardware thresholds, inference frameworks, the Artificial Analysis Index v5.0 score and the evaluation recommendation for developers
• Hugging Face, thinkingmachines/Inkling-2-Small: the license metadata, the languages line, the NVFP4 version, post-training tools and API providers
• Hugging Face, thinkingmachines/Inkling-2-Small-MXFP8: the MXFP8 version and its 800 GB threshold
• Thinking Machines Lab, Inkling model family: the family page, the three models' descriptions and parameters
• Hugging Face, thinkingmachines/Inkling and thinkingmachines/Inkling-Small: the license and inputs of the first-generation models
• Apache Software Foundation, Apache License, Version 2.0: sections 2, 3, 4, 6 and 7
• Open Source Initiative, Apache License, Version 2.0 (OSI): OSI's copy of the license text
• Thinking Machines Lab, Model Acceptable Use Policy: the last-updated date, how it binds users, its relation to Tinker's terms, permitted use, the restrictions and the disclosure duty
• Tinker Documentation, Models & Pricing: the Inkling models' prices, extended context and serverless inference
• Tinker Documentation, Thinking effort: the effort range, presets and default
• Artificial Analysis, Inkling 2 Small analysis: the Intelligence Index v5.0.1 score and rank
• Ollama, Library: the models in the Ollama library
• Alibaba Cloud Model Studio, Qwen4-Max-Preview: Qwen4-Max's inputs, context, Token Plan access and preview period
• Hugging Face, Qwen: the open-weight models Qwen has published

• Open-weight model licenses and commercial use
• When is Qwen4 coming out? The Max preview and Token Plan
• Mistral Large 4 open weights: GPU math and license guide
• LLM quantization explained: FP16 to INT4 and VRAM sizing
• How to run an LLM locally: offline AI setup guide
• What is a token in AI? Why Turkish text uses more tokens
• What is an LLM? How large language models work
• KVKK and generative AI guide
• Local LLM vs ChatGPT: how to decide under KVKK
• Courses: Open-Weight LLM Selection, Licensing and Benchmarking, GPU Capacity Planning and Hardware Sizing, LLM Serving with vLLM