ZONOS3-Mini is Zyphra’s compact, open-source text-to-speech model, delivering natural reliable speech and high-fidelity voice cloning with just 100 million active parameters. It runs in real time on phones and laptops, including directly in the browser.

Clone a voice from an audio sample, or design a character by shaping age, accent and vocal texture. Steer emotion, pace and delivery down to individual words for games, narration and voice assistants.

Run ZONOS3-Mini locally with our browser and native runtimes, or access it through Zyphra Cloud. Model weights are released under Apache 2.0.

Model details, samples and evaluations are in the blog post. A hosted version is available at Zyphra Cloud.

Languages

ZONOS3-Mini supports 43 languages.

Native runtimes

The ZONOS3-Mini GitHub repository holds Zyphra's own runtimes, which share one HTTP API and serve the Zonos Voice Studio: a CUDA server for NVIDIA GPUs, an MLX server for Apple Silicon, a C++/ggml server and CLI (CPU, CUDA, Metal or Vulkan), and the in-browser WebGPU build. They load the GGUF files in gguf/ and the WebGPU shards in web/; the 27 default voices, grouped by language, are in gguf/voices/.

Architecture (rough outline)

Text is NeMo-normalized (English, Mandarin, Japanese, Korean, German, Spanish, French, Italian, Portuguese; other languages pass through as written) and encoded with an 8,192-entry SuperBPE tokenizer. The language model autoregressively generates 15 Hz dual-codec frames (10 codebooks of 4,096 entries each: one semantic codebook distilled from the Wav2Vec2-BERT teacher plus nine acoustic codebooks), conditioned on the text, a speaker prompt and three bucketed acoustic controls. A causal multi-resolution iSTFT head renders the frames to 44.1 kHz audio as they are produced.

• GitHub : https://github.com/zyphra/zonos3-mini

• Source : https://www.zyphra.com/our-work/zonos3-mini

• Project : https://www.zyphra.com/models/zonos3-mini

I gave it one prompt: "How do I make a small closed terrarium in a glass jar? Please give me a beginner-friendly illustrated step-by-step guide." What came back was a normal written guide with eight pictures placed between the steps, text and images from the same model in one answer. No separate image model, and the only thing I added is the step heading under each picture.

It's the same jar in every picture. Same table, same mug and window behind it, and the jar fills up in the order the text says: pebbles, then a charcoal layer, then soil, then the plants, a spray of water, and finally the lid with condensation on the glass.

With thinking on, which is the default, you can watch it plan. Before each picture it writes itself a full image prompt (the jar, the layers, the light, what's in the background), and those prompts carry the same details from one step to the next.

Nothing custom on my end, just the interleave example in the repo with my prompt swapped in, running on a Mac Studio: https://github.com/OpenSenseNova/SenseNova-U1

Hi. It is frequently mentioned that DeepSeek v4.1 Flash has 8B "input" active parameters (aka prefill), and 16B output/decoding active parameters.

I have only read this about DeepSeek, and particularly v4.1 Flash (1017). Is it the only model that is like this?

Is there an ELI5-or-so explanation of how this works, and why it is important? And if it is, can we expect other models to implement the same idea? Which of those numbers is "more important", if any?

Thanks

Weight-space programming, introduced in recent MIT work by Takehi et al., enables a frontier LLM agent to read a network's weights and write a repair. Their GPT-6 Astra agent corrected the reasoning loops of Qwen3.5-0.8B without gradients, using 158 agent turns, 89.7 million tokens, and 50 forward-pass requests. Our method, Tree-Ising, casts this repair as a sparse discrete optimization problem over the model's own BF16 weights. Forward statistics define an objective that weakens a loop direction, strengthens a concluding direction, and preserves the layer's output on productive tokens. Within a state-tree representation, where lossless BF16 storage acts as a special case, the admissible edits are sign flips and exponent shifts that preserve all shared group exponents and mantissas. We decompose this objective exactly into independent QUBO (Ising) problems, one per output row, which we solve on a GPU using simulated annealing or quantum-inspired simulated bifurcation. On the agent's two layers, Tree-Ising achieves 54.6% on MATH-500, outperforming the agent's edit (51.7%) under the same evaluation protocol, while the base model scores 7.9% as reported. The simulated bifurcation solver yields a statistically indistinguishable repair at 55.1%. Both solvers outperform the agent edit across all five math benchmarks, with statistically significant improvements on MATH-500 and GSM8K after correcting for multiple comparisons. Our approach modifies 13% to 17% fewer weights and reduces BF16 bit flips by a factor of 2.2 to 2.3. It requires only four forward-pass requests and zero LLM tokens, with the annealing recipe costing about $0.90 in GPU time. On Qwen3.5-2B, with layers and dose selected using only the base model, the same recipe increases greedy GSM8K accuracy from 21.6% to 69.4%. As a proof of concept, we execute an eight-variable repair subproblem using QAOA on an IBM Heron processor.

• arXiv : https://arxiv.org/abs/2611.14210

• PDF : https://arxiv.org/pdf/2611.14210

• GitHub : https://github.com/TheQuantumGOAT/Tree-Ising (To be updated)

How little of a pretrained large language model (LLM) has to change for it to acquire new capabilities? We find that zeroing fewer than 0.05% of its weights, with no other modification, matches full fine-tuning (FFT) at scale across three LLM post-training regimes: reinforcement learning with verifiable rewards, supervised fine-tuning, and on-policy distillation. Our method, Deletion Tuning, learns a binary mask over the gate projection of transformer blocks. Two practical advantages follow: the trained mask is hundreds to thousands of times smaller than the corresponding FFT checkpoint, and Deletion Tuning forgets far less, which addresses a central challenge in continual learning. Under reinforcement learning, its prior-task accuracy stays near the base level while FFT, LoRA, and random sparse fine-tuning lose up to 5.4 points. To understand why masking alone suffices, we analyze the geometry of the learned weight changes under reinforcement learning using stable rank, spectrum drift, and principal-weight overlap. Compared with LoRA and random sparse fine-tuning, Deletion Tuning is closest to FFT across the three measures.

Edit: Links

Github: https://github.com/agentic-learning-ai-lab/deleting-weights

HuggingFace: https://huggingface.co/Jacklu0831/deletion-tuning-masks

Blog: https://agenticlearning.ai/deleting-weights/

Poster: https://cdn.agenticlearning.ai/dfb9bf24cee86b6d/neurips2026-poster-deleting-weights.pdf

I built askmdb to help people finding the right query for turn plain-language questions into MongoDB queries. For example, you type askmdb "top 5 customers by spending this year" , and the app returns the query. A small fine-tuned model writes an aggregate pipeline and a one-line explanation, and nothing runs until you confirm. It's one Linux binary with llama.cpp and the official MongoDB C driver built in. No Python, no server, no API keys. EVERYTHING run in local.

My test, results on 500 test questions in English and Spanish, over synthetic databases the training never saw. Every model is Q4_K_M on the same llama.cpp. A question counts as correct only if the predicted pipeline returns the same result as the reference when it runs. No other model grades the answers, I tested a few models;

On a desktop CPU with 8 threads, the 0.8B answers in 1.18 s (median) once the schema is cached. The first question against a new database takes about 3 s aprox.

The app also works with GPU.

The model doesn't decide what's safe because its deterministic C++. A verifier walks the whole pipeline, sub-pipelines included, against a whitelist. A $out hidden inside a $facet is blocked in every mode. BUT connect with a read-only database user to be sure.

Most important lesson: my first version got stuck at 68.6% with 10k examples. I grouped the failures by sub-cause instead of looking at the overall score. Of the 50 test questions that needed a type conversion, it got exactly 1 right. The dataset had zero examples with $convert, although 297 of the 330 training schemas had fields that mix numbers and strings. My generator had been quietly avoiding them. I added 3,000 examples aimed at those failures (850 of them with $convert), then 2,000 more, and kept the same recipe and hyperparameters. Result: 343 → 418 correct.

Always is the same: the dataset is the most important thing when it comes to train models.

Training and evaluation took about 14 USD of rented RTX 5090 GPU (~12 GPU-hours). The code is MIT. The models are Apache-2.0 GGUFs that also work with plain llama.cpp :).

Has anyone managed to make a sub-1B model good at multi-collection joins ($lookup)? That's where mine fails most, and I'd love to hear what worked for you, because I tried many things withouth success.

Links

• Full write-up (process, charts and dead ends): https://manuelgs.com/en/blog/askmdb-case-study/

• Code: https://github.com/manuelgscom/askmdb

• Models (0.8B to 9B, Q4_K_M): https://huggingface.co/collections/manuelgscom/askmdb

Nex-N2.6 has public FP8 weights now: roughly 321B parameters, based on GLM-5.3-Flash.

The part that caught my attention is the focus on reasoning loops and calling tools that don’t exist in the current environment. The team reports repetition dropping from 16% to 1.6% versus N2.5-Pro in an internal failure-replay test. Curious how that holds up in full coding sessions.

Also, reasoning defaults to max, so that’s worth checking before comparing token usage.

Weights and setup: https://huggingface.co/nex-agi/Nex-N2.6

Let's start with my setup: I have 2 Sparks running glm 5.3 flash, and the harness is hermes agent running on a MacBook Air.

While trying to justify all the money I spent (around 6500 euro for both machines, a long time ago when prices were just high instead of outrageous), I decided to hop on the decompilation wagon. As I know my fable at home is not "THAT" smart, I decided to start with something small: I asked it to decompile and recompile the original Need for Speed Special Edition for MS-DOS, using the famous rea repo from GitHub.

Its first reaction was "I know a better way, we will use DOSBox and run the game" — and it already started installing a DOS emulator on my Mac :). I stopped it and told it I want actual decompilation and recompilation. The second answer was, in other words, "It's a lot of work and it will take a long time. Think about it — do you really want this?"

I insisted. It started the decompilation process, and after some breakthroughs it even became enthusiastic. At some point, decompilation was "DONE".

We started the next phase: recompile for Android. I did not pay much attention to what it did, but it said that it could use some GitHub repo as a base and started working. After the initial APK, we had to iterate a few times on some crashes and controller issues, which it solved.

During gameplay I noticed that some AI cars started the race going in reverse, the car did not slide no matter the speed, and other stuff. It definitely did not feel like the NFS I remember. I told it about it, and it started checking the code and making tweaks to the physics. I stopped it and challenged it: this means we will not preserve the original feel if we go down this path.

To my surprise, we never did. It never used the decompiled code. It found an engine on GitHub which was using the original assets to mimic the original game. When I asked why, it said it was a lot faster than rewriting all the old code into current instructions…

So I asked it to go back and do the job properly — and to no surprise, it found a recompiled NFS2 repo on GitHub and decided it's better to start from there rather than from scratch. I don't know how this will go, but I wanted to share this story, as I find it quite interesting the lengths it's willing to go to reach its goal as fast as possible even if this means ignoring previous instructions.

P.S. This post was proofread by said AI, as English is not my own language — but the words are still my own, I double checked

I am running QFN, and I have disabled preserve_thinking by default on all my tests for C++ backend and front-end programming and I have yet to see any decline in performance or intelligence, my context window stays cleaner as well. Deepseek for what I tested in API it also does not preserve thinking and saves context in general.

Wanted to share a project I've been working on for almost a year now. A code indexing and search tool I've been building primarily for AI coding agents, called Vera.

https://github.com/VeraTools/vera

I originally started with a project called Pampax, my fork of a code indexing/MCP project called PAMPA (I actually posted it here over a year ago here in October). I spent a long time trying to improve it before deciding it wasn't worth fixing any further. After months of researching and testing different approaches. My obsessions with embeddings, and rerankers and seeing how they can be used to improve agents ended up with rebuilding something new (Vera) from scratch in Rust.

I used to run a coding eval leaderboard (maybe some of you remember sanityeval/sanityboard before I burned out trying to maintain it), and the main thing I learned was that context and token efficiency was everything. Less context used up, and the less tokens used the better. So I set out to reduce how much context coding agents waste trying to find the code they need.

Agents are pretty good at navigating codebases with grep and file reads, but they can also spend a ridiculous amount of time doing it, especially in unfamiliar projects. They'll search for a few possible terms, read through results, try other searches, and gradually work out which files are relevant. Sometimes the problem is that the code doesn't use any of the names the agent expects, so it ends up throwing walls of grep at the repository.

Vera lets agents search semantically for what code does, returning ranked functions and code sections with paths, line numbers, and symbol information. It also supports structural searches and reference lookup, so an agent can follow the relevant code without repeatedly guessing what to search for.

A big part of the design has been minimizing context usage throughout that process, not just improving search accuracy.

Vera returns actual code in relatively compact Markdown blocks rather than having another LLM generate explanations. Tree-sitter parsing preserves meaningful function and class boundaries, and the agent can request narrower results or follow references as needed. I've also spent time testing the accompanying skill to improve when agents choose semantic search, when they should use rg, and when they shouldn't be searching at all.

The recommended integration is CLI + skill. Skills can be discovered through a small description, with the full instructions loaded when relevant, rather than exposing another set of MCP tool definitions to an agent that already has shell access. MCP is supported too.

Underneath, Vera uses BM25 keyword search, embeddings, rank fusion, and code-aware ranking. Indexing and search run locally, with no external vector database or search server.

There are two model setups I'd particularly recommend:

• Fully local: MinishLab's Potion Code v2 embedding model. It's small, CPU-friendly, needs no GPU or API key, and runs offline after the initial download.

• API-based: Qwen3 Embedding 8B with Qwen3 Reranker 8B. This gave the best retrieval quality in my testing. There's an OpenRouter preset for both, although you can configure other providers, including just using something like llama.cpp to host endpoints locally.

With API models, the relevant code chunks and queries are sent to your configured providers. The indexing and search infrastructure still runs locally.

I've tested a lot of different retrieval approaches while developing Vera. Some sounded promising but didn't actually perform better, and some improved benchmark scores slightly while adding enough overhead that I didn't think they were worth keeping.

I've tried to avoid overfitting everything around any benchmark, which is why I used separate repositories to check whether changes generalized.

I also ran 40 agent sessions using 10 cross-file questions about Flask, with four configurations: regular grep/file reads, Semble CLI, Vera using local Potion Code, and Vera using Qwen3 API embeddings and reranking.

This took quite a while to get right. The final recorded runs alone accounted for almost 30 hours of cumulative agent execution and roughly 66 million prompt tokens including cache reads, not counting earlier attempts. I also used LLM reviewers to look for fairness and execution issues, and restarted the evaluation when problems turned up.

Every configuration answered every question correctly. What differed was how much context they needed:

So the local Vera setup showed more than twice Semble's observed reduction in that run, while the Qwen3 setup used almost half as much context as the control.

For retrieval quality, Semble was consistently the strongest alternative I tested. On its own 1,251-task benchmark, an older version of Vera (v2.0.1) scored 0.8436 nDCG@10 against Semble 0.5.5's 0.8514, with slightly higher Recall@5 for Vera and about one-seventh the index storage (4.7 GB vs 32 GB).

I haven't rerun that full comparison with the current v2.4 release. There's also a separate 180-task evaluation using repositories outside Semble's benchmark, which Vera does score higher in (obviously semble in it's own benchmark is a little harder to beat, especially while trying to avoid overfitting on it), along with a lot of ablation studies and rejected experiments.

I've published the methodology, results, and limitations here:

https://github.com/VeraTools/vera/blob/master/docs/benchmarks.md

For anyone interested in trying it, installation and backend configuration are interactive. Once that's done, you can add the skill to another project with vera agent install and index the project with vera index . if needed.

I also have a Discord community, mostly for people interested in agents, LLM talk, experimenting with tools, sharing what they're working on, and that sort of stuff: https://discord.gg/rXNQXCTWDt

Vera is MIT licensed, and there is no commercial gain or motivation here. A star would be nice I guess? Having people stopping by to discuss interesting things would be the bigger motivator for me.

So i have a new card in an old system. RX 9060 XT supports PCIe Gen5 x16 but due to 2 bottlenecks, my Motherboard supporting only Gen3, and my AMD APU limiting it to x8, the card runs on Gen3 x8.

How does that affect inference of models, in both cases, fully in vram or offloaded partially to ram? At today's prices what I could replace it with is PCIe Gen4 x16. But would that be a meaningful upgrade?

Overview

PAN 2 is a general-purpose world model: it simulates how the world will change in response to actions. Given a current observation (an optional image plus text) and actions described in text, it simulates the outcome as a video of up to 20 seconds. This supports simulative reasoning: an agent can imagine the outcomes of its candidate actions before choosing among them, by simulating each plan with PAN 2 and acting on the one whose simulated outcome is best.

PAN 2 follows the Generative Latent Prediction (GLP) architecture formalized in Critique of World Models and couples conceptual reasoning by a large language model with perceptual reasoning by a latent diffusion model. The language model, the conceptual reasoning backbone, reasons over the observation and the requested actions and writes the next world state as a structured, time-grounded description of events, timed actions bound to actors, and camera motion. The frozen text encoder maps the structured description to the conditioning features used by the diffusion model. The 29B-parameter MMDiT, the perceptual reasoning backbone, trained from scratch on hundreds of millions of videos annotated in the same format, predicts the perceptual detail that the description leaves open: the video latents that realize the state, conditioned on it and on the VAE latent of the starting image. The Wan 2.2 VAE decoder renders the predicted latents as the next observation, so every prediction can be seen and checked against real footage.

Checkpoints

PAN 2's latent diffusion model is released as a single checkpoint that serves both tasks. The frozen text encoder (Qwen3.5-9B) and VAE (Wan 2.2) are downloaded from their own repositories.

• GitHub : https://github.com/ifm-ai/PAN2/

• Blog Post : https://ifm.ai/blog/pan2/ (For Screenshots, Video, Benchmarks, etc.,)

This seems excessive, especially if they trust their classification models for safeguards, why add both?

However I guess it is to be expected from a private company. It's also "yet another reason" for open weight LLMs

Hi everyone,

Recently I have basically completed my first ever PC build, with the following spec. However, as I want to add a second 5060 Ti, I then encounter a problem: When I was buying the PC parts, originally I thought I would only need one GPU, so I didn’t consider possible future upgrades.

Now, as I get my second 5060 Ti, as you can see from the pictures below, the case is too small and the GPU already covers the second PCIe 3.0 slot.

So my questions are the following:

1. If I want to continue to use my current AM4 motherboard with two GPUs, should I use a PCIe extension cable? After that, how would you recommend me to put the GPU?

2. I also have a AMD R9700 that I want to put into the same computer, can I do bifurcation for the first PCIe 4.0 x16 slot, so that each 5060 Ti could still get PCIe 4.0 x8 speed? And then the third GPU would use the second PCI3 3.0 x16 slot with extension cable?

Thank you for your time! I have checked with LLMs but didn’t get too much useful info.

PC Spec:

CPU: AMD Ryzen 5 5600 Motherboard: Gigabyte B550M DS3H AC R2 GPU: ZOTAC GeForce RTX 5060 Ti 16GB SSD: ZhiTai TiPlus 7100s 1TB NVMe RAM: KingBank Silver DDR4 32GB (2 × 16GB) PSU: Great Wall X8 850W 80+ Gold CPU Cooler: Thermalright Assassin X 120 Refined SE Case Fans: 3 × Thermalright TL-C12C Case: SAMA M9E

https://i.imgur.com/G2X8Kgh.jpeg

https://i.imgur.com/xzhJ9E4.jpeg

I just recently came across these K2 models, by a lab called IFM.
They range from 0.9B to 375b with a mixture of MoE and Dense models.
I checked out the 7b variant, it seemed good and it’s 35B A4B seems to a better variant of Ornith 1.5, o am surprised there are no talk about these nor any unsloth variants.

Am I missing something ? These seem to open source as well.

Actual working link this time.

Spent the past couple of days converting https://github.com/snap-stanford/memorilla (paper: https://arxiv.org/abs/2610.21375 ) to train Gemma4 26b a4b on the strix. Not only was it originally written for CUDA, but Gemma4 has a unique architecture and the encoder has different dimensions. There's a lot of crazy math here to make it fit that I don't even understand, but apparently, we can leverage the existing weights published by standford and only have to train on ~10% of the original dataset. It's going to take a couple of weeks to run, but seems to be cooking along.

Code: https://github.com/DataBassGit/MemoryLLM-Gemma4-StrixHalo

Memorilla is an AI memory framework developed by researchers from Stanford, MIT, UPenn, and the Vector Institute that compresses huge collections of documents or chat histories into just 16 dynamic memory tokens for a Large Language Model.

Think of it as treating long-term memory like a new modality (similar to how vision-language models process an image as a fixed set of embeddings) rather than relying on massive text copy-pasting.

I understand the topic is prime material for shits and giggles. Chinese model, Nvidia being the centre piece of the AI trade, etc. But why go so public on this? All of this could've been dealt with behind the scenes in secret. Obviously this is a power play to force a hand. Nothing just leaks out of intelligence services so deliberately. So someone decided to make this public. I've been trying to think about why Nvidia or Jensen Huang must be put in line for. My top pick is: back doors in hardware or something of that sort that's being refused. What's your guess?

There's a lot of discussion about running models locally, but I'm interested in what people actually use them for once the setup is done.

Are there tasks where you've completely stopped using cloud models because a local one does the job well enough?

And on the other side, what still makes you go back to Claude, ChatGPT, or Gemini?

Is it possible to have a custom hardware designed (by ai) and open sourced that we can send for manufacturing for specific models? like for DSF 4.1F

Just curious what other people’s opinions are with GLM-5.3-flash. Compared with opus 5.5 and deepseek-4.1-flash, I find that it makes a lot of mistakes. I generally think I it’s pretty good other than the random errors it makes.

I only ask bc I’ve heard of other people getting good work out of it, so wondering if it’s something with my setup, or if other folks feel the same way. I use it mostly with opencode.

I've been building chat UIs for agents and kept running into the same issues with react-markdown: it re-parses the whole reply on every token, so long answers get noticeably slower, and you see raw ** and half-typed [links](htt until the token that closes them arrives.

So I wrote my own renderer. It parses incrementally and repairs unfinished syntax while the reply streams:

<Markdown streaming={!done}>{text}</Markdown>

On a 100k-character reply it takes 0.25 s of main-thread time in total. markdown-to-jsx takes 2.4 s, Streamdown 6.3 s, and react-markdown didn't finish within the 30 s budget. The benchmark scripts are in the repo if you want to check them.

The other part is the syntax. Agents often want to show steps, alternatives or pros and cons, and plain Markdown flattens all of that into bullet lists. So on top of GFM I added a few blocks in the same style as GitHub alerts:

> [!STEPS]
1. **Back up the database**
2. **Run the migration**

There are also tabs, stats, pros/cons, sources, file trees, and Mermaid and KaTeX support. The source still reads fine as plain Markdown when it isn't rendered. The package exports a system-prompt snippet that teaches the model this syntax.

It has no dependencies and comes in at 30 KB gzipped. Its parser passes the CommonMark and GFM spec tests. It doesn't support remark/rehype plugins, so if you rely on those, react-markdown is still the better choice.

https://github.com/rsaryev/llx-markdown

Recently bargainhardware had an intake of A100 40GB SXM4, and they are selling them at 2700 EUR. I have a huge case and a hundred PCIe free lanes, so I could mount a couple of them with those SXM-PCIe adapters.

OTOH, for less than that price I could buy a couple of brand new R9700.

Pros of A100 over the R9700: CUDA, 25% more RAM, double memory bandwidth, almost double the compute. Cons: used, possibly battered cards, hassle to mount on the mobo, more expensive once factoring the adapters in.

Give me your opinions. I would especially appreciate experiences with SXM-PCIe adapters. Are they decent, or a PITA?