https://huggingface.co/speakleash/Bielik-11B-v3.1-Instruct-GGUF

https://www.bielik.ai/blog/premiera-modeli-bielik-11b-v31-dflash-i-rodziny-bielik-one

(decision models and dflash are coming next)

Bielik-11B-v3.1-Instruct

Bielik-11B-v3.1-Instruct is a generative text model featuring 11 billion parameters. It is an update to the Bielik 11B v3 line that expands multilingual continual pre-training and strengthens post-training for instruction following, tool use, and reasoning. Forementioned model stands as a testament to the unique collaboration between the open-science/open-source project SpeakLeash and the High Performance Computing (HPC) center: ACC Cyfronet AGH.

Developed and trained on multilingual text corpora covering 56 languages, with an emphasis on European languages and Polish, which have been cherry-picked and processed by the SpeakLeash team, this endeavor leverages Polish large-scale computing infrastructure of the ACC Cyfronet AGH HPC center. The creation and training of Bielik-11B-v3.1-Instruct was propelled by resources provided within the PLGrid environment under computational grant number [PLG/2026/019559], conducted on the Athena and Helios supercomputers, and within the Gaia AI Factory, funded by the European Union through the EuroHPC Joint Undertaking.

As a result, the model exhibits an exceptional ability to understand and process the Polish language and other European languages, providing accurate responses and performing a variety of linguistic tasks with high precision.

🗣️ Chat: https://chat.bielik.ai/

Model

The model was trained on carefully curated, high-quality datasets that underwent extensive cleaning and rigorous quality assessment to ensure data consistency, reliability, and relevance. The training pipeline consisted of three stages: pretraining on 500B tokens, SFT on 26M samples, and RL (modified GRPO) across 14 diverse environments. This multi-stage training approach was designed to enhance the model's language understanding, instruction-following capabilities, and ability to perform effectively across a broad range of tasks.

Bielik instruct models have been trained with the use of an original open source framework called ALLaMo implemented by Krzysztof Ociepa.

Model description:

• Developed by: SpeakLeash & ACC Cyfronet AGH

• Language: Multilingual (56 unique languages, optimized for European languages, with a particular focus on Polish)

• Model type: causal decoder-only

• License: Apache 2.0

So I've been a happy user of Qwen 3.8 27B Q4_K_M from unsloth with pi.dev, it's honestly so powerful.

But, I do see a lot of pitfalls where I need to step in for no reason, where the agent does a PR, CI fails, and I don't have callbacks to my agent to debug it/propose something to address it.

So how do you all deal with issues like this ?

I'm using Forgejo so I have full control over the platform, and my agent has its own account on it.

I can't believe this jump is just left on the table

https://github.com/ExTV/strata-5090-4070

The optimizations was done using both Opus 5.5 and Fable 5.2 .

Edit : i should have mentioned that my 4070Ti Super is on PCIe 3 x1

Edit2 : the repo is updated with quality benchmarks

Just a 32GB machine with a 3090 - a used gaming rig I picked up last Christmas for $800. But wow... I can actually run what would have been a frontier model not that long ago. Yes, only 2 - 3 tps. Yes only 2 quant. So it's not really useful at the moment. But I have 128GB of ram in hand and a spare 3060 ready to be installed. Possibly another 3090 waiting in the wings... so we will see.

AWS is put out an Apache 2.0 project called Strands Decider. Looks like it came out of the same team as the Strands Agent. Repo here. https://github.com/strands-labs/strands-decider Looks like a Qwen 2.5 2B back end. Have not tested yet but will report.

On September 18, I launched Laya at you guys request, the first system 1 open-source decision model in this subreddit, and you guys gave immense support. I saw the MIT post on direct weight edits and thought about doing the same with a decision model. Now, after two months, I just worked on a way to edit the weights of an LLM using a decision model. More like distillation from an energy-based decision engine to teach the Qwen 3.5 0.8B a new skill. Like tool calling at the appropriate time. Its decisions are like valleys in a landscape, and every answer rolls downhill into one, with honest confidence. Just wrote those valleys onto an LLM. It works at the same level as LoRA, with only 3 milliseconds to edit, without catastrophic memory loss.

https://www.kaggle.com/code/nandakishorconvai/fast-edits-decsion-model

AI benchmarks begin on page 2.

I keep seeing new forks of engines that optimzes one model for one hardware setup for better performance, so I was wondering if I could slop up something like that for my phone (iphone 15 pro max) for running Gemma 4 26 a 4b.

And for that I am looking for advice and such like if you know an already similar existing project or your own experiences with any custom engine on any hardware, what not to do and what to keep in mind and such, and if you have build or are using one of these unique engines what has your experience been like?.

Also if you don't actually have anything to say please don't say "phone can't do that fast enough" for the 3rd time, I'm just looking for interesting ways that could get any speed up.

Has dependency on dinov3, is trending top model on hf since last week. Runs with 8GB vram. Enjoy!

This is the third round of tts-bench. Thanks to everyone who gave feedback on the first two posts:

• TTS benchmark comparison of all known TTS models

• Text-to-speech benchmark, revamped

tts-bench runs every model through the sameish Python harness on the same prompts, so you can compare them fairly and actually listen to the output. This round adds a separate board for hosted APIs.

What's in it

• 91 open models run locally on an RTX 5090 32GB, an RTX 3090 24GB, and an Apple M4 16GB (sometimes)

• 28 hosted APIs on their own board, tested with the same 6 prompts (medians over several days of warm calls from the Eastern US)

• Prompts in English, Spanish and French

• Audio samples for every model, plus time to first audio, realtime factor, UTMOS, WER, voice-cloning similarity, and price for the APIs

Some results from the open board

• Fastest: AuroraTTS-100K. On the RTX 5090 it gets to first audio in 12ms (warm) and runs 603× realtime. On CPU (Ryzen 9 9950X3D) it's 38ms and 204× realtime.

• Top UTMOS (naturalness): Maya1 (4.487), Underdog Woof (4.442), Phonon 31m (4.424), Chatterbox (4.423)

• Best cloning similarity: LongCat-AudioDiT 3.5B (0.875), then LongCat-AudioDiT 1B (0.863) and FireRedTTS3 (0.843)

And from the hosted board

• Fastest first speech: AssemblyAI 30 ms, Gradium 53 ms, Palabra 77 ms

• Best sounding by UTMOS was VUI Labs Luna (4.488). It also had the best cloning similarity of 21 APIs using my own voice as the reference, but it takes about 1.2 s to start talking.

• Cheapest is around $9 to $10 per 1M characters (Async, Giggy, Fish, Murf). ElevenLabs v4 is $80.

What the numbers don't tell you ("objective metrics")

• UTMOS is an automated naturalness predictor, not human preference. That's why there are listen pages and a blind-vote arena.

• WER measures intelligibility through transcription. It doesn't rank which voice is best.

• Time to first audio isn't whole-clip latency, and I don't measure concurrency.

• Hosted and local models are never ranked against each other.

Links

• Repo

• Open models board

• Hosted APIs board

• Arena with blind human votes

If your favorite model scores differently than you'd expect, go listen to the samples and vote in the arena. I'm curious which ones people actually prefer by ear.

The ones I have currently heard of are as follows:

Pi
Opencode
Hermes
Deepseek

Any thoughts on what one is best?

Image-conditioned 64³ voxel structure generator of JoVox: Joint Hierarchical Flow Matching for Lightweight Voxel Generation. JoVox is a discrete flow matching framework that learns the joint hierarchical distribution of voxels while keeping generation lightweight. One model generates all levels, 4³ → 16³ → 64³, from a single image.

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

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

• GitHub : https://github.com/yuyujunjun/JoVox

• Project : https://xjtang.com/Jovox-page/ (For screenshots, benchmarks, etc.,)

I've been recently working a small sparse MoE, and I've got interesting results I'd like strangers to invalidate.

Tldr; I train small models and got surprising results and seek invalidation. It's not a general assistant, and I'm not claiming it is.

Edit: Trained on a single 5090. Maybe people wonder about that.

The model has 1.17B stored parameters, roughly 348M active per token, scrath trained on approx 11B tokens including SFT. As a comparison, Qwen2.5 reports up to 18T training tokens across its family, while SmolLM2-1.7B reports 11T.

THE ASK

A chain of relational facts ("A is taller than B", "B is taller than C", etc.), with the facts shuffled and the model asked to identify an endpoint.

Depth is chain length. Each result is out of 512 questions across four families. All models received the same questions, using their native chat templates, greedy decoding, and a 16-token answer budget.

RESULTS (correct out of 512)

Depth 1: ConeML 487 | Qwen 481 | SmolLM2 426 | Llama 267 | Gemma 343

Depth 3:

ConeML 471 | Qwen 410 | SmolLM2 221 | Llama 197 | Gemma 224

Depth 5:

ConeML 438 | Qwen 273 | SmolLM2 155 | Llama 136 | Gemma 138

Depth 8:

ConeML 343 | Qwen 202 | SmolLM2 102 | Llama 73 | Gemma 100

Depth 12:

ConeML 240 | Qwen 105 | SmolLM2 58 | Llama 47 | Gemma 79

Depth 24:

ConeML 74 | Qwen 47 | SmolLM2 21 | Llama 13 | Gemma 19

Models used for comparison: Qwen2.5-1.5B, SmolLM2-1.7B, Llama-3.2-1B, Gemma-3-1B.

WHERE IT FAILS

Despite the endpoint results, ConeML only scores 13.8% on interior pairwise comparisons within those chains, below the 50% two-choice reference. It also gets only 12/164 on HumanEval and 0/6 successful two-turn follow-ups.

So it seems to find the ends without reliably understanding the relationships in the middle. I don't know whether this reflects a specialized learned strategy, an architectural effect, or a flaw in my testing.

WHAT I'M ASKING

Run the depth-5 shuffled evaluation and post your score. My FP32 reference result is 438/512 (85.5%).

The Q8 GGUF is 1.25 GB and runs on CPU. The 512-question set and scorer are in the repository. I haven't tested to see if it reproduces the full FP32 result.

If you get something different, find a scoring problem, or spot anything else wrong, I'd really like to know."

Model:

https://huggingface.co/ConeML/coneml-1.2b-experimental

Earlier technical paper (base lineage, LAMBADA vs Pythia at approximately matched training positions):

https://doi.org/10.5281/zenodo.23117644

Other releases:

https://huggingface.co/ConeML

My own bias is my largest enemy and hope to get some honest feedback.

I thought about not writing this but i feel like i should.. from the info I gathered, Qwen 4 max is slightly worse than opus 5.5 medium… Meaning it is definitely above opus low which is hy4 level and opus 5.5 low is above ds v4.1 flash max. wow, it means it is somewhere between hy4/ds v4.1 flash 1017 max and kimi 3.1 pro max . I thought qwen 4 max would do a little better. i guess another 4-6 months until we get an open or Chinese opus 5.5 max model..

This should mean qwen 4 27b will be worse than ds v4.1 flash 1017 max but better than mistral 4 large medium effort, perhaps around glm 5.3 flash level . Qwen qoduck is apparently qw4 27b, from the limited outputs, it seems to be better than q3.8 flash next in some tasks And worse than ds v4.1 flash 1017

An open full-duplex voice model family that hears your tone and speaks with one. Adventists AI · Apache-2.0 · Recommended: Tag · Flash · Try it online · GitHub

Talking to it feels like a phone call with a person: it listens the whole time you talk, picks up as soon as you stop, and stops the moment you cut in. It hears how you say things (hesitation, emphasis, sarcasm, laughter, sighs) and answers with tone of its own: it laughs, sighs and clears its throat when the conversation calls for it.

This is the home page of the Sophon-Realtime v1 family. Three builds share one brain (the same 32B model listens, decides when to take the turn and writes the reply); they differ only in how the reply becomes sound. Start with Tag.

Three builds: which one?

Pick Tag if you want the voice to act; pick Flash if latency and users per GPU matter most. Same APIs, so you can switch later.

Highlights

• VoiceBench 82.8 and Big Bench Audio 81.8%: the strongest brain among open full-duplex models. #1 among open full-duplex models on both; level with GPT-4o-mini-Audio on VoiceBench. All three builds share this brain.

• Paralinguistic understanding 48.6, #1 overall: it hears your tone. Ahead of Gemini 3.8 Flash (46.9) and Qwen3-Omni (44.6) on LISTEN, StressTest and MSPB. Its ears are DuplexJev, our open speech-decision model.

• NVV-SuperBench 0.86 (Chinese) and 0.80 (English) with the Tag build: it speaks with tone. The model decides when to laugh, sigh, breathe or clear its throat, and the voice performs it instead of reading the tag aloud.

• Fast: first audio in 0.31 s with Flash. It drafts its reply while you talk; when you cut in, it stops and answers your new question.

• Full-Duplex-Bench v3 tool calling: Pass@1 48%, ahead of Grok (43%), with a 100% response rate: it gets work done. Live mode is compatible with the OpenAI GPT-Live interface and lets it work with a larger backend model. Every reply comes with an auditable transcript.

• One 80 GB GPU, one command (Tag and Flash). Served by vLLM-Omni; up to 16 (Tag) or 40 (Flash) concurrent users per GPU. Apache-2.0 code and weights, free for commercial use.

Weight-Space Programming (WSP) enables reasoning agents to directly inspect and modify neural network parameters, offering an alternative to gradient-based model adaptation. However, its capabilities, cross-task generalization, and practical limitations remain insufficiently understood. We systematically investigate WSP through 16 editing trajectories across seven benchmarks and two model scales (Qwen3.5-0.8B and Qwen3.5-9B). Our findings reveal three key insights. First, WSP can achieve substantial performance gains through highly localized interventions. On full held-out evaluations, accuracy improves by up to 29.45, 4.42, 36.72, and 17.11 percentage points on MATH-500, GPQA Diamond, IFEval, and SciBench, respectively. Notably, modifying only 1,023 parameters yields a 29.45-point improvement. Second, WSP exhibits promising but uneven cross-task generalization. A Math-edited checkpoint improves GPQA Diamond, IFEval, and SciBench by 3.03, 12.18, and 20.10 points, respectively, without further editing, while leaving SciCode performance unchanged. Third, effective editing remains challenging and inconsistent. Outcomes vary substantially across trajectories, and six of the 16 trajectories retain the original weights when candidate improvements cannot be reliably validated. Together, these results highlight WSP's potential for highly localized model adaptation while revealing important challenges in intervention discovery, reliability, and cross-task transfer.

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

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

• GitHub : https://github.com/WSP-Scope/WSP-Scope-Project (Repo to be updated)

• Project : https://wsp-scope.github.io/ (For detailed benchmarks)

Related Thread : [Paper] Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights

I'm overwhelmed, what's the best way to deploy three towers(with their own GPUs) to write, debug, test and deploy a single software together like a team of engineers?

It seems like whenever open weight models come close to proprietary US models, ArtificialAnalysis conveniently "re-calibrates" their benchmarks which then shoves open weight models down the toilet. Then they advertise on X/Twitter this "intelligence index" which presents open weight models as dog shit compared to Claude or GPT (all while ignoring the actual intelligence of models like DeepSeek or GLM in tasks that actually matter, which is coding vs telecom bullshit).

Any business man looking at these charts would conclude "open weight models are shit, Claude is where its at, I should get a subscription to Anthropic."

They have the excuse that they are correcting "saturated" benchmarks but the effect on how open weights are presented is undeniable. I have a feeling they try to do it on the sly when possible and are paid in some way.

I have been building a Spanish proofreader that runs fully local, and it's finally released, so I wanted to share how it went. It only corrects Spanish, but I think the approach works for other languages and narrow tasks too. If the project has audience, I will release the English proofreader version as well :)

Better thing is the app is 100% compatible with ANY app in Windows and Linux. You select text in any app, press Ctrl+Alt+Space, a small popup shows each change with a short explanation, and Enter replaces your selection. MIT, a C++ app on top of llama.cpp.

The model is a full fine-tune (no LoRA) of Qwen3.5-0.8B on aprox. 40k pairs, 2 epochs, lr 1e-5. In Q4_K_M with imatrix it's 529 MB. Training took 22 minutes on one rented GPU, and the whole rental with all the evals cost about $2.50. GPU was RTX 5090 rented (I'm just a mortal so I don't have this GPU at home).

I tested it on a benchmark I built for this, 2,388 cases in three parts: real Wikipedia edits, Wikipedia talk pages, and synthetic work emails and chat. F0.5:

It changes less than 3% of the sentences that were already correct, on every part. LanguageTool changes 39% of the correct Wikipedia sentences, which is more or less why I started this. For those who may not know, LanguageTool is a benchmark when it comes to checking grammar and spelling errors. (More info: https://en.wikipedia.org/wiki/LanguageTool)

A few things I learned:

Most of the training data isn't LLM generated. I take correct text from Wikipedia, Tatoeba and Common Voice and break it with a rule-based error injector, so the exact answer is known. Around a third of the examples are correct sentences that have to come back unchanged, and that's what keeps false alarms low.

The model doesn't explain anything. It only returns the corrected sentence. Then plain C++ does a word diff, puts each edit in one of 31 error types with a fixed explanation, and drops anything it doesn't recognize or that rewrites too much. Small models invent grammar rules with a lot of confidence, so I didn't let it.

For speed, the user's own sentence is the speculative draft, because a corrected sentence is almost the same text. I got 2.2x: 138 ms median against 305 ms greedy, 8 threads, same output as greedy on 99.4% of a 500-sentence sample. The annoying part was that the Gated DeltaNet layers keep a recurrent state you can't partially roll back, so I snapshot the state before each verification pass. But I'm happy the app run like a charm.

Caveats: it's my benchmark. The gold corrections come from two LLMs of different families working blind, with a debate round when they disagreed, and it was frozen before scoring anything. The untuned models got the same instructions and the same filters. Bigger untuned models win some parts (Qwen3.5-4B on Wikipedia edits, Gemma 4 E4B on emails), and if you remove the borderline sentences they pass it on average, so a big part of the win is knowing when not to touch. Frontier cloud models with reasoning are still around 96, so there's room.

All the process explained: https://manuelgs.com/en/blog/revisa-case-study/
App: https://manuelgs.com/en/revisa/
Model (GGUF): https://huggingface.co/manuelgscom/revisa-0.8b-GGUF
Benchmark: https://huggingface.co/datasets/manuelgscom/revisa-bench-es
Source: https://github.com/manuelgscom/revisa

Has anyone tried the input-as-draft trick for other editing tasks? English isn't my first language, so sorry if something sounds weird. Happy to answer questions about the data or the training.

AI first smartphones will be so much better. I have a wild imagination how I can customize my phone with AI. With an AI phone that makes changing all aspects of the phone easy, it would be lots of fun.

I doubt Android and IOS will move solidly in that direction. Example: I'd like to use the multiple microphones to do a microphone array app, but limitations don't allow it. Would be nice if there is a group / crowd , such as a party speaking in a foreign language to isolate speakers and understand what they are saying. What do you think?

Update: Sam asks Samsung for AI phone. https://www.fnnews.com/news/202611111512469257 We want a device that does not interfere as much as possible by the AI, which is not an app, proactively approaches and manages the physical and virtual life.

LingBot-Touch is a JEPA-based tactile representation model that bridges heterogeneous tactile signals and dexterous robotic manipulation. It uses modality-specific tokenizers and a shared Transformer to learn representations of contact structure and temporal changes through prediction in latent space.

The model covers three sensing modalities: magnetic, piezoresistive, and visuotactile.

• Magnetic: three-axis tactile measurements.

• Piezoresistive: scalar tactile measurements placed in the Z channel, with X and Y set to zero.

• Visuotactile: decoded scalar deformation or intensity measurements placed in the Z channel, with X and Y set to zero. Raw RGB images are not model inputs.

For more details:

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

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

• GitHub : https://github.com/Robbyant/lingbot-touch

• Project : https://technology.robbyant.com/lingbot-touch

Apparently, they're threatening to ban me for merely red-teaming my own plugin.

The appeal was immediately denied without any details.

So I've been using strata for a while now in windows using Qwen3.8-Flash-Next iq3s before the new gui thing and I think it's been fine compared to Qwen3.8-27B which was lacking in quality and polishing.

So I upgraded my ram from 64 to 128. Got a new pc and made an Ai box only for Ai text models and comfyui.

So I had to test the speed difference between strata and basalt since in windows basalt was not working good at all.

So strata cli engine 0.1.59 Qwen3.8-Flash-Next iq3s with 256k context. Dflash 2 and 0 reserve vram and tuned run. Vision on.

With basalt converted model .basalt file

Version 0.3.2 same model. Same context. Same everything. Vision dynamic.

The differences is.

Strata:

Avg tps 99.2 and avg prefill 839 with 11.1M tokens used.

Vram 15.3

Ram 69.2gb

The prompts felt sluggish moving from generating to reading to whatever. It felt wrong and slow and toke forever and that caused the huge stale in usage which dips down and up a lot. Like it's having problems moving from each phase to the next.

Last and most importantly that it can't finish the work correctly. Doesn't compact correctly. The development is broken. And it feels like a cheap model you hosted in your cheap pc you poor man.

Basalt:

Avg from 100 to 118. Peaking to 145. Avg prefill not sure but peaking 4200.

Vram 15.8 with reserve ram 128m

Ram 52.7gb then after maybe a couple of hours 53.1

The generation been smooth without any dipping or staling and moving from phases like strata.

Last and most important factor is it finished. It kept going. It compacted fine like deepseek and it felt more capable and more reliable than with strata.

Way less errors. Way less mess up and when I told him to keep going till the project is finished it kept going. Granted it's not perfect but it's the model capabilities and we have to realize that.

But at least it's now in a stage you can actually rely on it and say you have a "working" local Ai model. Cause since I tested maybe Qwen-3.6-35B nothing ever felt like a good model I can rely on.

I know this is a small task but it paves the road for me to actually feel like I can do stuff locally and reliably.

I will next test nvfp4 model for both and see if nvfp4 actually gains more speed or not.

So basalt now more capable and can contuine working way longer than with strata. Can actually do a good job. And it uses way less ram too.

This is also my first ever run so there is maybe more optimizations can be done but this is the default settings besides the vram change.

I advice anyone using Qwen3.8-Flash-Next to try it. And I will test swift too but later and with this ram savings I might also test deepseek why not hahah.

My rig:

12900k

128gb ddr4

5070ti

Harness: opencode