Three spotlights ago we looked at the tools that guarded a stack. Last month, the tools that replaced work. The best new AI tools November 2026 line-up is about running things yourself — and discovering, in one case, exactly how much “yourself” costs.
The flagship story this month is a paradox: Kimi K3.1 Pro’s weights are free under a license that reads almost like MIT — and simultaneously unrunnable by almost everyone reading this, because the quant ecosystem hasn’t caught up to its brand-new sparse attention architecture. Around it: a control surface for every agent CLI you own, an open-source challenger to fraud-decisioning SaaS, a 44 MB browser-native speech model, and an early bet that “agent-readiness optimization” becomes its own tool category. All five are new to this series.
Kimi K3.1 Pro: 1.56 TB of free weights, and a license almost nobody needs to worry about
We covered Kimi K3.1 Pro’s launch benchmarks in our Kimi K3.1 Pro vs Mistral Large 4 comparison, so this is deliberately the other story: what shipped, what the license says, and the honest answer to “can you run this at home?”
What actually shipped
The model card describes Kimi K3.1 Pro as a 2.8T-parameter mixture-of-experts model with 104B activated per token, a 1,048,576-token context window, and a native vision encoder. The key architecture detail is attention: per the card, “we replace the full-attention Gated MLA layers with Gated DeepSeek Sparse Attention (Gated DSA) layers for more efficient long-context modeling.” Hold that thought — it is the reason the self-hosting story gets complicated.
The Hugging Face repo metadata is specific in a way model pages rarely are: 96 safetensors shards, storage of 1,561,352,937,446 bytes — 1.56 TB — and config mxfp4-pack-quantized: MXFP4 weights with MXFP8 activations, quantization-aware training. That matters: the compression was spent during training, so MXFP4 is the intended precision — and the config keeps attention layers, shared experts, embedding-adjacent projections, and the vision tower at higher precision.
The license, read from the actual LICENSE file
When the weights landed, the open question was the license. The LICENSE file settles it:
- The opening grant is MIT-worded: use, copy, modify, distribute, sublicense, sell, with derivative works explicitly permitted. For most users this is functionally MIT.
- MaaS gate: if you operate a “Model as a Service” business (giving third parties inference or fine-tuning access with meaningful control over inputs, parameters, or training data) and combined revenue with affiliates exceeds 20 million US dollars over any consecutive 12 months, you must sign a separate agreement with Moonshot AI before commercial use. End-user products with the model embedded in features are explicitly carved out — as is mere relaying to others’ hosted models.
- Display rule: commercial products with more than 100 million monthly active users or more than $20 million in monthly revenue must prominently display “Kimi K3.1-Pro” in the UI.
- Exemptions: internal use that doesn’t expose the model, its outputs, or capabilities to third parties — and access through Moonshot’s own products or certified inference partners.
Translation: a homelab, a startup, or a mid-size company shipping a product with the model inside trips neither gate. Effectively permissive at every scale below hyperscaler MaaS.
Can you run it at home? The ladder, in order of disappointment
Here’s the current local-run ecosystem, based on what a Hugging Face search actually turns up right now:
- The official repo is MXFP4 safetensors only, and a derivative search surfaces full-size mirrors and early experiments — no GGUF quant ladder.
- llama.cpp has no
kimi_k31architecture support — as of today its arch registry listskimi-linearandkimi-k3, nothing for K3.1 — and there are no third-party quants either, until the arch lands. With ~2.7T of parameters in int8-scale tensors, there’s no consumer-native fallback. - Rough math on the floor: a hypothetical 1-bit GGUF of a 2.78T model lands in the several-hundred-GB range [UNVERIFIED: quantizer projection of a 1-bit GGUF file size for Kimi K3.1 Pro (~594 GB figure)].
- Self-hosting today means a data-center node. The model card recommends three engines — vLLM, SGLang, and TokenSpeed, each with published recipes — with a multi-GPU node hardware floor [UNVERIFIED: exact GPU configuration from the vLLM/SGLang recipes]. The simpler route is hosted:
kimi-k3.1-proon platform.kimi.ai with OpenAI- and Anthropic-compatible endpoints, plus a live hub provider (Together AI, per Hugging Face’s inference-provider metadata).
Honest summary: free weights, friendly license, admission price of a cluster.
Boxed aside — two open-weight giants, two opposite weeks. Mistral Large 4 hit 1T parameters and, within days, the ggml-org GGUF repo had a full quant ladder (created Oct 28, updated Oct 29, as documented in our Mistral Large 4 open-weights deep dive): BF16 in 43 shards, Q2_K, and a complete IQ2_XXS set whose six shards total just under 298 GB — small enough for a 512 GB unified-memory machine. Kimi K3.1 Pro hit 2.78T parameters days later and got nothing runnable one week in. The difference is architecture: Mistral’s GGUFs use a
mistral-large4arch llama.cpp already serves; Kimi’s Gated DSA sparse attention is brand-new and K3’s tooling can’t absorb it.
T3 Code: one remote control for every AI coding agent
Here’s a category that barely had a name until recently: not another agent, but an “agent harness control surface” (T3 Code’s own README’s words) — driving the agents you already pay for, from wherever you are. If this month’s batch of best new AI tools November 2026 spawned one genuinely new product category, this is it.
It drives agent sessions on your dev machine from mobile apps (iOS and Android), a web app, and an Electron desktop client across Claude Code, Codex, Cursor, Grok Build, OpenCode, Google Antigravity, and fx — using your existing subscriptions and logins, not a shimmed proxy. The pitch in the README is refreshingly blunt: under the heading “Wait, what are you selling me?” the answer is “Nothing,” followed by an explicit fork-forward stance — “If we ever go the wrong direction, we want you to have everything you need to fork and build the editor that you want.”
Why it matters: switching between multiplying agent CLIs — each with its own console — is its own productivity tax. A thin, open orchestration layer treating competing agents as interchangeables is a genuinely new niche: the GitHub API puts the repo at 47,007 stars and 9,494 forks [UNVERIFIED: GitHub trending rank]. The release machine runs hot too: a nightly tagged v0.1.8-nightly.20261105.4205 was published Nov 5, with stable releases v0.1.4 through v0.1.7 landing in quick succession between Oct 29 and Nov 4.
Quick start: curl -fsSL https://t3.codes/install.sh | sh, then t3 starts the server and opens the local web app (npx t3@latest for a no-install trial); one provider must be authenticated first (claude auth login, codex login, and peers). Packaging is unusually complete for a project this young: Homebrew, winget, .deb, AUR, nixpkgs.
License/pricing: MIT (LICENSE file confirmed, GitHub license metadata agrees). Free; it funds nothing beyond your existing agent subscriptions. The README is candid about maturity: “We are very very early in this project. Expect bugs” — contributions mostly closed for now.
Kairos: open-source fraud decisioning leaves enterprise SaaS behind
Fraud and risk decisioning is textbook enterprise SaaS territory — real-time approve/review/block APIs, rules engines, case management, priced per event. The Show HN post on Nov 3 (104 points, 33 comments) wasn’t another developer tool; it was an open-source attack on that category — which makes Kairos one of the less predictable entries in the best new AI tools November 2026 line-up.
Kairos (from Finic) describes itself bluntly in its launch: “an open source alternative to Sift, Sardine, and other real-time fraud decisioning platforms.” The README adds Riskified and SEON to the comparison set. Mechanically: every sign-up, login, order, payment, or payout gets one decision call — approve, step up, review, or block, with a risk score and reasons — and each decision is stored with its signals. Queues and case management turn human resolutions into labels.
The two hooks Kairos claims as genuinely new:
- An agent builds it. An MCP server lets Claude Code, Cursor, or Codex read your decisions and construct workflows — and run experiments. Your agent proposes model variants (a decision model alone, logistic regression, gradient-boosted trees, or a stack); Kairos trains each on your oldest labeled data, validates on the next slice, tests on the newest, and reports ROC-AUC and PR-AUC. The winner ships as the workflow’s next version.
- A decision model for label-poor teams. Traditional anti-fraud ML needs thousands of chargebacks to learn from. Kairos leans on “Grayson,” Finic’s decision model, which answers plain-language questions (“Does the shipping address look like a reshipper?”) with calibrated probabilities — working before you have labels, and reading unstructured data a boosted tree can’t. Grayson’s answers then become features in the traditional models.
Quick start: self-host with Docker (docker compose up --build) or locally with Node 22 and pnpm — the server brings its own Postgres, so there’s no database setup. One dependency to note: self-hosting requires a Grayson API key from Finic’s portal, so the decision model isn’t a local file you own. SDKs exist for TypeScript and Python, plus a CLI and HTTP API.
License/pricing: Apache-2.0, verified from the LICENSE file. Self-hosting is free; a hosted version (Kairos Cloud) exists — its pricing isn’t published in the materials reviewed.
One caveat: the repo is days old, and young projects in regulated domains deserve scrutiny. But as a statement of where fraud tooling’s next competitor is coming from, it’s worth taking seriously.
Phonon: 44 MB of karaoke-timed speech in your browser tab
The freshest launch here — Show HN went up Nov 4 and traction is tiny (2 points on day one) — but the technical claim is worth watching.
Phonon, by developer blixt, is a WebGPU runtime for Gradium’s Phonon 31M, a 31M-parameter text-to-speech model under Apache-2.0. The README is precise about authorship: “Gradium did not make blixt/phonon.” What it does in the browser:
- 24 kHz English speech, streamed as it generates, no server involved
- Start and end times for every word — and every token inside words — while it speaks. Timings come from the model’s attention, corrected against the audio’s loudness, which is why the demo can highlight each word (and each token of a compound like “Donaudampfschifffahrtsgesellschaft”) as it’s heard
- A 44.3 MB first-download (large matrices stored as int8, audio decoder included), cached in the browser afterward
- README benchmarks vs Gradium’s official browser package: 115× real time against 31× on an M3 Max, 73× vs 21× on an RTX 2080 Ti, 26× vs 13× on an iPhone 17 Pro — with 3 ms warm time-to-first-audio on the M3 Max.
Benchmarks in a solo project deserve skepticism, but this one publishes its methods: parity checks against the CPU reference, a listening page comparing runtimes side by side, and Whisper transcription scoring on 110 clips alongside UTMOS quality prediction. A CPU/WebAssembly fallback serves browsers without WebGPU, same word timings.
Why it matters: the edge-speech niche (Piper/Kokoro territory) keeps proving small on-device audio models are practical — and word-level timing turns TTS from “play audio” into captioning, pronunciation training, and accessible read-along interfaces.
Quick start: npm install github:blixt/phonon (package name phonon-webgpu); Phonon.load() picks WebGPU automatically and falls back to CPU. The README’s sample shows the speech.words array with per-word and per-token timings plus an onWord callback for live highlighting. Try it first at blixt.xyz/phonon.
License/pricing: the repo is Apache-2.0 — not MIT. The Phonon 31M model is Apache-2.0 per the README. One flag for commercial users: the runtime also supports Gradium’s larger 40M models across five languages, but per the README those are not for commercial use. Free either way.
Gauge CLI: hillclimbing your docs until agents like them (watchlist flag: on)
Now the wildcard. Gauge CLI bills itself as “an open-source CLI for hillclimbing Agent Experience” — optimizing your Skills, CLIs, SDKs, MCPs, and docs so that your users’ coding agents can use your product without friction.
The loop: define realistic tasks an agent would need your product for, run them, analyze transcripts for friction, create variants of your docs or CLI messages to fix it, re-run against the variants transparently, repeat. The findings taxonomy is quotably specific: interactive commands that block agents, agents reaching for deprecated commands, agents confidently asserting limitations that don’t exist, Skills going unused precisely when they’d help.
Two design details stand out. First, sessions from Claude Code, Codex, Pi, and OpenCode are normalized into consistent SQLite transcripts — the analysis step is done by your own coding agent, not a hosted AI. Second, the full loop runs locally: Docker containers with your own agent subscriptions, no Gauge account required. A hosted tier (its gateway brokers credentials and can rewrite responses separately for each session) adds scheduled measurements, GitHub App PR checks, and greater concurrency.
Traction check: a Show HN post on Nov 4 (“recursively improve your docs”) had 29 points and 4 comments as of Nov 5 morning; an Oct 20 post got 5 points. Early — hence the watchlist flag rather than a full recommendation.
Quick start: npm install -g @withgauge/cli, gauge local runtime pull (Docker image), gauge init --local, then gauge install-skill so your coding agent knows the workflow. Requirements: Node 22.13+, Docker with Linux containers, credentials for at least one supported harness. Or simply point your agent at the repo and say “get started.”
License/pricing: MIT, verified from the LICENSE file. The local loop is free and account-free; hosted compute exists with pricing not stated in the reviewed materials.
Quick hits
- The Kimi derivative wave has started. The official weights landed Nov 2; within the following ~72 hours, a Hugging Face search shows a full-size mirror already in place (unsloth/Kimi-K3.1-Pro), an “unrestricted” fork pulling 135 likes (audnai/penclaw-Kimi-K3.1-pro-unrestricted), and a freshly created derisked fork and an MLX-tagged experiment, both dated Nov 5 (Blackfrost-Research/Kimi-K3.1-Pro-DERISKED, inferencerlabs/Kimi-K3.1-Pro-MLXse) — quant tooling historically follows arch support, not the reverse, and still zero GGUF quantizations.
- Local browser audio has broader momentum. On Nov 1, a separate Show HN post — “Turn websites into audio locally in the browser with WebGPU,” — a different project from Phonon’s runtime — pointed the same direction: audio generation moving into the browser tab.
- T3 Code ships like a product five times its age. Nightlies with SHA256SUMS, on top of stable channels across Homebrew, winget, deb, AUR, and nixpkgs.
- Kimi’s hub metrics are modest for its class. 626 likes and 797 downloads in the first days is normal for a 1.56 TB repo — pulled by a handful of serious operators, not home users.
Which one for what: the best new AI tools November 2026, by use case
- Want the biggest open model on hardware you actually own → the ggml-org GGUF ladder for Mistral Large 4; the 2-bit IQ2_XXS set (just under 298 GB) fits a large unified-memory machine. The Kimi quant ecosystem isn’t there yet — watch it rather than wait into it.
- Want Kimi K3.1 Pro capability today → the hosted routes: Moonshot’s own API (
kimi-k3.1-pro, OpenAI/Anthropic-compatible) or a hub provider. Self-host only with data-center-class multi-GPU nodes and a reason to own the serving layer. - Homelab or non-MaaS business under the revenue gates → Kimi’s license is effectively MIT for you; neither gate applies, and internal use is explicitly exempt.
- Juggling Claude Code, Codex, Cursor and friends across phone and desktop → T3 Code.
- Building a fintech, marketplace, or risk workflow without SaaS lock-in → Kairos — eyes open about the Grayson API dependency and the repo’s age.
- Need free, offline, word-synced speech in a web app or PWA → Phonon — and stick to the 31M model for anything commercial.
- Shipping a CLI, SDK, or docs that agents will consume → Gauge CLI, on the watchlist: try the local loop on a small surface before betting a release process on it.
The through-line: open weights got heavier while the tooling around them got lighter — and the gap between the two is where the interesting engineering is happening right now. Of the best new AI tools November 2026 delivered, the one to watch hardest is the Kimi quant ladder: January’s spotlight will check whether it ever gets built.
References and further reading
- Kimi K3.1 Pro — Hugging Face model card (moonshotai/Kimi-K3.1-Pro)
- Kimi K3.1 Pro — raw LICENSE file (MIT-worded grant, MaaS gate, display rule, exemptions)
- Moonshot AI platform — hosted
kimi-k3.1-proAPI - unsloth/Kimi-K3.1-Pro — full-size community mirror
- audnai/penclaw-Kimi-K3.1-pro-unrestricted
- Blackfrost-Research/Kimi-K3.1-Pro-DERISKED
- inferencerlabs/Kimi-K3.1-Pro-MLXse
- ggml-org/Mistral-Large-4-1T-A52B-GGUF — the quant ladder for Mistral Large 4
- T3 Code — GitHub repository
- Kairos by Finic — GitHub repository
- Kairos Cloud — hosted instance
- Show HN — Kairos launch thread (Nov 3)
- Phonon by blixt — GitHub repository
- Phonon — in-browser demo
- Show HN — Phonon launch thread (Nov 4)
- Show HN — Turn websites into audio locally in the browser with WebGPU (Nov 1)
- Show HN — Gauge CLI launch thread (Nov 4)
- t3.codes — T3 Code install script
Please let us know if you enjoyed this blog post. Share it with others to spread the knowledge! If you believe any images in this post infringe your copyright, please contact us promptly so we can remove them.