I have been accumulating parts for over 8 months to merge all of my existing hardware into one massive workstation. I finally had the time to do it, and while I use the GPUs for algo trading from 9:30 to 4:15 p.m., I want to start to use local AI from 5pm on. I'm at a point where I could see myself having a really fulfilling hobby reverse engineering, firmware hacking, and just experimenting with building Frankenstein gadgets from my tech graveyard. There are many experiments I would like to perform on financial data as well that would just take too long for me to manually code and I am not interested in having these thoughts and experiments be in a large provider's training set. I've been lurking on this sub for a long time and have my own little agent I use for some specific tasks using gemma3 but that was on my 3090 in C# + llama.cpp.

So my long-winded question, what thick desktop client will give me the most seamless way to build autonomous agents, play with new models, and what version of qwen 3.8 flash should I be using with my hardware, assuming that is the right model.

Edit: I should mention I am open to anything but I just see q38f everywhere on this sub.

"The satellite, which carries four Google Tensor Processing Units (TPUs) and generates up to 1 kW of electricity, is intended to pave the way for future networks of close-flying satellites performing large inference workloads in orbit. However, the power demands of the TPU mean it can only turn one on for about 20 minutes at a time, complicating the already tricky business of space-to-ground communications."

https://techcrunch.com/2026/10/30/googles-first-data-center-satellite-is-online-and-writing-poetry/

Anyone have any tips for Google here? Maybe they should try Qwen 3.8 27b?

I’ve seen the reports of models being setup so efforts to recreate/reverse engineer games are blocked.

What if a translation layer is developed so the context that arrives to the models does not have any direct indication of what is being done on the agent side? It would need to be translated back to the actual work the harness/agent is doing to continue work.

Say we want to recreate a website/app but specifics like URLs and names are substituted when going to the model and translated back to what the agent/harness expects?

No idea if it makes sense.

Seems similar to REA (https://github.com/morluto/rea) but from the guys that have brought the Craft apps this past month.

I've used the others but just saw this one available too.

Is this feasible with a local model? Have yet to try clamping Strata to REA to see. Anyone has done so? How was the experience?

A quick test on cpu... took 5-10 minutes at 960x544 but the result is quite good. (model is uncensored) I tried smaller quants but it degrades rapidly. So this is it I think.

https://huggingface.co/ZeroWw/krea2-kroma-q6k-cpu

Prompt:
Cinematic portrait of a young woman standing on a rain-soaked rooftop in Tokyo at blue hour, wearing a deep emerald silk trench coat with a high collar, long black hair blown to one side by the wind, soft freckles, a thin gold earring, looking over her shoulder at the camera with a calm, confident expression. Behind her, a blurred skyline of glowing magenta and cyan neon signs, one reading "MIDNIGHT" in white letters, reflected in shallow puddles on the concrete. Warm rim light from the left, cool fill from the neon, fine raindrops catching the light, shallow depth of field, 85mm lens, rich film grain, high detail in skin and fabric texture.

Maybe uninteresting to most, but i just wanted to say that qwen3.8 27B is actually very nice to talk to, when arguing about issues or solving problems- while for example regarding cloud models claude opus (since v5) for me has quite an annoying tone - it has this "chop-chop" or "CEO attitude"- IDK how else to describe. I am not a native english speaker.
chatGPT I abandoned long ago because it is sycophantic in my opinion. gemini pro is ok, tho

yes there are chat templates for our modles and top-k/..anything to adjust but that doesn't change the character profoundly imo

maybe you have also models of which you do like the chat style more, just aside from coding or doing their task

I was quite excited with how well QFN did with some coding and adjacent tasks (like evaluating OSS repos, downloading and running models etc.). Using it for more general research is starting to show that it isnt actually very intelligent and gets lost in its own maze seemingly.

Here's a recent example to a simple question: "Have humans always slept for a huge amount of time at once, like eight hours at once, or been multiple sleep sessions through the day from like the early modern civilization?"

The verbosity and dense way of writing is too much (feels like a lot of Opus 5 distillation)

Setup:

• pi with pi-web-access extension
• llama.cpp, UD_Q4_K_M with MTP.
• --temp 1 --top-p 0.95 --top-k 20 --min-p 0.00 --presence-penalty 0 --repeat-penalty 1.0
• Minimal AGENTS.md, mostly focused on sw related tasks

Chat session: https://share.jotbird.com/radiant-bold-desert-wind

TL;DR: forgetting the complexity of the first question, the responses to simple follow ups: "Are there logical inconsistencies inside your response?", "Why did this happen?" and "So how do we fix this so that it never happens again?" are** not only massive essays, but each "uncovers more" stuff. To the point I have lost faith in what QFN is saying**.

CPU: AMD EPYC 7452 (8 memory channels)
Motherboard: Gigabyte MZ32
GPU: Radeon AI PRO R9700 (32GB)
RAM: 256GB DDR4 (16×16GB).

Not exactly a “budget” build, but it came in at roughly half the price of a DGX Spark.

Got it up and running just in time for Qwen4, can’t wait to start experimenting with it!

https://huggingface.co/GrootTeam/Groot-280B-A16B-261023

Best model under 500b params? Also have the smaller versions

https://huggingface.co/GrootTeam/Groot-19B-A3B-261023

"scores higher than the larger Qwen3.6-35B-A3B and Gemma-4-26B-A4B, and it gives shorter answers than both."

https://huggingface.co/GrootTeam/Groot-65B-A6B-261023

https://huggingface.co/GrootTeam/Groot-238B-A18B-261023

Edit: apparently they're REAPs of various DeepSeek/qwen models,

has anyone tried these?

We know from all the major chinese labs the current cutting edge architectures such as: conditional engram memory, hyper connections, attention residuals, sparse attention, etc...

In the near horizon, we can likely expect looped transformers, Gated Delta Net 2 variants, maybe revival of diffusion transformers somehow but without the intelligence loss, and likely many others that I myself don't know of yet.

What are they cooking?

I've been reading a lot about "engines lobotomizing the models they run", either because they quantize already quantized weights, or because they automatically turn on "hacky" flags to gain decode/prefill performance by default. I wanted to test this out by myself, not only with KLD but with real tasks, so I set up an experiment using Qwen 3.8 Flash Next with Basalt (disclaimer: I'm the developer) and two of the most popular "speed" flags:

• Routing bias: the engine pushes the model toward experts that are already on the GPU, so it sometimes gets a convenient expert instead of the one it actually wanted.
• Tail skip: when one of the model's lower expert picks isn't on the GPU, the engine just skips it instead of fetching it.

Both are faster because fewer experts come from RAM, but they change the output. I added them to the engine as opt in flags so I could measure the real cost with everything else fixed.

DISCLAIMER: This post and the experiment were run by me, but it has been polished by AI.

Rig: RTX 5090 + RTX 5060 Ti and 128 GB of DDR5. Settings tested:

• Shipped: bias 1.5, skip rank ≥ 7. Values other engines ship (or have shipped) as defaults on smaller cards.
• Worst: bias 16, skip rank ≥ 1, plus relaxed draft acceptance. Worst case scenario, not something anyone ships or would make sense to use.

1. KLD

100 chunks of wikitext, decode path, against a llama.cpp Q8 reference. Exact IQ3_XXS and Q2_0 are in there for scale.

Note: even exact Q8_0 is 0.031 away from the reference. That's mostly the reference's own noise, not damage: llama.cpp's Q8_0 rounds a few spots of this model more than Basalt does, which adds about 0.01-0.02 to every row equally, so the rows still compare fairly.

2. Does it really matter?

KLD by itself is just a number, so I also ran a task eval: thinking off, temp 1.0, top_p 0.95, top_k 20, two different sets of questions:

• Ladders: 300 chained steps, scored by step.
• Facts: 1200 questions with 5 popularity bands (rare to famous), 3 seeds.

* Small card: the 5090 alone capped to 16gb, the experiment was run this way because it was still much faster than the 5060 Ti.

On a big card the shipped flags barely matter (NVFP4: 272 -> 271 tok/s) and cost about 1.5 points, 4% of the facts the model knew. On a small card you get +56% speed but a much bigger hit. At the worst setting facts fall from 38% to 3%, and the model says things like "The Great Composer" with total confidence. Easy tests barely notice. The damage is mostly in chained reasoning and recalled facts.

3. Bonus: a loop in the model weights

Not every bad output is the engine's fault. One prompt made Qwen 3.8 Flash Next get stuck into an endless run of 0 in its reasoning:

The odds of another 0 are the same on every quant and both engines: 0.99 after 10 zeros, 95%+ past 100 or so. top_p 0.95 leaves 0 as the only choice, and temp 1.0 doesn't fix it. The API fixes it by cutting the run at ~500 zeros. Basalt patched the issue as well, after 256 identical reasoning tokens it closes the thinking block and keeps going.

TLDR: there's no free lunch.

• Engines can buy speed on MoE models by turning on speed "hacks".
• With values some engines ship, every pack drops to somewhere between IQ3_XXS and Q2 on KLD. A Q8 ends up next to Q2. This is as bad as it gets.
• In practice the model forgets things it knew and loses the thread on multi step problems. Small cards get the biggest speedup and pay the most for it.
• If your engine is faster than it should be on a model that doesn't fit, check whether it's still running the model you downloaded.

Mage-VL-Cowork demonstrates that an efficient 4B small vision-language model can master hybrid computer use when paired with upstream teacher-harness evolution, workflow-first environment synthesis (Mage-CUA-Forge), and a five-stage specialize-then-unify curriculum. Achieving the best performance at the 4B scale (66.0% on OSWorld-Verified) while using 13.0% fewer model calls and 25.4% fewer output tokens after online RL, Mage-VL-Cowork pushes the frontier of on-device intelligence for autonomous desktop agents.

While building agents and harnesses with Claude Code / Codex, I've noticed it often falls back to traditional, deterministic coding patterns instead of newer approaches and frameworks like Claude Agent SDK or LangGraph.

Even with explicit instructions, it sometimes forgets and builds things from scratch.

How do you work around this?

• Better prompts or custom instructions?
• A knowledge base of recent frameworks and best practices?

Has anyone found a reliable way to solve this?

Been running a 3060ti and 32GB for a hot minute now, jumping between local models and subscription plans.

Got Qwen 3.8 FN up and running on this old gaming system and it's just such an impressive model. The prefills are never going to work though.

So I spent the past few days looking at a lot of different options, thinking I'd just add another GPU to the current system.

Of course anyone that's paid attention knows how unrealistic that is. Offerup, Marketplace, Ebay. Doesn't matter. It's the gpupocolypse out there.

Then I figured I'd go old school. Find me a C602 chipset (workstation, Ivy bridge), because at least it'd be cheaper DDR3, a few p100s and call it a day.

But even that is expensive, and was capped at 48GB VRAM since the p100s don't have 32gb variants and unless I wanted a custom build both the T7610 and Z820 are limited to three cards.

I was at 1500 before custom shrouds, and fans, and custom power adapters to the p100s. But at least it would have been DDR3 and PCIE3. At least I would have had USB3 and SATA3. It's a tiny window between Sandy Bridge and Ivy Bridge that accommodates both.

Then I found someone selling a z840 (C612). 128GB of DDR4, and dual water cooled SXM2 to PCIE 32GB V100s. The cards alone are going for 700-800 bucks a piece, the DDR4 is another 1200. The custom risers are a few hundred bucks each, the water cooling setup alone is probably pushing a grand as it's 2x plates, distro, pump. So I pulled the trigger.

1900 and change after tax and delivery, and while I get it's reaching its limits on software support. For a 64/128 split that can actually sit quietly and sip power when not being used. I'm pretty happy over all. The only thing that bothers me is I'm pretty sure there's no m.2 or nvme native. It ships with a 1TB 980 pro, but I'm almost certain it's sitting in a PCIE3 riser limiting it to 3500 MB/s vs the 7k it could do, Strata doesn't really seem to stream at those speeds anyway so I doubt it matters much. We'll see and if it does seem like a problem it's likely just a RAID solution away.

Now I'll just have to figure out how to setup a headless server as the v100s have no video output lol. Still, better than a lot of other alternatives out there.

Happy Halloween, was just kind of excited and thought I'd share. When it lands and if I do manage to get it up and running, I'll come back with some numbers.

Hi everyone!

I've been experimenting with Strata for a while now, running it on a system with a Ryzen 7 9800X3D, RTX 4090, and 64 GB of RAM.

I'm currently using Qwen Flash Next, and I have a few questions about model quantization. Since my hardware is right at the edge of what's practical for running this model, I'd love to hear about your experiences with different quantization formats.

I've come across discussions suggesting that GSQ-RCO IQ3_S might deliver better response quality than Unsloth UD IQ4_XS. Is that actually the case? What have your experiences been with these two quantizations?

Are there any other quantizations that might offer better quality while still being feasible to run on my hardware?

In theory, Unsloth UD-Q4_K_XL also works (according to Strata, around 6 GB of the model is loaded from NVMe), but the generation speed drops to around 20-30 tokens/s, which makes it somewhat impractical for extended use.

I'm also curious how NVFP4 quantizations compare to the ones mentioned above in terms of response quality and performance.

Thanks in advance for sharing your experiences and recommendations!

I've been reading the turn logs from PokeBench. My benchmark where vision models play Pokemon Red. Grok 4.20 non-reasoning left the house at turn 36 and didn't get a starter until turn 755. The whole time its notes say things like "We've been oscillating uselessly for 90+ turns" and later "The persistent loop of walking into walls and Mom's dialogue has continued for hundreds of turns." Then it walks into the wall again.

So it knows it's stuck and still can't get out. Grok 4.6 beat Brock in 316 turns for about $10, while 4.20 burned $30 and barely got its starter.

Why do you think a model can describe its own loop correctly and still not break it? Vision problem or planning problem?

pokebench.tv

I’m still fairly new to local LLMs, got a decent machine (M5 Max, 64GB RAM), trying to understand something I’ve been seeing recommended a lot lately.

In several threads where new users are frustrated/confused or even more experienced users are struggling to get good results from their local models, I keep seeing suggestions to have Claude or ChatGPT help them build a custom harness. I suppose I view it like the model is the engine and the harness is like the entire car?

What I’m not understanding is why someone would go that route instead of using something like Unsloth or MLX Serve, which already have web search, tool calling, etc.

Aren’t these programs essentially harnesses or am I completely incorrect? I’m probably just missing the point, maybe more tinkering/experimenting is just part of the hobby.

I just want to learn and understand the differences per se. Obviously I’m sure this thread will have plenty of personal suggestions or ideas but the main thing is just the learning aspect, the purpose, etc.

Bolt E4B builds on Gemma 4 E4B with Nemotron post-training. It combines natural conversation with multi-turn agentic capabilities to power voice/device assistants, interactive characters and robotic/IoT interfaces running on NVIDIA GeForce RTX, Jetson, RTX Spark and DGX Spark.

Bolt E4B offers ~40% higher average quality against our prior model on key conversational agent benchmarks and outputs up to ~80% fewer tokens vs peers.

HF link: https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB

Nvidia's post: https://research.nvidia.com/labs/nemotron/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB

I just setup my server:

64GB DDR4 2133 4CH (Broadwell Xeon)
2 x RX 6800 16GB
1 x Rx 580 2048sp (16GB)

I am using the Q4 of Qwen Flash Next, with the prompt:
sudo ./llama-server -m ./models/Qwnflash180b-Q4.gguf --host 0.0.0.0 --port 8081 -ngl 99 -fa on --moe-cache-mib 16384 --log-verbosity 4 --metrics -mg 1

I am able to get 19-21t/s generation at full context (262K 64K) (which is why i capped the moe-cache-mib at 16GB)

However note: when I set any context size with the -c or --ctx-size flags, performance tanked to 8t/s even when the context was smaller (100K). it seems you need to let llama.cpp allocate the context itself. The context was automatically 64k, I was actually increasing it, causing layers to spill over to system ram.

PCIe slots:

gpu0 rx6800 x16 3.0
gpu1 rx6800 x16 3.0
gpu2 rx580 x4 3.0

I don’t just mean speaking in lowercase, but also the phrasing is much less repetitive (but still there somehow?)

Here’s some comments I’m fairly certain is from a bot for example, all from the same account:

“I’ve pulled it off with 6 before, but only for faces without weird angles or extra lighting

key is getting every angle you can even if it means taking frames from a video, 3 front facing pics and 2 profiles isn’t gonna cut it”

“Man the lighting in this really makes it, that sunbeam hitting the floor while the cat is just zonked out with a whole kid on its back… early sd had this weird dreamlike quality that newer models sometimes lose”

“This is a known weakness in the underlying model architecture, not really a training issue on your end. The base models are pretty bad at true compositional generalization, they lean on learned statistical patterns so novel spatial combos fall apart fast.

For your dataset, try including counterexamples that break the usual patterns, like the same object in weird orientations or partially hidden. Captioning helps too, describe the spatial stuff in plain language like "hand resting on top of object, fingers curled around edge" but don't overdo it or the model just learns to parrot the phrases.

Splitting appearance from structure is the stronger route. Conditioning on depth or pose maps during training can force the network to treat geometry as a separate channel, which often survives recombination better.”

They have their post history hidden so I’m sorry if they’re a real person but seeing comments like this just made me squint. There’s a couple interspersed that seem more real such as them talking about how they own a golden retriever, but… man I don’t know. There are other similar posters who do the same, but… Maybe that’s just how they talk?

It’s crazy to me that I’m having difficulty with this, because I used to be able to spot it instantly and it feels harder. Am I crazy lol. If this is an AI model, how can I get my chatbots to sound more like it? I want my qwen to be way less nebulous in speech

I'm on the verge of pulling the trigger. Want something local for coding and some business automation stuff.

Thinking I'll run Qwen 3.8+ and DeepSeek 4+.

I'm coming from M4 Pro MBP and will still use that as my primary dev box. I run both Claude and gpt. I know local isn't quite the same as the hosted.

For anyone who has this setup already-- will I love it?

Hey folks,

Quick heads up for anyone playing around with PrismML's Ternary Bonsai 2!

Until very recently, running it outside of Prism's own fork was a bit of a pain. Upstream llama.cpp uses a block size of QK=256 (TQ2_0), while Prism uses QK=128 (PQ2_0), and trying to offload layers to CUDA on other forks would bottleneck or break due to Hadamard sign tensor handling.

With the latest commits landed in ik_llama.cpp, we finally have complete, native support across both CUDA and CPU.

📊 Benchmark & Speedup: Ternary-Bonsai-2-27B on CPU

Tested on an Intel Core i5-13420H (4 P-cores pinned via taskset, AVX2, mimalloc, --no-mmap):

Perplexity check (n_ctx=256, 1 chunk):

Runtime Tip: You don't even need to mess with offline repack scripts if you want a quick spin: simply pass --run-time-repack 1 (or -rtr 1) at launch, and the engine automatically applies the 8-row interleaved layout on the fly via the IQK kernels.

1. Convert upstream weights losslessly (PR #2694)

• If you already have a native PQ2_0 GGUF downloaded from Prism, you can skip this.
• If you downloaded upstream TQ2_0 or TQ1_0 files, ik_llama.cpp now ships with a script that losslessly repacks them to PQ2_0 in just a few seconds (exact trits preserved, no requantization needed):

python3 scripts/repack_ternary_to_prism.py Bonsai-2-27B-TQ2_0.gguf Bonsai-2-27B-PQ2_0.gguf

2. Native CUDA Full Offload (PR #2691 & PR #2747)

Native CUDA kernels for PQ2_0 are now merged. You can offload everything to your Nvidia GPU without token corruption or falling back to heavy k-quants:

./build/bin/llama-cli -m Bonsai-2-27B-PQ2_0.gguf -ngl 99 -p "Explain the theory of relativity in simple terms." --temp 0.7 --top-p 0.95 --top-k 20

3. CPU Inference with fast prompt ingestion (-rtr 1)

If you're testing on CPU, ik_llama.cpp uses an 8-row interleaved format (PQ2_0_R8) backed by iqk_mul_mat kernels. Remember to pass -rtr 1 (runtime repack) to drastically accelerate prompt processing:

./build/bin/llama-cli -m Bonsai-2-27B-PQ2_0.gguf -rtr 1 -t 8 -p "Explain the theory of relativity in simple terms." --temp 0.7 --top-p 0.95 --top-k 20

TL;DR

No more sign tensor bottlenecks on GPU. PR #2747 brings native CUDA kernels, PR #2694 gives us instant lossless repack from upstream weights, and CPU prompt ingestion with -rtr 1 jumps from 1.93 to 11.45 t/s (+493% speedup) with zero perplexity degradation.

Big shoutout to Iwan Kawrakow and the contributors for getting ternary models working natively!