Thinking Machines' Inkling Explained: Inside Mira Murati's First Open-Weight MoE Model

For eighteen months, Thinking Machines Lab, the startup founded by former OpenAI CTO Mira Murati, said almost nothing in public about what it was building. That changed on July 15, 2026, when the company released Inkling, its first in-house foundation model, as an open-weight download rather than an API-only product [1][2].

That choice matters as much as the model itself. Every other frontier lab in 2026, Anthropic, OpenAI, Google, xAI, ships its best models behind an API. Thinking Machines shipped a 975-billion-parameter Mixture-of-Experts model with full weights on Hugging Face, under an Apache 2.0 license, on day one [3]. This post is a technical walkthrough of what is actually inside Inkling, how its Mixture-of-Experts routing and attention design work, what the real benchmark numbers say next to competing open and closed models, how the smaller Inkling-Small variant was distilled down to roughly a quarter of the size, and how to actually load, fine-tune, and run either one in production.

Step 1: Why Thinking Machines Built an Open-Weight Model At All

Thinking Machines Lab was founded in 2025 by Mira Murati, OpenAI's former chief technology officer, and has grown to roughly 200 employees despite a wave of high-profile departures, including two co-founders who returned to OpenAI earlier in 2026 [2]. The company had already shipped Tinker, a fine-tuning API for customizing open-weight models, before it had a flagship model of its own to point that product at. Inkling is the model that closes that loop.

The strategic argument the company makes is that centrally-trained, one-size-fits-all models leave value on the table compared to AI that organizations can inspect, fine-tune, and shape around their own data [2]. That is not just marketing framing. Microsoft CEO Satya Nadella has separately warned that enterprises leaning entirely on proprietary, closed models effectively pay twice: once in subscription costs, and again by handing a third party the accumulated prompt and usage data that encodes their own business knowledge [2]. An open-weight flagship model that a company can actually run, inspect, and fine-tune on its own infrastructure is a direct answer to that concern, and it is a meaningfully different bet than the closed, effort-tunable API model strategy pursued by Anthropic's Claude Opus 5 and Sonnet 5, covered in our breakdown of the effort toggle that separates those two models.

The timing is notable too. Reports place a $50 billion fundraising round in progress as of last November, which reportedly stalled by January, and the company has stayed guarded about its current funding position since [2]. Shipping a genuinely competitive open-weight flagship, rather than another closed API product, is as much a proof of technical execution to the market as it is a product launch.

The Open-Weight Landscape Inkling Enters

Inkling is not the only major open-weight release of August 2026. DeepSeek shipped the production DeepSeek-V4-Flash-0731 release on July 31, retraining its April preview checkpoint with a substantially improved post-training pipeline aimed at coding, tool use, and agentic tasks, while keeping the same 284B-total, 13B-active architecture, API endpoint, and pricing [4]. Alibaba's Qwen team released Qwen3.8-27B on August 14, a dense 27.78-billion-parameter multimodal model distilled down from the larger Qwen3.8-Max, aimed specifically at running on a single high-end consumer GPU [5]. Meta shipped Muse Spark 1.2 and a companion coding agent, Muse Code, on August 5, scoring 82.9% on Terminal-Bench 2.1 at unchanged API pricing from the prior Muse Spark version [6]. Inkling's 975B-total, 41B-active MoE design sits at the larger end of that field, closer in scale to a frontier closed model than to any of these open competitors, which is itself part of the story: this is the first time an open-weight release has directly targeted frontier-scale capability rather than a smaller, more efficient tier.

Step 2: The Architecture, Layer by Layer

Inkling is a 66-layer decoder-only transformer with a sparse Mixture-of-Experts feed-forward backbone [3]. The headline numbers are 975 billion total parameters with 41 billion active per token [1][3], meaning that for any given forward pass, the model computes with roughly 4% of its total weights, the rest sit idle, selected in or out by a routing mechanism, and that gap between total and active parameters is the entire economic case for MoE architectures at this scale.

Mixture-of-Experts Routing

Each MoE layer contains 256 routed experts, of which 6 are activated per token, plus 2 shared experts that process every token regardless of routing decision [3][7]. The routing itself uses a sigmoid-based gate with what Thinking Machines describes as an auxiliary-loss-free load-balancing bias [3], a detail worth unpacking because it reflects a broader shift in how MoE models are trained.

Earlier generations of MoE models, including the original Switch Transformer line, typically added an auxiliary load-balancing loss term during training: a penalty that discourages the router from sending too many tokens to too few experts, which would otherwise waste capacity and create training instability. The problem with an auxiliary loss is that it directly competes with the primary training objective. Push the load-balancing term too hard and you distort what the router actually learns about which expert genuinely handles a given token best; push it too soft and you get expert collapse, where a handful of experts absorb most of the traffic while the rest sit undertrained. An auxiliary-loss-free approach instead adjusts a bias term added to each expert's routing score directly, based on how overloaded or underloaded that expert has recently been, decoupling load balancing from the gradient signal that shapes what each expert specializes in. The result, if implemented well, is experts that specialize more cleanly around genuine subtask structure in the data rather than partially around an artificial balancing pressure.

The 2 shared experts matter for a related reason. Routed experts are free to specialize narrowly, a coding expert, a multilingual expert, an arithmetic expert, precisely because the shared experts handle whatever general-purpose processing every token needs regardless of its content. Without shared experts, every routed expert would need to relearn that general-purpose baseline redundantly, wasting capacity that could otherwise go toward specialization.

python
/code
# Conceptual sketch of what happens inside one Inkling MoE layer for a single token.
# 256 routed experts exist; only 6 are activated per token, plus 2 shared experts
# that process every token regardless of the routing decision.

def moe_layer_forward(token_hidden_state, routed_experts, shared_experts, router):
    """routed_experts: list of 256 expert feed-forward networks
    shared_experts: list of 2 always-on feed-forward networks
    router: sigmoid-gated scorer with an auxiliary-loss-free load-balancing bias"""
    routing_scores = router.score(token_hidden_state)  # one score per routed expert
    top_6_indices = routing_scores.top_k(k=6).indices

    output = sum(shared_expert(token_hidden_state) for shared_expert in shared_experts)
    for idx in top_6_indices:
        weight = routing_scores[idx]
        output += weight * routed_experts[idx](token_hidden_state)

    # Only 6 of 256 routed experts, plus both shared experts, actually ran.
    # That is the ~41B active out of 975B total parameters in practice.
    return output

If you want to visualize the routing mechanism itself as a short generated clip rather than a static diagram, here is a standalone video generation prompt built around the same sorting-machine metaphor used in the routing image above, written for a Wan-style video model:

A wooden ball-sorting machine on a tabletop, a funnel at the top dropping a stream of small colored balls onto a wide branching set of chutes. Most chutes stay closed and dark, while six chutes near the center light up warmly and open just as a ball approaches, guiding it into a glowing collection bin below, then the chutes close again as the next ball drops. Clean scientific motion-graphics style, precise mechanical motion, soft pastel lighting, no readable text, no logos, no people, smooth steady camera push-in.

Attention: Hybrid Local and Global, Not RoPE

Inkling departs from the now-standard Rotary Position Embedding (RoPE) approach to positional encoding. Instead, it uses what Thinking Machines describes as relative attention, computing per-token, per-head relative features directly rather than rotating query and key vectors by a position-dependent angle [7]. Layered on top of that is a 5:1 ratio of sliding-window attention layers to full global attention layers, with 8 KV heads [1][3].

The practical motivation for this hybrid pattern is straightforward once you consider what a 1-million-token context window costs computationally. Full global attention scales quadratically with sequence length, every token attends to every other token, which becomes prohibitively expensive at a million tokens. Sliding-window attention caps that cost by only letting each token attend to a fixed-size local window, which is far cheaper but loses the ability to directly relate tokens that are very far apart in the sequence. A 5:1 ratio means most layers use the cheap, local form, while every sixth layer uses full global attention, giving the model periodic opportunities to propagate information across the entire context without paying the full quadratic cost at every layer. This is the same general family of technique used by several other million-token-context models shipped in 2026, and it is one of the main reasons Inkling can advertise a 1M token context window at all without an unreasonable inference cost.

Inkling also includes a short convolution (SConv) component, processing the current token together with its preceding W-1 hidden states [7], which functions as a lightweight local feature extractor sitting alongside the attention mechanism rather than replacing it, similar in spirit to the convolutional augmentations used in several 2025 and 2026 hybrid architectures to cheaply capture short-range patterns before the more expensive attention layers process longer-range structure.

Multi-Token Prediction for Faster Inference

Inkling ships with a Multi-Token Prediction (MTP) layer, functioning as a built-in speculative decoding mechanism [7]. Standard autoregressive generation produces exactly one token per forward pass through the full model, which is the main reason large model inference is slow: you pay the full cost of the network for every single token, one at a time. Speculative decoding instead uses a small, cheap draft mechanism to propose several tokens at once, then verifies them against the full model in a single pass, accepting the ones that match what the full model would have generated anyway and only falling back to standard one-token-at-a-time generation when a proposal is rejected. Building an MTP head directly into the base model, rather than pairing a separate draft model alongside it, means the draft mechanism shares representations with the main model by construction, which tends to produce a higher acceptance rate than an external draft model trained independently. If you want the deeper mechanics of why this speeds up inference at all, our explainer on speculative decoding covers the general technique in more depth.

Step 3: Training Data and the Post-Training Pipeline

Inkling was pretrained on 45 trillion tokens spanning text, images, audio, and video [1][3], using a hybrid optimizer that pairs Muon for the large matrix weights with Adam for everything else [3]. Muon, a relatively recent addition to the large-model training toolkit, is specifically designed for the large 2D weight matrices that dominate transformer parameter counts, and using it selectively rather than uniformly across every parameter is a pattern several 2026-era training runs have converged on: apply the specialized optimizer where its geometric properties actually help, and fall back to a well-understood general optimizer everywhere else.

Post-training followed a two-stage structure: synthetic data bootstrapping, followed by large-scale reinforcement learning exceeding 30 million rollouts [3]. Thirty million rollouts is a genuinely large post-training RL run, on the same order of magnitude as the reinforcement learning stages reported by other frontier labs for their reasoning-focused models in 2026, and it is the stage most directly responsible for Inkling's benchmark performance on reasoning and agentic tasks, since pretraining alone teaches a model to predict plausible next tokens, not to reliably solve multi-step problems or use tools correctly.

Controllable Thinking Effort

Inkling exposes seven distinct reasoning effort levels: none, minimal, low, medium, high, xhigh, and max [7]. This is conceptually the same idea as the effort parameter Anthropic introduced with Claude Sonnet 5 and Opus 5, letting a caller trade inference cost for reasoning depth on a per-request basis rather than accepting one fixed behavior, and the fact that two labs building very differently structured models converged on nearly identical effort vocabularies is a signal that this control has become a standard, expected feature of a 2026-era reasoning model rather than a one-off product decision by either company. What is different about Inkling's implementation is the granularity: seven levels instead of five, with a distinct "none" setting that appears to disable extended reasoning entirely for cases where a caller wants the fastest possible response and is willing to accept whatever answer the model produces without deliberation.

Step 4: The Benchmark Numbers

Inkling's official benchmark results, as reported on its model card and technical blog post, span reasoning, agentic tool use, and multimodal understanding [1][7].

A few of these numbers deserve context beyond the raw score.

AIME 2026 at 97.1% is a near-ceiling result on a competition mathematics benchmark that was, only two years earlier, considered a genuinely difficult test for frontier models. That trajectory, from a benchmark being a meaningful differentiator to being nearly saturated within roughly 24 months, has played out repeatedly across math and coding benchmarks in the current generation of models, and it is one reason the field has increasingly shifted toward harder, more adversarial successor benchmarks like SWE-bench Pro rather than the original SWE-bench.

HLE (Humanity's Last Exam), 29.7% text-only and 46.0% with tools, is a more telling number than AIME, precisely because HLE was specifically designed to resist the kind of rapid saturation seen on older benchmarks. Both figures sitting well under 50% on a benchmark engineered to stay hard is a more honest signal of the actual reasoning gap that remains than a 97% score on a benchmark closer to saturation, and the roughly 16-point jump from text-only to with-tools shows how much of Inkling's real-world reasoning capability depends on tool access rather than raw parametric knowledge.

SWE-bench Verified at 77.6% puts Inkling in a competitive range with other 2026-era coding-focused models, though notably behind Claude Opus 5's reported 96% on the same benchmark [8], a reminder that Inkling's value proposition is openness and customizability more than raw best-in-class coding performance.

Terminal-Bench 2.1: matching Nemotron 3 Ultra at roughly a third of the tokens. Thinking Machines' own reporting frames this as a headline efficiency claim rather than a headline capability claim [2]: Inkling reaches comparable terminal-agent performance to Nvidia's Nemotron 3 Ultra while consuming roughly one-third the tokens per task. Token efficiency at equal capability directly translates into inference cost at equal capability, since API and self-hosted inference pricing both scale with tokens processed.

How This Compares to the Rest of the August 2026 Open-Weight Field

Direct apples-to-apples comparisons across labs are limited by what each lab has chosen to publish, and inventing comparison numbers a lab has not released would violate the same sourcing standard applied throughout this post. What can be said with the available published numbers: Meta's Muse Spark 1.2 reports 82.9% on Terminal-Bench 2.1 [6], a benchmark where Inkling's own reporting emphasizes token efficiency at parity with Nemotron 3 Ultra rather than a raw top-line score, making a precise head-to-head comparison on that specific metric imprecise without a shared reporting methodology. DeepSeek-V4-Flash-0731's improvements are reported primarily in relative terms against its own prior V4-Pro-Preview checkpoint rather than as absolute scores directly comparable to Inkling's benchmark suite [4]. The honest summary is that Inkling, Muse Spark 1.2, and DeepSeek-V4-Flash-0731 all represent genuine August 2026 progress on agentic and coding benchmarks from three different labs, without a single shared leaderboard making a precise ranking across all three possible from public information alone.

Step 5: Inkling-Small, and the Distillation Story

Two and a half weeks after the full Inkling release, Thinking Machines shipped Inkling-Small: a 276-billion-parameter multimodal MoE model with 12 billion active parameters, roughly a quarter of the full model's total parameter count [9][10], reported to approach the full model's performance despite the size reduction [9].

The practical reason Inkling-Small exists is hardware access. The full Inkling model needs a minimum of 2TB of aggregated VRAM at BF16 precision, realistically 8x B300/GB200 GPUs or 16x H200 GPUs, or 600GB minimum on an NVFP4 quantized checkpoint across 4x B300-class GPUs [3][7]. That is a genuinely large cluster, out of reach for most individual developers and many smaller organizations. Inkling-Small drops that requirement to 600GB at BF16 on 8x H200s, or as little as 180GB on NVFP4 with a single B300 or two H200s [7], and the model additionally supports 1-bit GGUF quantization through llama.cpp, cutting VRAM consumption by a further 95% for local, consumer-hardware inference [7].

That hardware ladder is the real story behind Inkling-Small: it is not a separately trained smaller model competing on its own terms, it is an accessibility tier for the same underlying model family, letting a solo developer or small team run something meaningfully close to a 975B-parameter frontier model's behavior on hardware two to three orders of magnitude smaller than what the full model needs.

Step 6: Loading, Serving, and Fine-Tuning Inkling

Inkling has native support in the Hugging Face Transformers library [7]:

python
/code
from transformers import AutoModelForMultimodalLM, AutoProcessor

model = AutoModelForMultimodalLM.from_pretrained(
    "thinkingmachines/Inkling",
    torch_dtype="auto",
    device_map="auto",
)
processor = AutoProcessor.from_pretrained("thinkingmachines/Inkling")

inputs = processor(text="Summarize the tradeoffs of MoE routing at inference time.", return_tensors="pt")
output = model.generate(**inputs, max_new_tokens=512, effort="high")
print(processor.decode(output[0], skip_special_tokens=True))

For production serving, vLLM support requires a nightly build with tensor parallelism enabled, since a model this size cannot fit on a single GPU under any realistic configuration [7]:

bash
/code
# Requires a vLLM nightly build with tensor parallelism support for this model size.
# 8x H200 example, NVFP4 checkpoint, minimum ~600GB aggregated VRAM.
vllm serve thinkingmachines/Inkling-NVFP4 \
  --tensor-parallel-size 8 \
  --max-model-len 1048576 \
  --quantization nvfp4 \
  --speculative-config '{"method": "mtp", "num_speculative_tokens": 4}'

SGLang offers a comparable path with a custom implementation supporting 8-GPU sharding [7]. For genuinely local, consumer-hardware inference, the 1-bit GGUF quantized checkpoint runs through llama.cpp, trading some quality for a VRAM footprint small enough for a single high-end consumer GPU.

Fine-Tuning Through Tinker

Thinking Machines' own Tinker platform is the intended fine-tuning path for Inkling, offered at a temporary 50% discount at launch, alongside third-party inference support from Together AI, Fireworks, Modal, and Databricks [7]. Tinker's cookbook and its tml-renderer component specifically handle tool calls, reasoning content, and multimodal inputs during fine-tuning [7], which matters because naively fine-tuning a reasoning model on plain input-output pairs, without preserving the structure of its intermediate reasoning traces and tool-call formatting, tends to degrade exactly the agentic and reasoning capabilities that make a model like this worth fine-tuning in the first place.

python
/code
import tinker

client = tinker.Client(model="thinkingmachines/Inkling-Small")

# The Tinker cookbook and tml-renderer preserve reasoning traces and tool-call
# formatting during fine-tuning, which a generic fine-tuning pipeline will not do.
job = client.fine_tune(
    training_data="gs://your-bucket/agentic-tool-use-examples.jsonl",
    renderer="tml-renderer",
    preserve_reasoning_traces=True,
    effort_default="high",
)
job.wait_until_complete()
print(job.status, job.checkpoint_uri)

An Inkling Playground is also available for free trial access with integrated web search, letting a developer evaluate the model's behavior before committing to either the Tinker fine-tuning cost or the hardware investment required to self-host [7].

Step 7: What Inkling Means for Content and Media Pipelines

Inkling's multimodal input support, text, images up to 4096px, and audio up to 20 minutes at 16kHz [3], positions it as a candidate reasoning layer for pipelines that plan or script multimodal content before handing generation off to a specialized image, video, or music model. That two-stage pattern, a strong reasoning model handling planning and structure, paired with specialized generation models for the actual media, is the same architecture behind creator tools like Text2Shorts in Miraflow AI, where a topic is turned into a script and scene plan before any visual generation happens. A model with Inkling's context window and controllable reasoning effort is well suited to that planning stage specifically, long-context script and storyboard reasoning, handed off to dedicated models for the AI Image Generator, cinematic AI video, or AI Music Generator to actually render the output.

The open-weight nature of Inkling also matters for any pipeline with strict data governance requirements, a use case where sending prompts to a third-party API is a compliance obstacle regardless of model quality. A media company processing sensitive unreleased content through an AI-assisted AI Clipping pipeline, for example, has a materially different risk profile running that reasoning step on infrastructure it controls versus a closed API, independent of which model performs marginally better on a benchmark.

Common Mistakes When Evaluating or Deploying Inkling

• Assuming Inkling-Small is a fully independent smaller model rather than an accessibility tier of the same family. Its value proposition is running near-Inkling behavior on dramatically smaller hardware, not necessarily beating other models purpose-built at the 276B scale.
• Under-provisioning VRAM based on the NVFP4 numbers while planning to run BF16. The 2TB BF16 requirement and the 600GB NVFP4 requirement for the full model are not interchangeable; picking the wrong one during infrastructure planning leads to a cluster that cannot actually load the checkpoint.
• Fine-tuning through a generic pipeline instead of Tinker's cookbook. As noted above, naive fine-tuning that does not preserve reasoning trace and tool-call structure risks degrading the exact agentic capabilities that motivated choosing Inkling over a smaller, simpler model.
• Treating the seven-level effort control as a strict monotonic quality dial. Consistent with what Anthropic's own reporting found for Opus 5's xhigh versus max effort levels, more reasoning is not guaranteed to be strictly better on every task for every reasoning-tunable model, and it is worth benchmarking your own workload rather than assuming max effort is always the right default.
• Comparing Inkling's Terminal-Bench score directly against Muse Spark 1.2's without checking methodology. As covered in Step 4, Thinking Machines' own reporting frames the Terminal-Bench result around token efficiency at parity, not a raw leaderboard score, which is not directly comparable to a flat percentage figure from a different lab's report.

Production Architecture Notes

For teams evaluating a self-hosted Inkling or Inkling-Small deployment, a few practical patterns are worth planning around before committing infrastructure spend.

• Match the checkpoint precision to the actual latency and cost target, not just what fits. NVFP4 quantization roughly triples the VRAM efficiency of BF16, but quantization always carries some quality cost, and that tradeoff should be benchmarked against your own task distribution rather than assumed acceptable by default.
• Budget for tensor parallelism overhead, not just raw VRAM. A model that technically fits across 8 GPUs at the VRAM level still needs inter-GPU communication bandwidth sufficient to keep tensor-parallel inference from becoming network-bound, particularly relevant for the full Inkling model's 8 to 16 GPU serving configurations.
• Use the MTP speculative decoding head by default in production serving. Since it is built into the base checkpoint rather than requiring a separately trained draft model, there is little reason not to enable it, and the token-efficiency gains compound with whatever effort-level routing strategy you build on top.
• Route by modality, not just by task difficulty. A pipeline that only occasionally needs audio or image understanding should confirm those modalities are actually exercised in production before paying for infrastructure sized around Inkling's full multimodal capability on every request.
• Version-pin your Tinker cookbook and tml-renderer alongside your fine-tuned checkpoint. Since both are still actively maintained and updated post-launch, an unpinned fine-tuning pipeline risks silently changing behavior on a re-run months later.

Frequently Asked Questions

Is Inkling actually open source, or just open-weight? Open-weight. The trained model weights are freely downloadable and modifiable under an Apache 2.0 license, but that is distinct from the training code, data, and infrastructure being open, which Thinking Machines has not released.

Can I run Inkling on a single consumer GPU? Not the full 975B model. Even the NVFP4 quantized full checkpoint needs a minimum of 600GB aggregated VRAM. Inkling-Small's 1-bit GGUF quantization through llama.cpp is the realistic path to single-GPU, consumer-hardware inference.

How does Inkling's effort control differ from Claude's? The underlying idea, letting a caller trade inference cost for reasoning depth per request, is the same. Inkling exposes seven levels (none, minimal, low, medium, high, xhigh, max) versus Claude's five (low, medium, high, xhigh, max), with Inkling's "none" and "minimal" tiers offering finer control at the cheap end of the range.

Is Inkling better than Claude Opus 5 or GPT-5.6 at coding? On the specific benchmarks each lab has published, no. Opus 5 reports 96% on SWE-bench Verified against Inkling's 77.6%. Inkling's advantage is openness, customizability, and the ability to self-host and fine-tune on proprietary infrastructure, not raw leaderboard position.

What is the difference between Inkling and Inkling-Small in practice? Inkling-Small is roughly a quarter the total parameter count (276B versus 975B) and about a third the active parameters (12B versus 41B), designed to approach the full model's performance on dramatically smaller hardware, not to be a separately optimized smaller model.

Does Inkling support multimodal input and output? It accepts text, images, and audio as input, but current output is limited to text, code, and structured data. It does not generate images, audio, or video directly.

Conclusion

Inkling is less notable for any single benchmark number than for what it represents structurally: the first genuinely frontier-scale open-weight model from a lab explicitly betting that customizable, self-hostable AI beats a one-size-fits-all API for a meaningful share of real deployments. The Mixture-of-Experts routing, hybrid attention, and built-in speculative decoding are all solid, well-reasoned engineering choices individually, but the combination of frontier scale, full open weights, a purpose-built fine-tuning platform in Tinker, and an accessibility tier in Inkling-Small is the actual product. Whether that bet pays off against Anthropic, OpenAI, Google, and the other open-weight labs shipping in the same window depends less on this one release than on whether Thinking Machines can keep iterating at the pace the rest of the field is currently setting.

References and Sources

[1] Thinking Machines Lab. "Inkling: Our Open-Weights Model."

[2] TechCrunch. "Thinking Machines amps up its bet against one-size-fits-all AI with its first open model, Inkling."

[3] Thinking Machines Lab. "Inkling Model Card."

[4] DeepSeek. "DeepSeek-V4-Flash Goes Official: Agent Benchmarks Beat V4-Pro-Preview."

[5] The Decoder. "Alibaba's Qwen team releases Qwen 3.8 models with open weights under the Apache 2.0 license."

[6] Meta AI Research. "Introducing Muse Code and Muse Spark 1.2."

[7] Hugging Face. "Welcome Inkling by Thinking Machines."

[8] Anthropic. "Introducing Claude Opus 5."

[9] VentureBeat. "Thinking Machines debuts Inkling Small open source AI model nearing performance of predecessor at about 1/4 size."

[10] MarkTechPost. "Thinking Machines Lab Releases Inkling-Small: A 276B Total, 12B Active Open Weights Multimodal MoE Model."