Native Mac inference for agents at scale

A fleet of agents.
One Mac.

inferd is a native inference engine for Apple Silicon, built for many agents at once: long shared contexts, agents that pause and come back, and everyone wanting an answer now.

615tok/s32 agents on 16k contexts. One Mac Studio.
341vs 240One Studio against a pair of DGX Sparks. Flash-Next, 8 agents.
29% sooner8 Qwen3.8-27B agents finish ahead of TensorFold 1.2.1 and 1.2.2 (125.6 vs 177.9 s).
0.2–0.7sfor an agent to resume, from memory or SSD, not 15–18 s of re-reading.

01 · The problem

Built for more than a chat.

Most Mac engines are tuned for one person talking to one model, and they are very good at it. Agents behave differently: they share long contexts, take turns, pause, resume, and all want an answer at once.

One prompt at a time

Agent eight waits for the other seven.

When prompts are read strictly one after another, the queue grows with every agent. In one engine's parallel mode, combined throughput even falls as agents are added: 148 → 143 → 124 tok/s at 2, 4 and 8.

inferd: everyone, together

Agents start in a steady stream.

Prompts are read in chunks between decoding steps, agents are admitted by memory budget, and the GPU stays busy. Add agents and the combined rate keeps climbing.

02 · Measured on a Mac Studio

More agents. More throughput.

Same machine, same weights, same harness. Every point on every chart is a measured run, not an estimate.

615 vs ~369 tok/s

Throughput keeps climbing as agents pile in

01603204806408001481632agents615inferd369Splash 1.5
Total tok/s by number of agents. Mac Studio M5 Ultra, Qwen3.8-27B 4-bit, agents taking turns on 16k contexts, 512-token replies. Splash 1.5 is faster for a single agent (172 vs 143 tok/s); it was not run at 32.
125.6 vs 177.9 s

The last agent finishes sooner

0408012016020012345678agents177.9TensorFold 1.2.1125.6inferd
Seconds until the last agent finishes; lower is better. N agents released together, 14,336-token prompts, 6,400 tokens out, Qwen3.8-27B, same drafter weights, 3 trials each. TensorFold 1.2.2 measured the same as 1.2.1 within 1%.
3.83 vs 49 s

At 64k, the 32nd agent still starts in seconds

012243648601481632agents48.9Splash 1.53.8inferd
Time to the last agent's first token, seconds; lower is better. Agents taking turns on 64k contexts, Mac Studio.
78.7 vs 116.8 s

Agents arriving at random

TensorFold 1.2.2, first come first servedinferd
27B total (s)
116.8 s
78.7 s
27B p95 first token (s)
72.1 s
34.0 s
16 agents arriving about 3 s apart with 2k–16k prompts and short replies, Qwen3.8-27B. TensorFold 1.2.2 in its default order; its new shortest-first order measured slower (122.9 s). On Flash-Next the two engines are level here (57.2 vs 57.3 s).
Flash-Next

Eight agents, one question: who finishes the job?

inferdMac Studio M5 Ultra
341tok/s
TensorFold 1.2.1, arrival-order prefillMac Studio M5 Ultra
300tok/s
TensorFold, dual-Spark recipe (TP=2)2 × DGX Spark
240tok/s
TensorFold 1.2.1, defaultsMac Studio M5 Ultra
205tok/s
TensorFold, 8 slots, 32k window1 × DGX Spark
145tok/s
TensorFold 1.2.1 --parallel 8Mac Studio M5 Ultra
124tok/s
End-to-end tok/s, higher is better. Qwen3.8-Flash-Next, 8 agents released together, 14,336-token prompts, 6,400 tokens out, thinking off. Single trial each, 2 November 2026.
341 vs 240 tok/s

One Studio vs two DGX Sparks

080160240320400148agents341Mac Studio, inferd2522 × 1 Spark, projected2402 Sparks, measured1261 Spark
Flash-Next, same harness. Two Sparks cost about the same as one Studio and hold the same 256 GB. Dotted: twice one Spark, an upper bound for two separate boxes. The Sparks are well served by vLLM and TensorFold today; they are inferd's next target.

Fair's fair.

inferd is not ahead everywhere, and it stands on excellent work. These are the engines we measure ourselves against, and where they lead.

TensorFoldSuperb single-agent decode, fast prefill, and the quicker finish for 1–5 Flash-Next agents starting together.
SplashA strong all-rounder: faster than inferd for one agent on short contexts, excellent up to a dozen-odd agents.
oMLX & mlx_lmBrilliant for one user, quick to start, and the reference every kernel here is checked against.
vLLMThe standard for serving at scale, and what runs our DGX Sparks today.
Flash-Next, agents starting together0408012016020012345678agents166TensorFold 1.2.1138inferd

TensorFold 1.2.1 finishes sooner up to about 5 agents (its Flash-Next prefill is faster); inferd from 6 (8 agents: 137.7 vs 166.3 s). Seconds, 3 trials.

03 · Pick your Mac

From Mac mini to Mac Studio.

Every figure below was measured on that machine, not extrapolated.

A fleet on your desk.

Small box, serious work. On every 8- to 64-agent fleet we ran on the minis, inferd led.

  • GPU neural accelerators. The M5 Pro decodes about 2.3× faster than the M4 Pro for one agent.
  • Older chips welcome. GPUs without neural accelerators (M3/M4) get their own kernel path, with logits matching mlx_lm. On an external tester's M3 Max, 16 agents at 32k all started within 28.4 s (Splash's last: 114 s). M1/M2 are untested.
  • Neural Engine (experimental). Optionally, inferd splits work onto the Neural Engine: up to +45% on the M6's 8k fleets.
184.6tok/sM5 Pro, 16 agents on 4k contexts.
14.3turns/minM5 Pro, 16 agents at 16k. Splash 1.5: 12.0.
+19–25%over Splash 1.5 at 16 agents (M5 Pro and M6).
64/64requests served at 64 agents. Splash refused half of the first round.
167.6 tok/s, M5 Pro

Agents taking turns on 16k contexts

0408012016020014816agents168M5 Pro 64 GB68M6 32 GB60M4 Pro 64 GB
Total tok/s, Qwen3.8-27B 4-bit + DFlash2. The M6's 32 GB leaves a 2.4 GiB KV pool, about four 16k contexts, so larger fleets there re-read context.
Qwen3.8-27B 4-bitM4 Pro 64 GBM6 32 GBM5 Pro 64 GB
Decode, one agent, 4k31.837.272.6
Prefill, 4k prompt (PF8 off)120269454
16 agents, 4k contexts65.4110.5184.6
16 agents, 16k contexts59.667.6167.6
Resume via the session API–0.43 s0.26 s
Self-tests and demos15/15 pass15/15 pass15/15 pass

tok/s unless stated. With int8 prefill (PF8) on a server sized for a few agents, the M5 Pro reads a 4k prompt at 668 tok/s.

Flash-Next does not fit on a mini. For the biggest models, step up to the Studio.

Runs on open weights: Qwen3.8-27B · Qwen3.8-Flash-Next · Qwen3.6-35B-A3B · Qwen3.5-9B · Gemma-4-31B · Muse Glimmer 30B

04 · Built for agents

Keep the context. Keep working.

Agents re-read the same material constantly. inferd lets the agent framework, which knows who will come back, decide what the model's memory keeps.

0.2–0.7 s

Back to work in a blink

without the API: re-read the contextinferd sessions and saved contexts
M6: resume a parked session
18.30 s
0.43 s
M5 Pro: worker resume
18.40 s
1.16 s
M6: worker resume
24.60 s
1.79 s
M4 Pro: worker resume
62.30 s
2.20 s
Time to an agent's first token after other work filled memory. Qwen3.8-27B 4-bit + DFlash2 on Mac minis.

One field on a normal OpenAI request

POST /v1/contexts  # save + pin a context once
POST /v1/chat/completions
{ "model": "qwen3.8-27b",
  "messages": [ ... ],
  "inferd": {
    "context": "brief-42",  # start from it
    "session": "agent-7",   # keep my turn
    "effort": "low",        # per agent
    "max_context": 32768,
    "priority": 1
  } }
# one-off work that leaves no trace:
  "inferd": { "cache": "drop" }
GET  /v1/cache     # cached, pinned, parked, free

Every reply reports cached_tokens, so a framework can check its caching strategy instead of guessing.

Saved contextsPin a brief, a codebase or a whole conversation once; new agents launch from it in 0.4–1.6 s and pay only for their own tokens.
Sessions on SSDPark an agent on disk, with checksums, and bring it back in 0.2–0.7 s instead of 15–18 s.
Per-agent controlsContext limit, reasoning effort and priority are set per agent on one server.
Strict JSONConstrained decoding plus schema validation: 100/100 valid on the first attempt.
8-bit KV, int8 computeMore agents per gigabyte, no measurable quality loss.
Hybrid models, done properlyQwen3.8 mixes attention with recurrent layers; inferd snapshots their state so prefix reuse, sessions and speculative decoding work together.

05 · Quality

Faster, with nothing given up.

41.6%

Humanity's Last Exam (HLE Lite, 173 items)*

Qwen3.8-Flash-Next
41.6%
Qwen3.8-27B 8-bit
34.1%
Qwen3.8-27B 4-bit
32.4%
Percent correct, effort medium, Mac Studio (32k budget, capped items re-asked at 128k). Published runs on other engines: 27B 31.8–33.5%, Flash-Next 34.7–43.9%.* Benchmark: github.com/incept5-ai/hle-lite
43.7/48Coding test*, level with the leading alternative (41.8, within run-to-run noise).* Benchmark: github.com/incept5-ai/languages-benchmark
100/100Strict-JSON replies valid on the first attempt, across five sets of 20 under mixed load.
top-1Logits match the mlx_lm reference (cosine ≥ 0.9997) at 24-, 256- and 1,536-row chunks.

06 · On the shoulders of giants

Native C++, Objective-C++ and Metal.

No Python on the token path; a thin Python front end serves the OpenAI-compatible API. inferd builds on Apple's MLX (its quantized and attention kernels are vendored, MIT), Qwen's open weights, the DFlash speculative drafter, and lessons openly shared by the TensorFold, Splash, oMLX and vLLM communities. Built and tested on Mac Studio M5 Ultra, Mac mini M6 / M5 Pro / M4 Pro and MacBook Pro M5 Max, macOS 27.

What could your agents do with a whole Mac to themselves?

Tell us your models, your Mac and your workload, and we'll show you where inferd fits. The full report, harness and raw results are available on request.

Talk to us about inferdRequest repository access