Frontier models. Your Mac. No cloud.
Quadpoint AI Studio runs 27B to 290B-parameter open-weight models on a 16 GB Mac by paging expert weights straight off the SSD. One self-contained bundle per model, a Swift and Metal engine written from each model's spec, and an OpenAI-compatible server on localhost for Xcode and your agents.
Apple silicon · macOS · Swift only · every number on this page was measured on a Mac mini M4 with 16 GB.
An inference engine built for machines that are smaller than the model.
Most local-AI tools load a whole model into memory and stop at whatever fits. Quadpoint treats RAM as a cache. Weights are packed into a single self-contained file and paged in on demand. Mixture-of-experts sparsity means a token touches a few percent of the weights, and the ones in use stay in memory. That is the entire story of running a 30B, a 125B, or a 290B model on a Mac mini.
.QPX One file per model
Weights, tokenizer, config and provenance in one self-contained, stamped bundle. Prepared anywhere, opens identically everywhere, on every platform the engine reaches.
METAL Spec-to-silicon engines
Every model family gets its own runtime, written fresh from the reference modeling file, with kernels for MXFP4, Q4, Q8, IQ3/IQ4 and F16 weights. No lane ships until its output is verified accurate on our hardware.
PAGING Built for small machines
The engine keeps the weights in use warm, reads ahead for the ones it will need next, and never blocks generation on the disk. The bandwidth math is honest; see the hardware table below.
Two native macOS apps that share one library.
Quadpoint AI Studio
Open a bundle, prompt, generate. The Studio is the engine's home: a chat surface with streaming, a heads-up display of tokens per second and paging stats, per-model sampling and thinking controls, and a settings gear for decode options.
- Local server. OpenAI-compatible routes on localhost. Xcode's model bridge, coding agents and curl all talk to it.
- Web chat. Open the server's address in any browser on the Mac for a chat page with streaming answers, a thinking pane, a stop button and a system prompt. One switch in settings turns it off.
- Run what you generate. A play button renders generated HTML live inside the app, with JavaScript alerts bridged to native dialogs.
- Fix turns. Search-and-replace patch turns ride the cached prefix, so a fix costs tens of tokens instead of a regeneration.
- Curated catalog. Download, verify against the official SHA-256, and auto-slice to a stamped bundle on completion.
Quadpoint AI Studio Companion
A native terminal agent that drives the Studio's server. Point it at a project folder and it explains, patches, builds and repairs real Swift code through a deterministic loop that surfaces every failure in plain text.
- F5 / F6 / F7 / F9. Workspace brief, composer patch, build from the enclosing Xcode project, and send the compile errors back as a patch turn.
- Assembler rules. Build errors are matched against the Swift compiler's own diagnostic templates, and the verified fix is injected into the model's context.
- Exact patches. Search-and-replace blocks are applied atomically with a permission diff gate. No block may empty a file.
- Workspace-aware. Bare filename mentions resolve through the project tree. Applied patches compact to receipts in history.
Four steps, no quant decisions.
Customers never pick a quantization. The catalog only lists models that have run on our hardware and passed our quality checks.
Pick a model
Choose from the curated catalog. Each entry is a model, a URL, an official checksum and a slice recipe.
Download and verify
The verified queue checks the SHA-256 before anything moves into the library. Every failure is loud.
Slice to .qpx
The source is packed into one stamped bundle, ready to open in the Studio.
Generate
Open the bundle. The tokenizer attaches, a self-check runs, and the first token streams.
Heavy hitters, each with its own lane.
A lane is a runtime, a Metal engine and a slicer for one model family. Speeds are on the Mac mini M4 with 16 GB; a Studio with 36 to 512 GB is a different product.
| Model | Architecture | Bundle | Mac mini 16 GB | Status |
|---|---|---|---|---|
| Qwen 3.6 35B-A3B | MoE, 128 experts top-8, GDN hybrid attention | resident | 14–19 tok/s | Live |
| Qwen 3 Coder 30B | MoE, 128 experts top-8 | resident | ~15 tok/s | Live |
| Qwen 3.8 27B | Dense · self-drafting MTP depth 2 | resident | 11.9 tok/s | Live |
| gpt-oss 20B | MoE, harmony format, reasoning effort selector | resident | ~19 tok/s | Live |
| Qwen 3.8 Flash Next (~125B) | MoE, 512 experts top-10, hyper-connections, sparse attention | 87 GB, paged | 3.95 tok/s | Live |
| DeepSeek V4 Flash (~290B) | MoE, 256 experts top-6, compressed attention, lightning indexer | 144 GB, paged | 1.1 tok/s | Live |
| DeepSeek V4.1 Flash | MoE + Engram memory tables, FP8 trunk | 466 GB, paged | 0.37 tok/s | First light |
| Gemma 4 (E4B first) | Dense, per-layer embeddings | resident | — | Lane written |
| GLM-5.3 Flash | MoE, DeepSeek-style hybrid | 163 GB, paged | — | Engine shipped |
| Kimi K3 · MiniMax H3 | Queued for the next system | Queued | ||
The bigger-than-RAM models are bounded by SSD read speed on a 16 GB machine, not by compute. Their ceiling on the mini is about 2 to 3 tok/s. They exist here because the same bundle and the same code become conversational on hardware with more memory.
Measured math, not marketing.
Paging is the portable asset. VRAM versus host RAM is the same physics as RAM versus SSD, so a machine with a bigger pipe makes the same code faster. Estimates for hardware we have not run on are marked as projections.
| Tier | Memory bandwidth | DeepSeek V4 Flash | 30B-class MoE | Basis |
|---|---|---|---|---|
| Mac mini M4, 16 GB | ~120 GB/s | 1.1 tok/s (2–3 ceiling) | 14–19 tok/s | Measured |
| Mac Studio, 36 GB | ~400–550 GB/s | 3–4 tok/s | 50–80 tok/s | Projection |
| M4 Max, 128 GB | ~546 GB/s | 4–8 tok/s | ~60 tok/s | Projection |
| M3 Ultra, 512 GB | ~819 GB/s | 40–100 tok/s, fully resident | 100+ tok/s | Projection |
Accuracy before speed
Every lane is verified for correct output before anyone looks at tokens per second. Speed work never ships on a lane whose answers have drifted.
Quality gate
A model enters the catalog only after it runs on our hardware and passes our quality checks. Formats that hurt generation quality do not make the cut, however small they are.
Sampling that survives quantization
Temperature and nucleus sampling over a top-K prefilter with a min-p floor, per-model configs at each model's official parameters. Greedy decoding was locking in quantization mistakes; sampled decoding fixed it.
One endpoint, every client.
The Studio serves the loaded model on localhost with OpenAI-compatible routes. Streaming starts with the first byte, pre-stream errors come back as JSON, and array-form message content is read directly. Xcode's model bridge and the Companion both use it, and so does curl.
- Chat and reasoner routes. The chat route runs without thinking; the reasoner route streams the model's thought channel separately.
- Prefix reuse. A prompt that shares a prefix with the last request skips straight to the new tokens.
- Honest limits. A prompt longer than the model's context returns an error instead of tripping the engine.
- One model at a time. Switching models fully unloads the previous one and clears the cache. Two big models never coexist on a 16 GB box.
- Web chat page. The server's root address serves its own chat client, so a browser on the Mac is a client too. Nothing is installed and nothing leaves the machine. The page is off by a switch in the settings gear.
curl http://127.0.0.1:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.6-35b-a3b",
"stream": true,
"messages": [
{"role": "system", "content": "You are a Swift engineer."},
{"role": "user", "content": "Write a SwiftUI counter view."}
]
}'The port and model id are shown in the Studio's server panel. Point Xcode's model provider at the same base URL.
Get the apps.
Quadpoint AI Studio and the Companion come together as one purchase: $200, one license key, both apps. Native macOS builds for Apple silicon, notarized by Apple. Install the Studio first; the Companion talks to it.
Quadpoint AI Studio
The engine, the chat surface, the local server and the model library.
Quadpoint AI Studio Companion
The terminal agent with the build-fix loop. Requires the Studio's server.
Quadpoint AI Studio is made by iSovereign Software LLC. Questions, or a machine to spec for the frontier lanes? Call 765-203-1506.
The short answers.
Does anything leave my machine?
No. The engine, the server and the Companion run locally. The only network traffic is the model download from the catalog, which is verified against the publisher's checksum.
Can I chat from a browser?
Yes. With the server running, open its address in any browser on the Mac. The page streams the answer and the model's thinking channel separately, keeps history in the browser, and has a stop button that cancels the generation. The same switch in the Studio's settings gear turns the page off while leaving the server routes up.
Why can a 290B model run on 16 GB at all?
Mixture-of-experts models activate a small fraction of their weights per token. Quadpoint keeps the experts in use warm on the GPU and pages the rest from the SSD as tokens need them. Each token still pulls a lot of data from disk, which is why those lanes are SSD-bound on the mini.
Can I bring my own GGUF?
The customer flow uses the curated catalog and slices on completion. In-app slicing of a GGUF you already have is the next piece of the library, with family auto-detect, recipe flags as UI and per-layer progress.
What does the Companion actually do to my code?
It applies search-and-replace blocks the model writes, with an exact match first and a whitespace-tolerant fallback. Every application is atomic, gated by a permission diff, and reported in plain text. Failed matches, missing files and malformed blocks are shown in the transcript and fed back to the model.
Which hardware should I buy for the frontier models?
See the tier table above. A 512 GB-class Mac makes DeepSeek-scale models fully resident and conversational. A 36 to 128 GB machine makes the 30B lanes very fast and the frontier lanes usable. The mini is the proving ground.