MTPLX 2.13.0 adds Inkling 2 Mini, Thinking Machines Lab's open-weights model for coding, agents and images, in three packs for Macs with 24 GB of memory or more, each with an FP16 build for M1 and M2 Macs. On a MacBook Pro M5 Max, Bare Speed decodes at up to 128.8 tok/s, Optimized Speed at up to 123.8 and Optimized Quality at up to 103.8, and every pack reads images with the model's whole vision tower.
| What you do | 2.12.3 | 2.13.0 |
|---|---|---|
| Run Inkling 2 Mini on a MacBook Pro M5 Max: decode speed | Cannot load the model | Bare Speed up to 128.8 tok/s; Optimized Speed up to 123.8 tok/s; Optimized Quality up to 103.8 tok/s |
| Read a new 4,142-token prompt on Inkling 2 Mini Bare Speed | Cannot load the model | Prefill at 2,830 tok/s, first token in 1.72 s |
| Run Inkling 2 Mini on a 24 GB Mac | Cannot load the model | Bare Speed, with a 24,576-token window |
| Have an agent write a file through a tool call on a Qwen-format pack (#691) | The file lost its last newline, and a JSON file was refused | Every argument arrives exactly as the model wrote it |
| Send a follow-up in Pi on Flash-Next right after a 32,000-token answer | 31,920 tokens read again, 32.9 s to the first text | 78 new tokens read, 0.55 s to the first text |
Decode speed is the fastest recorded figure for each pack, at the model's own sampler: for Bare Speed, a 128-token answer to a 4,142-token prompt already in the prompt cache, recorded through mtplx serve on a 2.13 test build; for Optimized Speed, a 166-token answer in the 2.13 app; for Optimized Quality, the fastest stretch of an answer in the 2.13 app, its first 32 tokens. macOS thermal pressure was nominal for Bare Speed and Optimized Speed, and moderate when Optimized Quality's answer began. Prefill is MTPLX's own server figure on a new 4,142-token prompt, the mean of three runs, and the first token is the slowest of the same three runs. Long sessions on a hot Mac run slower than the peak.
The fastest way to run Inkling 2 Mini on a Mac
MTPLX is the fastest way to run Inkling 2 Mini on a Mac. On the same MacBook Pro M5 Max with a new 4,142-token coding prompt, Inkling 2 Mini Bare Speed on MTPLX shows its first token in 1.69 s against 2.83 s for oMLX and 2.26 s for plain mlx-lm, reads the prompt at 2,466 tok/s against 1,460 and 1,829, and then decodes 1.6 times as fast as oMLX and 2.8 times as fast as plain mlx-lm.
| Engine and pack | First token | Prefill |
|---|---|---|
| MTPLX, Inkling 2 Mini Bare Speed | 1.69 s | 2,466 tok/s |
| MTPLX, Inkling 2 Mini Optimized Speed | 1.73 s | 2,397 tok/s |
| MTPLX, Inkling 2 Mini Optimized Quality | 1.84 s | 2,257 tok/s |
| oMLX with its own draft head, official weights | 2.83 s | 1,460 tok/s |
| plain mlx-lm, official weights, no draft | 2.26 s | 1,829 tok/s |
Measured on one MacBook Pro M5 Max with 128 GB on 22 November 2026, each engine through its own server with a fresh server for each run, the same 4,142-token prompt, temperature 1.0, top-p 1.0, top-k off and reasoning effort medium, three seeds (29, 31 and 37) taken in turn across the engines, every run starting and ending at macOS thermal pressure nominal. First token and prefill (the prompt's tokens over the first-token time) are timed at the client on the new prompt, and the decode ratio compares each engine's mean decode on a second request with that prompt cached; each figure is the mean over the runs (Inkling 2 Mini Optimized Quality: seeds 29 and 31, as the other run did not meet these conditions); Inkling 2 Mini Optimized Speed has no run on that sheet and is shown from one run on the release build. MTPLX 2.13.0. oMLX 0.8.0 (commit a9e23054) with its own draft head, and plain mlx-lm (commit 0c4c9919) with no draft, both on the official thinkingmachines/Inkling-2-Mini weights (revision 6e7c8248) with MLX 0.32.4.
Inkling 2 Mini
- A new model. Inkling 2 Mini is Thinking Machines Lab's open-weights model for coding, agents and images, released on 20 November 2026 under the Apache License 2.0, with 26.4 billion parameters, 3.4 billion of them active for each token, and a context window of up to 1M tokens according to its model card. It reads images natively.
- Three packs. Bare Speed (16.0 GB) keeps the official 4-bit experts and stores the attention, the output head and the embedding in 4 bits, Optimized Speed (17.2 GB) keeps the attention and the output head in 8 bits, and Optimized Quality (20.2 GB) is the official weights unchanged. Every pack carries the model's whole vision tower and its draft head, and needs MTPLX 2.13 or later.
- Three FP16 packs for M1 and M2 Macs. M1 and M2 chips have no native bfloat16, so each pack has an FP16 build that stores its 16-bit weights as float16 and keeps every 4-bit and 8-bit code as in its parent, and the app and
mtplx startpick it for you. All three passed MTPLX's release check (the coding tests, 6 of 6, the screenshot and the tool call) on the code path an M1 or M2 takes, run on an M5 Max. - Which Mac gets which pack. The app's model picker, its first-run screen and
mtplx startread your chip and memory and offer only the packs that fit: Bare Speed from 24 GB on an M3 or later, all three from 32 GB, and the FP16 builds from 32 GB on an M1 or M2 (no pack fits a 16 GB Mac). The context column is the longest conversation MTPLX admits for the first pack on that much memory:
| Your Mac | Inkling 2 Mini pack to use | Also fits | Context |
|---|---|---|---|
| 8 GB, M3, M4 or M5 | None fits. MTPLX recommends Qwen 3.5 4B Optimized Speed. | ||
| 16 GB to 18 GB, M3, M4 or M5 | None fits. MTPLX recommends Bonsai 2 27B Optimized Speed. | ||
| 24 GB, M3, M4 or M5 | Inkling 2 Mini Bare Speed | none | 24,576 tokens |
| 32 GB, M3, M4 or M5 | Inkling 2 Mini Bare Speed | Optimized Speed, Optimized Quality | 163,840 tokens |
| 36 GB, M3, M4 or M5 | Inkling 2 Mini Bare Speed | Optimized Speed, Optimized Quality | 245,760 tokens |
| 48 GB, M3, M4 or M5 | Inkling 2 Mini Bare Speed | Optimized Speed, Optimized Quality | 434,176 tokens |
| 64 GB, M3, M4 or M5 | Inkling 2 Mini Bare Speed | Optimized Speed, Optimized Quality | 749,568 tokens |
| 96 GB to 512 GB, M3, M4 or M5 | Inkling 2 Mini Bare Speed | Optimized Speed, Optimized Quality | 1,048,576 tokens |
| 8 GB, M1 or M2 | None fits. | ||
| 16 GB to 24 GB, M1 or M2 | None fits. MTPLX recommends Qwen 3.5 9B Optimized Speed FP16. | ||
| 32 GB, M1 or M2 | Inkling 2 Mini Bare Speed FP16 | Optimized Speed FP16, Optimized Quality FP16 | 163,840 tokens |
| 64 GB, M1 or M2 | Inkling 2 Mini Bare Speed FP16 | Optimized Speed FP16, Optimized Quality FP16 | 749,568 tokens |
| 96 GB to 192 GB, M1 or M2 | Inkling 2 Mini Bare Speed FP16 | Optimized Speed FP16, Optimized Quality FP16 | 1,048,576 tokens |
- Vision. Every pack reads screenshots, diagrams and photos, and an image turn uses the same prompt cache, fast decode path and memory plan as a text turn. In MTPLX's release check each of the six packs read a screenshot of a failing test, named the test and both counts, and called the tool it was offered.
- The prompt cache in every client. A follow-up turn reads only what is new, in Pi, OpenCode, Hermes and the app's Chat; the table gives the share of prompt tokens served from the cache after the first turn, one session per client on Bare Speed.
The cache in each client the release offers, on Inkling 2 Mini Bare Speed: the share of prompt tokens served from the cache over every request after the first. A new paste or tool result counts as prompt, so no session reaches 100%.
| Client | Session | From the cache |
|---|---|---|
| Pi | one prompt to build a browser game, Pi's thinking at xhigh: 18 turns in one part to a 113,202-token context, with a screenshot and the server restarted 3 times | 99.7% |
| OpenCode | 11 turns with file tools, an image and a 9,919-token tool result; the server restarted halfway | 91.8% |
| OpenCode, M3 and M4 code path | the same OpenCode session, on the code path M3 and M4 Macs take | 91.5% |
| Hermes | 11 turns with file tools; the server restarted halfway | 97.9% |
| The app's Chat | 10 turns with a pasted image and a 9,448-token paste; the app quit and opened again halfway | 89.8% |
After a restart, Pi picked its conversation up from the SSD cache in 1.45 s, Hermes in 0.48 s and the app's Chat in 0.63 s to the first token; OpenCode read its conversation again (see Known issues).
- Its own kernels and draft head. Inkling 2 Mini runs on Metal kernels written for it, and the model's own draft head proposes several tokens that the full model checks in one pass, so the output keeps the model's own distribution at any temperature. When an agent rewrites a file or repeats a patch, MTPLX also proposes up to 24 tokens at once from the prompt: a 315-line file rewrite on Bare Speed ran at 114.9 tok/s against 89.8 with this off.
- Faster prefill on M5 Macs. On an M5 Mac with at least 12 GB of GPU memory to spare beyond the model, a prompt is read 2,048 tokens at a time instead of 512, and prompts of 4,096 tokens and more use a new attention launch on the GPU's tensor units. As on any engine, two correct ways of reading a prompt can lead to differently worded answers.
- M1 to M4 Macs. They take a code path without the M5's tensor units: on an M5 Max forced onto it, Bare Speed generated 106.1 tok/s on a cached conversation and answered a follow-up's first token in 0.06 s, and an M3 or M4 with less memory bandwidth will be slower. Prompts of 4,096 tokens or more now read faster there, in one attention launch on the GPU: in two pairs of runs Bare Speed read a 4,179-token prompt at 812 and 903 tok/s instead of 745 and 813 and a 16,467-token prompt at 801 and 845 instead of 699 and 695, with peak memory flat.
- Its own sampler, and the agents ready to go. The app,
mtplx startandmtplx serverun Inkling 2 Mini at temperature 1.0 over its whole distribution, as its generation settings say, and a client that sends its own sampler keeps it. The app's Pi, OpenCode and Hermes buttons andmtplx start pi,opencodeandhermesopen those clients with its tool-call format and chat template. - Memory. A conversation is kept once, prompt and answer together, instead of beside a second copy, which cost 2.28 GB at the start of a 64K answer on Bare Speed. On a 24 GB Mac a conversation keeps one restore point instead of eight (180 MB each), and a prompt longer than your Mac's window is told to shorten or compact the conversation.
- Every turn resumes from the saved conversation. A follow-up, a tool result, a turn after a server restart, a turn on another branch of the conversation and a conversation resent without its id all read only their new tokens. In a replay of a Pi session, the turns after a 28,000-token and a 35,000-token file write now read 11 tokens each, where they read the whole answer again (65.5 s and 128.9 s to the first token).
- Building and checking the packs yourself.
mtplx forge inklingrebuilds each pack on your Mac from the official weights andmtplx forge fp16makes the M1 and M2 build, both checking the vision tower and the draft head against the official release. A folder named like an Inkling 2 Mini pack is used only when itsmtplx-pack.jsonsays it is that build; otherwise the published pack is downloaded. - A prompt is read even where MTPLX's prefill kernel cannot run. If a Mac cannot build that kernel, MTPLX falls back to MLX's own kernels for that step instead of failing the request.
The app
- The reasoning effort control now reads from low to high on every model, as Inkling 2 Mini's does; the Qwen models used to list theirs from extra high down.
- After your third model load, the app asks once whether everything is working well, with Star on GitHub and File an issue as the answers; whichever you pick, or if you close it, it never asks again, and the app itself sends nothing.
- A new Settings window. It has a sidebar with eight sections, search over every setting and one save bar, and opens from the gear in the top bar, the app menu or Command-comma. The popover beside it is now called Model controls.
- Your decode speed in the menu bar (#692, requested by @ryanwwest). While a request decodes the menu bar shows its speed, and in five pairs of runs with it on and off it cost nothing measurable; Settings > General turns it off.
- Choose where Pi, OpenCode and Hermes open. Each opens in any installed terminal app or, for OpenCode and Hermes, in its own app, set per client in Settings > Clients or with
mtplx config set pi_opens_in Ghostty. mtplx startuses the app's server instead of loading a second copy. With the app running,mtplx start opencodeand the other clients now attach to the server already loaded, where before they loaded the model a second time (an 87 GB Flash-Next pack cannot fit twice on a 128 GB Mac).- The app uses less while it waits. With the Live tab showing and nothing running it now wakes 7 times a second instead of 253, and 4 instead of 273 when minimized.
- Readouts that say what happened. Activity shows how long a turn thought before it answered, a prompt read while the Mac was under thermal pressure is marked, and the memory card shows the memory guard's own limit and the room left.
- Model folders are shared with the command line (#388, #466). The app and
mtplxread the same folders from~/.mtplx/config.toml, and a model on a drive that is not plugged in is never downloaded again: you are asked to plug the drive in. - The fans are left alone when they are not the app's. Stop and Quit no longer reset the fans to automatic in a copy of the app that never set them.
Fixes for the other models
Agents and the server
- Tool-call arguments arrive exactly as the model wrote them (#691, reported with a reproduction script by @robin1333k). Every file an agent wrote through a Qwen-format pack lost its last newline and a JSON file or a file holding only a number was refused; each argument now arrives as generated, and the next turn resumes from the cache.
- The Responses API accepts the Codex desktop app's requests. Every turn it sent to
/v1/responseswas refused with a 400; its reasoning summary setting and its added and namespaced tools are now accepted, and images in Responses input reach the model (#686 by @LivenseAI). - Claude Code's tool search works against the local server. With 820 MCP tools Claude Code's first prompt was 254,636 tokens; where the model's chat template lists one tool per line, the deferred tools now stay out of the prompt until Claude Code loads them.
- Claude Code's session context reaches the model as system context, instead of being folded into your own message.
- Claude Code requests start sooner. A check for a repeated message took 75 to 105 ms before each request reached the GPU, and now takes 2.3 to 3.2 ms.
- A client's limit on its own thinking is honoured.
thinking_budget,reasoning.max_tokensand Anthropic'sthinking.budget_tokenswere accepted and ignored, and the model now closes its reasoning at that budget (MTPLX_THINKING_BUDGET=offturns this off). - Sampling controls a client sends now apply.
logit_bias,min_pandrepetition_penaltynow work on Inkling 2 Mini and on packs served without drafting, and a malformed value is refused with a message naming the field; the Qwen and Gemma drafting lanes still ignore them. - Thinking answers reach the client sooner. The stream no longer holds back the last 32 characters of reasoning. Measured at the client through
mtplx serve, at Nominal: on Qwen 3.8 Flash-Next Optimized Speed a repeated prompt's first token came in 24 ms instead of 117 ms, and an agent's next two turns in 199 and 221 ms instead of 281 and 443 ms (two runs of each version); on Qwen 3.8 27B Optimized Speed, 15 ms instead of 142 ms (three runs). - Cancel works on
/v1/completions(#687 by @SuperMarioYL), and a client that gives up no longer keeps the model busy untilmax_tokens. - The dashboard follows requests that do not stream (#689 by @jvmenen), on chat, messages, responses and completions.
- Hermes and other clients that send no session id keep their session in a short conversation, instead of reading the model's last answer again on every turn until the conversation passed 4,096 tokens.
- Qwen 3.5 and 3.6 keep the round's reasoning through Claude Code's tool steps (#570 by @jvmenen), and the end-of-turn save is no longer refused.
mtplx start webuiworks, as the app's Web UI row does.
Prompt cache and memory
- A follow-up after a long answer resumes from that answer. The next Pi turn on Flash-Next used to read the whole answer again when the server's guess of how the client would send it back disagreed (31,920 tokens and 32.9 s to the first text on 2.12.3); the state that wrote the answer is now kept. Keeping that state uses more memory inside the same cache budget (in a test of four conversations Qwen 3.8 27B Optimized Speed peaked at 29.55 GB of model memory instead of 27.75 GB, and Qwen 3.8 Flash-Next at 90.5 GB in both versions), and the cache frees it, idle conversations first, before it would refuse a request.
- An explicit RAM session cache size no longer throws the conversation away (#690, reported with an analysis and a patch by @robin1333k). With the cache set below one conversation's size, each save was dropped as soon as it was stored; it now drops its oldest restore points until it fits, and the next turn restores 11,012 of 11,040 tokens.
- A failed save no longer fails a finished answer (#696, reported by @menega). With a small session budget, 8 of 123 requests ended in a stream error after the whole answer had arrived; the answer now ends normally and the error goes to the request log.
- Less work at the end of each answer. Saving after a 42,626-token answer went from about 200 ms to about 4 ms, and on Flash-Next a saved turn is no longer re-rendered and re-encoded (0.12 to 0.29 s at 101,000 to 157,000 tokens).
- A new session resumes at the end of the system prompt it shares with earlier sessions, on models with recurrent layers such as Flash-Next, instead of at 4,096 tokens (
MTPLX_SYSTEM_PROMPT_CHECKPOINT=0turns this off). - After a cancelled answer the next message resumes from memory, instead of from the SSD cache (1.83 s to the first text at 118,096 tokens in Pi, about 0.5 s now).
- A short prompt sent again is served from the cache on models that save a restore point at the end of each prompt.
- Qwen 3.5 and 3.6 follow-ups read less with thinking on. A follow-up that arrived while MTPLX was reading the history in the background now waits for that work, where it read 12,245 and 19,832 tokens again in a Pi session on Qwen 3.6 35B-A3B.
- Follow-ups continue in the conversation's own cache on every client, not only from the app's agent buttons.
- Flash-Next's first long prompt after a start is priced right. The memory guard billed it as a second copy of its state (6.28 GB too much at 193,533 tokens), so a cold 247,048-token prompt that fits was refused.
- A conversation restored from the SSD cache is held once. A follow-up restored after a 247,034-token Flash-Next answer grew 16.1 GB for an 8.66 GB conversation and ended in a 507, and rebuilding the conversation now peaks at 1.03 times its size instead of 1.79 in tests.
- Memory held after a long read is given back at the answer's first round, instead of 1,024 tokens in (6.25 to 6.73 GB for about 18 s after a 118,096-token restore).
- The model stays in GPU memory while the SSD cache writes, so a request that arrives during the write no longer waits 0.75 to 1.0 s for Flash-Next's weights to come back.
- The SSD cache writer lets go of what it wrote. It kept a whole conversation's encoded bytes in memory after each write, 2.2 GB after a 16,000-token turn on Inkling 2 Mini.
Other models
- Qwen 3.6 35B-A3B reads images at their positions in the picture instead of by their order in the prompt; conversations with images saved before the update read their prompt once.
- Qwen 3.6 35B-A3B Optimized Speed and Optimized Balance draft better. One norm in their draft head was stored without its +1, and MTPLX now repairs it when the pack loads: tokens written per round went from 2.63 to 3.54 in a 2,048-token test answer, and the output's distribution is the model's own either way.
- A seed gives the same answer again on Qwen 3.6 35B-A3B. Its default lane drew from a generator seeded by the clock and now draws from the request's seed; which answer a given seed gives differs from 2.12.3.
- A Mac newer than the M5 takes the M5's paths (#695, reported by @audenvenn), where an M6 was treated as an unknown chip.
- The kernel self-check names an unsupported weight layout in one line (#677, reported by @energypantry), instead of four "qmm_m4 raised" lines on an MXFP8 pack.
Pack tools and dependencies
mtplx forge censusandmtplx forge day-zero. The first lists every reason a new checkpoint cannot be built yet, and the second runs a release day from a repository to packs one resumable step at a time.- A quality tool for packs.
mtplx.benchmarks.qualitymeasures what a pack costs against the full-precision model: 20 checkable tasks, the divergence from the reference and the draft acceptance. - Publishing a pack keeps its tokenizer intact.
mtplx forge publishtreated any text starting with~as a home folder and rewrote seven tokenizer entries in Inkling 2 Mini; only~/...and~user/...count now. mtplx forge verifystamps the fastest verified draft depth and a served id on packs built on your Mac (#575 by @jvmenen).- Pillow 13 on every install channel, since every Inkling 2 Mini check ran on it and it changes the pixels of an image the vision tower's grid enlarges. transformers is allowed up to 5.22 (#684), and the wheel carries MTPLX's native engine, built against MLX 0.32.2.
Experimental, off by default
These are built and tested, and stay off until what each one changes is accepted.
- Drafts from a smaller vocabulary (
MTPLX_INKLING_DRAFT_TABLE=<ranking.json>), which changes which tokens a given seed produces. - Copy rounds of 9 to 32 tokens decided on the GPU (
MTPLX_INKLING_WIDE_DECISION=1), the same kind of change. - A cost gate for copy rounds (
MTPLX_CONTEXT_COPY_GATE=1), which cost 3.4% in a replay of a long Pi session. - A reordered long-history attention for decode (
MTPLX_INKLING_ATTEND_C=1), which changes the rounding slightly and costs 2.2 ms a step at 64,000 tokens. - The round that writes its own kept tokens (
MTPLX_INKLING_ROUND_COMMIT=1), which was not faster in a served A/B. - Width-independent prefill (
MTPLX_INKLING_PROMPT_FAST=invariant), which has no comparison with an exact reference yet.
Known issues
- No Inkling 2 Mini pack fits a 16 GB Mac on any chip (Bare Speed's weights alone are 16.0 GB), and M1 and M2 Macs get one from 32 GB.
- On a 16 GB Mac with other apps open, the recommended pack can refuse turns with "insufficient memory" until you close some apps; this is as in 2.12.3, and the fix is planned for 2.13.1.
- On a 32 GB Mac, Qwen 3.8 27B Optimized Speed gets an 8,192-token window while Bonsai 2 27B gets far more; this is as in 2.12.3, and the fix is planned for 2.13.1.
- The FP16 builds have not run on an M1 or M2 Mac yet: all three passed their checks on the code path an M1 or M2 takes, on an M5 Max, and no speed is listed for them.
- On a 24 GB Mac the window is 24,576 tokens and each conversation keeps one restore point, so a prompt that changes before its last 64 tokens (an edited earlier message, a regenerated reply) is restored from the SSD cache or read again.
- In Pi, the first turn after
/newon Inkling 2 Mini reads much of Pi's system prompt again: 2,334 and 8,422 of about 10,500 tokens in two tries, 2.8 s and 7.7 s before the first token. - A tool call reaches the client only once the model has finished writing it, so an agent writing a large file shows nothing until the file is complete, as in earlier releases and on the Qwen packs.
- After the server restarts, OpenCode's next turn reads its whole conversation again (12.8 s to the first token for 22,070 tokens on Bare Speed, 37.7 s on the code path M3 and M4 Macs take), while Pi, Hermes and the app's Chat pick theirs up from the SSD cache in about a second.
- If the server restarts while an agent is in a tool loop, the next turn can read the whole conversation again, because the conversation reaches the SSD cache only when the session pauses (78,836 tokens took 40.4 s in a Pi session on Inkling 2 Mini), as in earlier releases.
- A conversation the server switched away from with no five-second pause may be missing from the SSD cache after a restart, so its next turn reads the whole conversation again (about 8 s for 10,642 tokens on Inkling 2 Mini).
- The visible answer after a model's reasoning starts two to three rounds after its first token, because the server holds the answer's last 32 characters until it knows they are not the start of a tool call.
- A short follow-up on Inkling 2 Mini spends about 0.1 s before its first token whatever its length (11 new tokens took 117 ms in a Pi session).
- With an explicit RAM session cache size, a conversation whose saved state alone is larger than the whole cache is still dropped from memory until its SSD copy is written (past about 28,600 tokens at 2 GB on Qwen 3.6 27B).
- On Flash-Next Optimized Speed the server process uses about 1.5 GB more memory than in 2.12.3 (97.6 to 98.0 GB against 96.2 to 96.3 GB at its peak in a test of four conversations); the model's own memory is unchanged, and the cause is being traced.
- When MTPLX refuses a streamed request for memory, the client shows a server error instead of the refusal, because the stream has already started; the fix is planned for 2.13.1.
- The app's reasoning effort control offers low, medium, high and extra high for Inkling 2 Mini; its other levels (none, minimal and max) work when a client sends them, as Pi and OpenCode do, but cannot yet be the default in the app or with
mtplx serve --reasoning-effort. - The known issues of 2.12.3 still apply: see the 2.12.3 release notes.
Upgrading
Run brew upgrade mtplx or pip install -U mtplx, or use the app's update check; no setting needs to change. To try Inkling 2 Mini, pick it in the app, or run mtplx start pi --model Youssofal/Inkling-2-Mini-MTPLX-Bare-Speed (on an M1 or M2, Youssofal/Inkling-2-Mini-MTPLX-Bare-Speed-FP16). Inkling 2 Mini packs do not load in MTPLX 2.12 or earlier.
Credits
- Faster session-cache lookups (#628, #629), the reasoning kept through Claude Code's tool steps (#570), the verified draft depth stamped by Forge (#575) and live dashboard progress for requests that do not stream (#689), by @jvmenen
- Images in Responses input (#686), by @LivenseAI
- Cancel and disconnect on
/v1/completions(#687), by @SuperMarioYL - Reports with reproductions: #690 and #691 by @robin1333k, #696 by @menega, #695 by @audenvenn, #677 by @energypantry, the menu bar request #692 by @ryanwwest, and the model folder requests #388 by @orkotr and #466 by @outofcoffee
Inkling 2 Mini is by Thinking Machines Lab, released under the Apache License 2.0 with its acceptable use policy: thinkingmachines/Inkling-2-Mini.
1c6fc39516febdeecf946cc070f708eb636206a0b7744416cc370653cd2655e4. Every published speed
number with its conditions is on the benchmarks page; the archive of every version is
on the releases page.