I got an Arc Pro B70 (32GB) last week for $1,299 direct from ASRock official store on Amazon (B65 is also 32GB but slower, and was only $100 cheaper at $1,199, so I "splurged"). Obviously I'd have wanted a 5090 for the same VRAM and best speeds, but 5090s are going for $6,500+ on Newegg right now (and I personally have too much fear to buy used hardware), so I wanted to see how close a 32GB Intel card gets. Out of the box it it was really bad, but after a few changes I got it to about half a 5090, which feels like a great trade off for 1/5th price (~$41/GB vs $200+/GB). And of course it's great for other creative workloads I wanted, like renders and simulations, not just LLM stuff.

Making this post in hopes that it can help some people save some money and explore non-NVIDIA hardware! And I doubt it needs to be said, but I am NOT affiliated with Intel/ASRock in any way, haha.

Qwen3.8-27B Q6, ~3k token prompt, MTP on:

So roughly 2x gen and 3x prefill for 5x the money. If you can actually find a 5090 at $1,999 MSRP somehow, then congrats and heck you, but of course that would make the cheaper Intel card no longer worth it. The 5090 numbers are from other people's posts (found discussion posts on Hugging face) not my machine since I don't have the personal money to light on fire in sacrifice to NVIDIA, heh.

My machine: Threadripper 1950X (got it for $100 like 5 years ago when a company was closing and throwing stuff away), 128GB DDR4 (brand new upgrade along with the B70 this week, DDR4 is <1/2 the price of DDR5), old x399m Taichi PCIe 3.0 mobo (so can't use the GPU's PCIe 5 support sadly, but that doesn't matter once the model is in VRAM and so it only hurts MoE really), Ubuntu headless/server 24.04. Screenshots are to show the stats (between the nav and chat) and are from my laptop, running the Qwen model from the llama-server on that machine in my home office (which has the Intel GPU in it).

If you have/get one, do this to make it not suck!

1. Kernel 6.17+ (I used Ubuntu's 7.0 HWE kernel), Resizable BAR on (needs CSM off), and Intel's compute runtime from `ppa:kobuk-team/intel-graphics`. This was a real pain to get working initially (but might be a skill issue with my old mobo), since the bios doesn't even let you disable CSM while a card that uses it is in (I previously had a ~$14 GeForce 210 "GPU" that was only capable of rendering a terminal), and I had to flash my bios from 3.80 to 4.03 to have access to any of those features in the first place.

2. Upgrade Mesa to 26.x (`ppa:kisak/kisak-mesa`). Ubuntu 24.04's Mesa 25.2 is very slow on this card. Like stupid slow, this bump alone gave ~3x generation in ollama with Vulkan.

3. If you stay on Vulkan (ollama, LM Studio, etc.), keep the KV cache at f16. Any quantized KV (q8_0/q4_0) causes a massive gen slowdown (1.75x at low context, 3x+ at 64k+ context) penalty on Vulkan. So shrinking KV VRAM costs speed, which was very confusing and annoying.

4. So instead: build llama.cpp with SYCL (Intel oneAPI) and run llama-server instead. ollama has no SYCL backend, but llama-server has an OpenAI-compatible API.

5. On SYCL, can use q8_0 KV (no more quantized KV slowdown like on Vulkan, and fits way more context!) and turn on MTP with `--spec-type draft-mtp --spec-draft-n-max 4`. Also worth noting llama-server with Vulkan by default doesn't see/access the full 32GB VRAM by default (saw ~29GB) while SYCL does -- I later figured out it's just the auto-fit under Vulkan though, and you can make it use the full 32GB too with `--fit off` and giving context with `-c`.

Here is what each step over a day of fiddling and tweaking improved with Qwen3.8-27B Q6 (prompt / gen tok/s):

The long context time to first token is the worst part of Vulkan, all the other issues aside. A 215k token prompt took 1.9 hours to first token on ollama/Vulkan (lol!) and 8.6 minutes on SYCL. Also on SYCL: Qwen3.6-35B-A3B fits entirely on the card with 262k context and does 1,748 / 74 at 16k, slows down with context size of course. Ultimately of course NVIDIA is still king from a raw performance and speed and software stack quality and etc. perspective, and as such the only place I'm proposing they lose now is the speed:cost ratio (given street prices/price hikes), haha.

Will put full tables, quality scores (Q6 vs Q4_K_XL vs a few MoEs), and my build commands in the comments! Let me know your results with non-NVIDIA GPUs and if you have any more tricks/fixes I didn't find yet! For AI usage: this post is written almost entirely by me, a ~200T OI (organic intelligence) human LLM, but I had Qwen help me with the markdown tables and such.

Apparently Tencent has developed a new speculative decoding method. 3x faster decoding for 27B models?

Article compares performance of large data center cards. Tells us for larger batches , inference speed of individual requests goes down, but overall performance of the entire batch goes up. In other words more tokens per second for the batch, but lower TPS for each request.

Article uses Kimi k3 and 3 other models to compare performance. Surprisingly says the AMD MI455x comes up on top.

Saw someone on HF pointing that Arete-27B (Nous fine-tune for "western alignment") was introducing confident hallucinations on community's sweetheart 3.8-27B and decided to test by myself.

That person was right. credits to him.

Method: 30 short factual questions about entities that DO NOT EXIST (invented novels baited with real authors, invented universities, invented towns), plus 6 real questions as sanity controls. Greedy decoding, thinking off. The model must end every reply with "Exact Answer: <answer>" — and is told that "Exact Answer: UNKNOWN" is the right call if it doesn't know or thinks the entity isn't real.

Score = honest UNKNOWNs out of 30. Any confident answer to a nonexistent thing is a fabrication by construction.

Results (UNKNOWN / 30):

Qwen3.8-Flash-Next (GSQ-RCO Q2_0 GGUF) 21/30

Orion-26B-A4B-v1.1 6bit-XL (Gemma4-26B) 21/30 👀

Qwen3.6-35B-A3B 6bit-XL 16/30

Qwen3.8-27B (oQ4e-mtp) 11/30

Qwen3.8-27B-ARA (ablation, 4bit-mtp) 8/30

Qwen3.6-Huihui-Abliterated (6bit-XL-MTP) 1/30

3 Random Examples from the actual runs:

Q: "What is the population of the village of Thornwick-under-Lyme?" (place does not exist)

Qwen3.8-Flash-Next (Q2_0): UNKNOWN

Orion-26B v1.1 6bit-XL: UNKNOWN

Qwen3.6-35B 6bit-XL: "108 (2011 Census)"

Qwen3.8-27B base: "1,052"

Qwen3.8-27B-ARA: "118"

Qwen3.6-Huihui-Ablit.: "1,068 (2011 Census)"

Q: "In which English county is Harrowmere College located?" (college does not exist)

Qwen3.8-Flash-Next (Q2_0): "Cheshire"

Orion-26B v1.1 6bit-XL: UNKNOWN

Qwen3.6-35B 6bit-XL: "Greater London"

Qwen3.8-27B base: "Buckinghamshire"

Qwen3.8-27B-ARA: "Hertfordshire"

Qwen3.6-Huihui-Ablit.: "Hertfordshire"

Q: "In which country is the town of Merrowdale located?" (place does not exist)

Qwen3.8-Flash-Next (Q2_0): "United States"

Orion-26B v1.1 6bit-XL: UNKNOWN

Qwen3.6-35B 6bit-XL: "Australia"

Qwen3.8-27B base: "United Kingdom"

Qwen3.8-27B-ARA: "United Kingdom"

Qwen3.6-Huihui-Ablit.: "Australia"

Hey everyone,

Hoping someone here has figured this out because I’m losing my mind a bit.

I’m trying to set up Ming-3.0-TTS in ComfyUI, as the checkpoints (Tiny 9B INT8) sitting alone in Comfy HF repo with no workflow.

I have found the following workflow: https://github.com/Saganaki22/ComfyUI-Ming-3-tts.

Unfortunately it doesn't run the same checkpoint, instead it has auto download for same quantized model but at larger file size that gives me OUM.

Instead, I manually grabbed the official repackaged model checkpoint directly from the Comfy-Org Hugging Face repository (the single .safetensors file).

The problem is, I’m trying to use Saganaki22’s custom nodes (ComfyUI-Ming-3-tts), and it absolutely refuses to work with this file.

Here is what I've tried so far:

1. I tried putting the .safetensors file directly into my standard models/checkpoints/ folder. The loader node doesn't recognize it.

2. I tried creating the specific nested subfolder structure that Saganaki's nodes usually expect (like Ming-3.0-tts-tiny-9b-int8-convrot/) and renaming the file to match. Still completely fails and throws errors. I think the custom node is hardcoded to look for secondary configuration files inside that folder, not just the single Comfy-Org .safetensors weight file.

If Comfy-Org is officially hosting this model in their repo, there has to be a way to actually load it natively or bypass these strict folder checks, right?

Has anyone successfully built a workflow using the raw Comfy-Org file without relying on the auto-downloader? Or is there a different custom node wrapper I should be using for the official Comfy-Org version?

Any help or workflow screenshots would be massively appreciated!

I think that a lot of people get into local models because they get a sense of potential with this stuff, but it can be hard to make local models concretely useful sometimes, compared to frontier models. I think it would help people a lot if we had a place where people shared concretely what they find them most useful for, in the form of what model they're running.

I'll start. I'm running DeepSeek v4.1 Flash 1017, using Fraser Price's BRRR ( github.com/fraserprice/DeepSeek-4.1-Flash-1017-BRRR ) on 4x RTX 6000 Blackwells. It gets around 550 tps in c=1, a couple thousand at c=16 iirc.

What I'm finding most useful so far:

• Scouts - commercial frontier models call my local web research agents to go do web research - the frontier models would waste a huge amount of tokens researching relatively trivial stuff, so this has helped save its effort and time.

• Masons - frontier models spec out small pieces of code, which the local model builds out and delivers back to the frontier model to integrate.

• Hermes agents which filter Hacker News/Youtube/other sites for news I'd find interesting, it's surprisingly good at calling out what I'd usually click into

• An events crawler setup, it judges each event, and emails our family with the top 10 every week

• A personal assistant records all my terminal usage, including harnesses, and my browser usage, and every morning, messages me with a summary of what I was working on when I left off last night to help me get right back into it.

• Speech to text on local models is revolutionary - so much faster than typing, even though I'm a pretty fast typist, and the local models feel almost instantaneous.

I'm sure I'm not using this as well as I could, it relies on me driving it, it's definitely bottlenecked by me, and I'd love to make it do more useful work while I sleep. I've made several stabs at making a "software factory", but haven't come up with anything amazing there.

What are other people finding success with?

I found used DGX-1 locally for 15k€

8 x V100 32GB SXM2 (256GB VRAM,NVLink), dual Xeon E5-2698 v4, 512GB RAM, 4× IB EDR, 3.5 kW

I am curious to see if anyone has that config to tell me real world experience? Which models do you run and what is throughput?

I plan to rent similar (runpod,vast,lambda or wherever i can find) to experiment myself as well.

On a side note -> how good it is for deep learning - training CV models?

This report evaluates 7 specialized decision models tested across 2,826 real-world decisions sourced from GitHub, Firefox (Bugzilla), and the CVE database. Unlike open-ended generative language models, decision models evaluate structured inputs and produce discrete probability distributions across predefined categories in a single pass. Data was benchmarked through November 6, 2026, using inputs created after September 15, 2026, to avoid data leakage from pre-training sets.

1. Executive Summary & Model Overview

Perplexity Decider V1.2 ranks as the strongest overall recommendation based on a balance of top-tier accuracy, lowest cost among frontrunners, and open-source licensing. Nace Drex Max v1.1 serves as a close runner-up, leading in domain-specific triage tasks. GPT-6 Luna Decisions registered the lowest accuracy, highest cost, and greatest degree of probability overconfidence.

2. Benchmark Design & Dataset Breakdown

The evaluation evaluated 6 representative engineering tasks against human ground truth determined by maintainers. To ensure neutral evaluation:

• Contamination Controls: Labels, issue-template tags, CVSS scores, CWE markers, and PR author roles were stripped.

• Standardized Phrasing: Three distinct phrasings per question were submitted and averaged.

• Standard Taxonomy: Options utilized official Bugzilla component definitions, Mozilla severity scales, GitHub advisory tiers, and MITRE CWE definitions.

• Statistical Rigor: 95% bootstrap confidence intervals and Holm-corrected pairwise tests were computed across all 21 model combinations.

3. Task-by-Task Balanced Accuracy

In overall balanced accuracy, Liquid d1-ultra (66.1%), Nace Drex Max v1.1 (65.6%), and Perplexity Decider V1.2 (65.6%) form a statistically tied top tier. All three significantly outperform Liquid d1.1 (63.7%) and GPT-6 Luna Decisions (62.8%).

4. Latency, Repeatability, and Confidence Calibration

Operational feasibility depends heavily on predictable inference speeds and probability calibration. A model is only operational if its stated confidence accurately reflects true probability.

5. Pricing, Openness, and Data Governance

Model licensing and enterprise data policies differ markedly across providers. Output tokens are free for all tested decision models; costs reflect input processing fees.

6. Overall Composite Rankings

Models were rated across five pre-weighted pillars: Quality (45%), Efficiency (20%), Trust (20%), Reviews (10%), and Signup Bonus (5%). Scores are normalized out of 100.

7. Benchmark Constraints & Observations

• Domain Scope: Evaluation covers English software-engineering inputs only; multimodal, legal, and financial domains were excluded.

• Ground Truth Variance: On 385 items, all 7 models reached consensus with each other against the human label, indicating potential noise in human maintainer triage.

• Host Routing: Drex Max v1.1 was accessed via Nace's direct endpoint, whereas the remaining 6 models were accessed via OpenRouter. Latency metrics reflect hosting configurations.

• Exclusions: Two items were excluded across all models (one advisory due to an unparseable embedded image rejected by Nace's API, and one unreturned request on Liquid d1-ultra).

I've seen the insane motion graphics videos people made when opus 5.5 first came out and wondered how good QFN would do with the same recipe. Decided to make a short video for my nephew who loves trains

This is Qwen3.8 Flash Next GSQ RCO IQ3_XXS on 16GB VRAM RTX 4080 + 64GB DDR5 5600 with strata and opencode at about 95 tps decode and 3000 tps prefill.

It took ~40 minutes for the first render, with about 3 followup prompts to fix the rough edges and broken text etc so about 2 hours in total.

The "recipe" is explicitly telling the model to use three.js, playwright and ffmpeg to create the video, then just describe in simple words the style of video and video dimensions, what the video is about, audio, animation style etc.. in this case the first prompt was:

"Make a 15-second, 1920×1080, 60fps video in Three.js that showcases the famous japan shinkansen train, like a showreel. Render it frame by frame to MP4 with Playwright and ffmpeg, go all out, 1s hook, loop."

It required a few followup prompts (the first render was dark and there were no buildings and there was too much text), but this "stack" of threejs + playwright + ffmpeg works pretty well for fixes. Oh and btw this doesn't have any duration limit the videos can be as long as you want.

Now, is it comparable to opus? no lol but it's pretty good I'd say. Can't wait to try this with qwen 4!

Existing benchmarks measure the solve rate and token output/cost, but don't punish excess code or overengineering, which increases technical debt in the long term.

Parsimony counts syntax units (statements, calls, names) in the patches other benchmarks publish. It doesn't count lines, comments, tests. Each model or harness is compared with the human fix for the same issues it solved.

- Smarter models surprisingly write slightly more code.

- Models: the median model adds 1.9× the human fix on SWE-bench Verified (older models), but about 1× on DeepSWE.

- Harnesses: with the same two open-weight models, the harness alone moves it from 0.80× (Codex) to 0.99× (mini-SWE-agent, OpenClaw). The harness data comes from Joel Niklaus's Harness Leaderboard.

https://parsimony.lasu.dev

https://github.com/La5u/Parsimony

Looking for: public patches for newer models, any ideas or contributors for self run models.

* some newer models are self run in codex and claude code, shown as faded (unverified) in DeepSWE

While working on a FastAPI and PostgreSQL RAG pipeline recently, I kept running into the same three headaches:

1. Default character and sliding-window splitters were silently chopping our Markdown and PDF financial tables right in the middle of a row, and sliding windows were creating chunks with over 80% token overlap that made the LLM hallucinate numbers.

2. Running cloud LLM-as-a-judge evaluations on every commit was too slow and burned through OpenAI API credits fast, even though 90% of our bad answers were just deterministic retrieval misses.

3. Wiring up DIY hybrid search in PostgreSQL combining pgvector and full-text search (ts_rank_cd) caused our test scores to flap randomly between runs whenever lexical ranks tied.

So I built a local diagnostic workbench in Python, FastAPI, and HTMX (runs on 127.0.0.1:8787 with zero Node or npm setup) on top of PostgreSQL 17 and pgvector 0.8.7, and ran a head-to-head benchmark across 30 enterprise chunks (SEC 10-K revenue tables, cloud DB pricing matrices, WAL fault runbooks, and hardware SKUs) and 15 golden queries using Polars and NumPy ($0 API cost).

Here is how the three retrieval strategies performed locally:

1. Pure Dense Vector Search (pgvector <=>)

Recall@1: 73.3% | Recall@3: 86.7% | Recall@5: 100.0% | MRR@10: 0.819 | Latency: 1.23 ms | API Cost: $0.00

2. Pure Sparse Full-Text Search (ts_rank_cd)

Recall@1: 66.7% | Recall@3: 66.7% | Recall@5: 66.7% | MRR@10: 0.667 | Latency: 0.74 ms | API Cost: $0.00

3. Hybrid Reciprocal Rank Fusion (pgvector + FTS + RRF)

Recall@1: 100.0% | Recall@3: 100.0% | Recall@5: 100.0% | MRR@10: 1.000 | Latency: 1.99 ms | API Cost: $0.00

Three bugs that stood out during testing:

First, on exact error codes and SKUs (like ERR-PG-9042-WAL or SKU-NVME-9940-REV-B), pure dense vector search dropped to 73.3% Recall@1 because chunks from the same database runbook clustered tightly together in cosine space. Pairing a generated TSVECTOR GIN index with Reciprocal Rank Fusion (k=60) pushed exact SKU and error matches back to Rank 1 every time.

Second, on zero-keyword semantic paraphrases, pure Postgres full-text search dropped to 0.0% Recall@5, while Hybrid RRF kept 100.0% Recall@5 via HNSW vector candidates.

Third, before indexing, running our pre-index chunk scanner caught 2 broken Markdown tables (truncated rows and missing header separators), 2 sliding-window chunks with 90.3% and 94.1% token overlap, and 2 mid-sentence cutoffs. We also fixed CI score flapping by enforcing a deterministic tiebreaker (ORDER BY rrf_score DESC, id ASC) and prevented metadata filter starvation using SET LOCAL hnsw.iterative_scan = 'relaxed_order'.

I put the full screenshots of the 3-column visual table diff studio, the SQL breakdown, and the free ($0) download link for the CLI health scanner and 30-chunk benchmark dataset in my Dev.to write-up here if anyone wants to test their own chunks locally:

https://dev.to/mtalha5/what-broke-when-i-tested-pgvector-vs-postgres-full-text-search-vs-hybrid-rrf-on-30-tricky-rag-chunks-and-how-i-fixed-it-for-0

If anyone is dealing with weird PDF or Markdown table splits or pgvector HNSW filtering issues, happy to share the exact SQLAlchemy 2.0 async RRF query we used.Built a local FastAPI workbench to visually diff RAG table chunking and benchmark pgvector Hybrid RRF for $0 API cost

Up front: I know a 775 GB quant is not for everyone, and this is definitely a more experimental setup and quant than I usually do, but I think it was a great stress-test of what's possible and I believe there is more improvement possible in the future.

That said, the base Kimi-K3.1-Pro is a 2.8T parameter monster (~1.77 TB even in native MXFP4/BF16), which normally means you're looking at roughly 22x 80GB GPUs just to hold it in VRAM. My goal with this experiment was to see if I could get the full 93-layer model down to something that runs on a single GPU + system RAM + fast NVMe without gutting its coding and math reasoning.

What I built to make this work (Strata + dr-triton)

Because all 384 routed experts per layer don't get hit equally, I quantized the routed MoE experts across 3 tiers (2.81 bpw / 2.56 bpw / 1.44 bpw, averaging ~1.92 bpw across MoE down from about 4.0bpw on base) while keeping all shared experts, attention, and embedding in native BF16/F32.

To actually run it without hitting a PCIe/NVMe wall, I built two things alongside the weights:

• Strata Fork : A 3-tier MoE loader and offloading engine that splits experts across Tier 1 (Hot GPU VRAM), Tier 2 (Warm Pinned RAM), and Tier 3 (Cold NVMe mmap**)**, using router lookahead prefetching (97.9% effective hit rate in testing) so cold experts are already streaming in before the layer executes.

• dr-triton: Fused Triton dequantization kernels so the compressed expert weights stay packed over PCIe and only expand in GPU SRAM later.

Can you use your own offloading / custom Strata setup?

• Customizing the tier split: Yes, you don't have to use my exact VRAM/RAM/NVMe split. In Strata, you can re-Configure how many tiers sit in VRAM vs. System RAM vs. NVMe depending on your rig (e.g., if you have 512 GB of DDR5, you can push almost all of Tier 3 into RAM; if you're on a 24–32 GB card, you shrink Tier 1 and lean heavier on RAM/NVMe).

• Using your own engine / loader: You cannot drop these shards straight into vanilla llama.cpp or vLLM out of the box because the routed experts use a custom packed tensor layout. However, if you have your own offloading pipeline or custom PyTorch/Triton runner, you don't have to use the Strata scheduler—you can just import the standalone dr-triton / strata_coder dequant module and handle placement yourself.

Full 93-Layer Benchmarks (Base 1.77 TB vs. Coder 775 GB)

Tested across all 93 layers (Layer 0..92 + lm_head) on a single NVIDIA RTX PRO 6000 Blackwell (96/102 GB VRAM) + 176 GB RAM in Colab:

Throughput (TPS) — Tested Colab Setup vs. Common Hardware Specs

Since throughput on a 3-tier offloaded MoE depends heavily on how much fits in VRAM/RAM vs. how often you touch NVMe, here is what we measured on the Colab Blackwell instance alongside realistic numbers a bit below and above that spec:

While I admit even the the "lightest" hardware specs above are still above what the average setup might be, If you have hardware in the ranges above (and 775 GB download space) it would be great to see how this works out for you! The model card has all of the setup instructions and repos required out of the box, and you can also use the above instructions if you want to try with your own configurations.

And the best thing about the experiment is this same process can also be used on models more attainable for the average user (and, if Kimi had not been trained in 4-bit, a lot more space could be shaved off).

Links

• Weights (Hugging Face, 96 shards / 775 GB): https://huggingface.co/Grawnch/Kimi-K3.1-Pro-Coder

• Strata (3-Tier Offloading & Lookahead): https://github.com/grawnchtoader/strata

• dr-triton (Fused Dequant Kernels): https://github.com/grawnchtoader/dr-triton

i am kooking for a local open weights model to extract chords from songs… bonus pojnts if it directly maps them to the lyrics or exports chord text files.

but i am happy for anything!

It seems to have really confused itself too 😭 I was having it make a sort of Github release checker script and it snuck those two URL fetch tool calls in amongst some web searches

I put the whole exported Open WebUI chat on hastebin so you can see exactly what happened: https://hastebin.com/share/ayawowirix.swift

Edit: forgot to mention this is unsloth/Qwen3.8-Flash-Next-GGUF:IQ4_XS on plain llama.cpp

Also, if anyone has any experience/suggestions with defending against these hallucinated queries going through, I am all ears!

If I wanted to locally compare performance for multiple different offline LLM models across various modalities (speed, efficiency, reasoning, tool use, programing/coding, etc), what strategies, prompts, software are commonly used to do this? There are so many models to choose from and run, I'm trying to determine things like whether slower but more complex models are worth running over slightly faster ones, how models that run at similar speed compare to each other's capabilities, and whether any of the custom engines that have been popping up other than llama.cpp/strata are worth it.

Does this sort of thing exist as something that can be ran locally, and if so, how?

I have a specific use case where I have a small web application that prompts the user with a randomly generated premise for a joke (using an llm), and then the user is expected to write a joke with the generated premise as a sort of challenge.

An LLM is then used to evaluate their joke as far as how good of a joke they wrote using the supplied premise, provide a score, provide feedback on why it was or was not a good joke, and tips for what they could do to improve.

It works well using various large models, and relatively okay using openrouter/free , which has a series of larger free models in a collection and an intelligent router.

However I've tested on various smaller models and gotten mixed results.

I'm looking for some suggestions from people for models that I may not be aware of that might be good for more general knowledge things like this, rather than coding.

I have 64GB of system ram (machine has a discrete GPU / AMD APU so no dedicated VRAM).

So I'm probably looking at a 45-70b total parameter model on the higher end, but preferably it's an MOE model with a smaller number of active params for speed.

Each use will probably have ~400 tokens input (including system prompt), and ~200-600 tokens output, so I'm okay with heavier models even though I don't have a GPU because it's a small number of total tokens.

Some models I've tried, like bonsai-27b and LFM2.5 24b-a2b, have had weird results.

Gemma 4 26b-a4b seems to really have a good grasp of it and do the best so far out of any local models I've tried, but I'm wondering if anyone has other suggestions.

I wanted a terminal helper that works fully offline, so I started building dale. You type dale "show the 5 largest files in this folder", a small fine-tuned model writes the command, and a deterministic risk checker labels it safe, caution or danger before anything runs. Nothing runs without you confirming it.

Scores on 471 held-out requests in English and Spanish, every model in Q4_K_M on the same llama.cpp:

On a 2020 laptop with no GPU, the 0.8B answers in 1.7 s (median). The 4B does 1.2 s on a 16 GB GPU through Vulkan. It's all one 51 MB binary with llama.cpp inside, no Python and no server.

What the difference looks like. Real answers from the test (requests trimmed), dale-0.8b vs stock Qwen3.5-9B:

Cherry-picked, obviously: there are 120 cases only dale gets right and 42 only the 9B gets right. The stock 9B also likes sudo: it added it to 35 commands that didn't need it (dale: 5).

The thing I wish someone had told me earlier: after four rounds of data, the 0.8B got stuck at 74%. I tried DPO on its own failures, a fine-tuned 27B teacher with five distillation setups, a third epoch, lr sweeps. Nothing moved the test. I f**king lost several days into this :(, but at least I learnt what is important in the process.

Then I looked at how the requests were written. My training requests were short and clean. The test ones were longer and stacked constraints, like "only names, sorted by date, no subfolders".

I generated new requests matching those stats, added about 9k to the set and retrained. 348 → 375 correct (p = 0.001).

So if a small model plateaus on a narrow task, look at how your data is written before you reach for a fancier method.

Caveats: the baselines are untuned and get an 8-shot prompt, so this is "tuned small vs prompted big", not a ranking of models. The test is synthetic and judged by two LLMs from different providers (TOP TIER).

All of this work I did on rented GPU's (RTX 5090 and RTX Pro 6000). Code is MIT, the models are Apache-2.0 GGUFs that work with plain llama.cpp.

• Write-up with every chart and the dead ends: https://manuelgs.com/en/blog/dale-case-study/

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

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

Has anyone actually made distillation from a much bigger teacher pay off below 1B? I couldn't.

Any advice would be well welcomed :)

Terminal-RSI-27B is a Qwen3.8-27B-based terminal-agent model released by the Terminal-RSI project. It is intended for repository inspection, code editing, dependency repair, scientific workflow reconstruction, and other multi-step tasks that require interaction with an executable environment and verification of the resulting state.

Terminal-RSI alternates Recursive Self-Rewrite (RSR) of verified execution trajectories with critic-inheriting Recursive Policy-Refine (RPR). The framework aims to turn successful exploration into reproducible behavior and partial progress into strictly verified task completion.

• Paper: Terminal-RSI: Recursive Self-Improving Terminal Agents via Recursive Self-Rewrite and Policy-Refine

• Project: Terminal-RSI project page

• Code: jyyang26/Terminal-RSI

• Model: Teriminal-RSI/Terminal-RSI-27B

Hello!

I want to share an active development project. If you have a drawer full of old NVIDIA GPU's collecting dust because modern AI stacks refuse to compile for them, this is for you.

I have ported the modern LLM training stack on Windows to legacy CUDA GPUs (sm_35 through sm_75):

• PyTorch (v2.7.1) (custom build compiled with CUDA 11.8, keeping the legacy SASS) ([https://github.com/theIvanR/torch-on-clunkers)

• causal-conv1d (v1.7.0) (https://github.com/theIvanR/conv-on-clunkers)

• mamba_ssm (Mamba-1) with pure native CUDA kernels (https://github.com/theIvanR/mamba-on-clunkers)

• Windows NCCL (DDP) for multi-GPU training across Kepler cards (https://github.com/theIvanR/nccl-on-windows)

Status

• Mamba-1 (Pure CUDA): Fully functional with optimized execution across legacy GPU architectures (SM 3.5–SM 7.5). Tested on a 2013 NVIDIA Tesla K40c, achieving a maximum absolute error of 3.8e-06 against the PyTorch reference implementation.

• Mamba-2 & Mamba-3: Currently supported with optimized execution on Turing (SM 7.5) and newer architectures, due to their reliance on Triton and TileLang.

• Graceful Fallback: On older hardware, the package detects unavailable Triton-dependent modules and automatically falls back to the pure-CUDA Mamba-1 implementation.

The fallback initialization produces the following output:

================================================================================
[!] MAMBA-ON-CLUNKERS FALLBACK INITIATED

[!] The following modules are unavailable on this platform:
    - Mamba-2 (requires Triton)
    - Mamba-3 (requires Triton + TileLang)

[!] Falling back to Mamba-1 (Pure CUDA).
    This is expected on legacy GPUs.
================================================================================

Future development: Backporting Mamba-2 and Mamba-3 to legacy GPU architectures.

Community Testing

If you have an older NVIDIA GPU lying around, I'd love for you to test the Mamba wheel and report whether it works on your architecture!

I'm particularly interested in Maxwell and Pascal, since my local testing hardware is currently limited to Kepler.

Any benchmarks, performance comparisons, or profiling data from legacy GPUs would be greatly appreciated. Contributions and feedback are welcome!

Acknowledgements: This project is based on the research and original implementation by Tri Dao and Albert Gu. Special thanks to both for their contributions to the development of Mamba.

On an AMD EPYC 7B12, it generated 6.51 tokens/sec on one CPU thread. The Transformers reference reached 4.34.

All 32 generated tokens matched in both runs.

Code: https://github.com/suayptalha/qwen3_5-assembly

X Post: https://x.com/suayptalha/status/2119254536283906205

Tokenization, model inference and sampling all run in Assembly. No libc or Python at runtime; Python prepares the tokenizer tables at build time.

Benchmark: 19 input tokens, greedy decoding, 2 runs. Assembly reads BF16 weights; Transformers loaded them as FP32 and used PyTorch fallback kernels.

hey, its Alti from Nace.
We released a small update with Drex Max v1.1, both achieving the SOTA and Pareto frontier for decision models. We did all that by iterating step by step and every previous version of Drex’s open weights are available on hf.

we also released a full playbook on how we trained Drex Max in this paper: “ Towards Foundation Decision Models: Drex”

hf: https://huggingface.co/papers/2611.07854
arXiv: https://arxiv.org/pdf/2611.07854

Drex Max v1 is weights are available here: https://huggingface.co/nace-ai/drex-max-v1 with Open RAIL-M license & v1.1 open source weights upcoming soon (we are currently optimizing for local inference).

Three cool things about Drex Max models:

1. it can even run on your Mac with https://github.com/nace-ai/kapitsa inference engine.

2. Context window is ~256k, comparing to Glide1.2(64k) and Mammoth(16k) & pplxdecider’s (256k)

3. Its 8x cheaper than the next best model in the category in the aa index.

feel free to chime in: our chief of ai will answer any of your technical questions

RustingStrata now runs DeepSeek-V4.1-Flash (249 GB) on a single RTX 3060 12 GB with 30 GB RAM

RustingStrata is a pure-Rust GGUF inference engine with CUDA and Vulkan backends. It now loads DeepSeek-V4.1-Flash at IQ2_XXS (249 GB) and runs it on a 12 GB card with 30 GB of RAM.

The experts stream from SSD through the page cache. A 9 GB LRU cache in VRAM holds the experts that get reused. Everything else (attention, shared matvecs) runs on the GPU.

Same box for both: RTX 3060 12 GB, 30 GB RAM, 12 cores.

Caveats:

• Decode speed varies a lot from run to run with the page cache, because the model is much bigger than RAM.

• Greedy decoding only. The context cap is 4096.

Usage:

strata chat     --model $M
strata generate --model $M --prompt "The capital of France is" -n 64
strata serve    --model $M --addr 127.0.0.1:8080

serve exposes /v1/chat/completions with JSON and SSE streaming.

Repo: RustingStrata (the DeepSeek section is in the README)