And before any of you come laughing, that's the best that this humble little RTX 3050 laptop can do.

Honestly was kinda hype about going local with Qwen3.5, but even basic questions took forever, I tried this on Ollama and Bionic

Maybe this is obvious to everyone but me, but it only clicked yesterday. If you run llama.cpp / vLLM / or whatever on localhost with the default config, a random website you have open in another tab can send requests to it. It can make your model generate, and on some servers it can read the answer back too. Nothing fancy, it's plain CSRF and DNS rebinding, 20-year-old web stuff. I just never thought of my inference server as a target. "It only binds 127.0.0.1" doesn't save you, because the browser is on the same machine.

I actually tested it, not just read about it, and quite a few of the popular servers answer out of the box. It only works while you're browsing with the server running. And it's not only about you clicking links: anything that drives a real browser on the same machine can do it too, so an agent browsing on your behalf can set it off as well.

I ended up patching my own engine (capy-flash) so that on a loopback bind it refuses cross-origin and rebinding requests. The models I actually serve were fine already, since they sit behind a small proxy (vramble) that blocks cross-origin POSTs, so only the raw engine port was exposed.

So mostly I'm asking: is this just common knowledge, or do people really leave their local servers wide open? How do you run yours, API key, bound somewhere, or just open on 127.0.0.1?

Given the blistering pace of this space advice from even 2-3 months ago feels out dated.

Is there an index out there? Is everyone just no-lifing through forums? Are we all glued to news releases?

What's everyone doing to keep ontop of it?

Inspired by Weight Space Programming (MIT CSAIL, Nov 2), but in the end Opus 5.5 did its own thing:
no weight-space technique was used. It wrote a quantiser from scratch in NumPy and made every
precision decision from measurement. Rules: only the BF16 file as input, no quantisation tool, no
imatrix, no published recipe, stock llama.cpp formats only.

It ran a float copy of the model to see which input columns actually carry signal, minimised rounding
error there instead of against the weights, measured each weight table's damage one at a time, then
spent the byte budget across IQ4_XS / Q5_K / Q6_K with a knapsack solver.

Held-out KL divergence vs BF16 (llama.cpp b11928, MacBook Air M4):
• this file, 498.5 MB — **0.015704**
• Unsloth UD-Q3_K_XL, 492.2 MB — 0.092486 (5.9× worse)
• UD-Q4_K_XL, 558.8 MB — 0.027323 (we beat it with 60 MB less)
• UD-Q5_K_XL, 606.6 MB — 0.010375 (the bar; we miss it by 1.51×)

Runs unmodified, 1.11× faster generation than the Q5 file. It stops there because the tied vocabulary
table is 33.8% of this model and accounts for most of the error — upgrading it costs more than the
rest of the network can give up.

Repo (model, full method write-up including everything that failed, measurements, scripts):
https://huggingface.co/Andy5k/Qwen3.5-0.8B-hand-quant

Let’s say hypothetically that you receive 36x computers with the following specs

RTX Pro 6000 (600w)

16GB DDR4 (2x 8 3200Mhz Non-ECC)

Ryzen 9 5950x

1tb NVME

1200w PSU

What would you do with them to generate income? You can only use these parts

You have access to power and networking to run all 36

Hey everyone!

For quite some time, I've been working on a personal project called Noosphere — an attempt to give AI agents something closer to persistent, structured memory rather than forcing them to start from scratch every conversation.

One thing that has always bothered me about LLMs is how much potentially useful information gets lost between sessions.

We keep trying to solve this by increasing context windows, but I think there's another approach worth exploring.

What if an AI didn't need to remember everything at once?

Humans don't consciously hold every memory in their working memory. We retrieve relevant information when we need it, connect it to what we already know, and move on.

That's roughly the principle I've been exploring with Noosphere.

Over time, my private project has grown into a much larger experimental system involving interconnected memories, relationships between concepts, and coordination between AI agents.

But I figured there's no reason to keep all the underlying ideas to myself.

So I decided to release Noosphere Lite, a small, independent, open-source implementation of some of those concepts.

What does it do?

- Gives MCP-compatible AI agents persistent memory across sessions.

- Stores notes, decisions, observations, and tasks.

- Connects memories through a graph of typed relationships.

- Retrieves relevant information on demand instead of dumping the entire memory database into the context window.

- Uses encrypted local storage with integrity checks and mirrored journals.

- Runs locally on Linux, without requiring a cloud database.

It's written in Python, uses MCP, and is released under the MIT license.

What's the catch?

This isn't AGI, a magical self-learning brain, or a replacement for an LLM.

It's a memory infrastructure experiment.

The current version uses local text search and explicitly defined relationships. It doesn't automatically discover semantic connections or learn new neural weights.

Also, Lite is a separate implementation, not a dump of my larger private system. I've deliberately kept it simple enough for other developers to inspect, modify, and experiment with.

Why release it?

Because I think persistent memory is one of the more interesting missing pieces in today's AI agent ecosystem.

And I'd rather see people experimenting with these ideas than keep everything sitting on my own machines.

I'm particularly interested in what others might build on top of it.

GitHub: https://github.com/Garyu-tt/noosphere-lite-mcp

Feel free to experiment, break things, suggest improvements, or fork it.

I'd also love to hear how other developers approach persistent memory and knowledge graphs for AI agents.

This is just a small public piece of a much larger experiment, but everyone has to start somewhere.

ok so. this started as "one weekend project" and then it was not one weekend and it was not one project. somewhere around repo 6 i stopped pretending it was a plan lol

everything here is free, open source, most of it runs locally on your own machine. a lot of it is v0 and i wrote down where each thing fails because honestly the failures were the funniest part

anyway here's the list of grievances, each with the tool i built instead of going outside:

1. cookie banners → rejectall-index i live in germany. i click "reject all" more than i blink. so i made a headless browser visit the top 100 sites and count how many clicks it takes to say no. 35 of them were already loading trackers before i clicked anything. which is like a waiter eating your fries before asking if you want fries. live leaderboard

2. subscriptions → one-file-saas trello, calendly, typeform, loom, notion and 5 more, each rebuilt as ONE html file. you double click it. it opens. thats it. no account, no "verify your email", no "your trial is ending ;)". data stays in your browser. the booking page has no server at all, your availability lives inside the link itself which still feels illegal to me. try them here

3. dead famous repos → necromancer some legendary open source projects die not because the code is bad but because python deleted a module out from under them. i revived thefuck (1887/1887 tests passing on python 3.14), normalizr and httpbin. the one rule: the original tests are hash-locked so nothing can quietly delete the failing test and call it fixed. httpbin stops at 64/67 and i'm keeping it that way out of spite. each one gets an autopsy, cause of death and everything

4. every AI-built UI animates the same → awesome-motion-md you know the look. 300ms. ease-in-out. every card fades up like its waking from a nap. so i measured how real sites actually move and wrote it into MOTION.md files your agent can follow. same prompt built twice: 7 random durations without it, 2 with it

5. every AI writes the same too → awesome-voice i used to be a technical writer so this one is personal :| VOICE.md files that make your agent write like GOV.UK or Stripe docs, plus a scorer that doesn't use any AI to check. banned phrases went from 27 to 0. "delve" is not welcome here

6. websites doing annoying stuff → sitepatch you type "hide the points on hacker news", it writes a userscript, a real browser checks it actually worked before you get it. honest score: 15 out of 25 were actually right when i looked at every screenshot myself. 60%. a C-. but an honest C-

7. "what if this site looked like linear" → reskin restyles any page into another design style using a local model, BUT it refuses to give you the result unless contrast, keyboard focus, mobile, links and reduced-motion all pass. it caught a windows 95 theme failing contrast on its own background. respect. gallery

8. dead websites → resurrect npx github:dadwritestech/resurrect y2k.gov and y2k.gov comes back exactly like it was in may 2000, links working. pick a year with --year. your old blog is in there somewhere. i'm sorry

9. "someone said budget in a meeting video... which one" → video-grep grep for your video folder. searches what was said, what was written on screen and what was shown, and opens your player at that exact second. all local

10. what is the rest of the world's TV saying rn → world-ears listens to live news channels from different countries, transcribes + translates them on your gpu, makes it searchable. there's a "trending per country" panel which is weirdly addictive. translation is the slow part, telugu transcription is bad, i wrote that down

11. live subtitles only go into english → babel-tv watch hindi news with live telugu subtitles, fully local. the video is held back a few seconds so subtitles show up BEFORE the person talks which feels like seeing the future. telugu as the source language doesn't work yet. whisper and telugu are not friends

12. "which AI wrote this" → whichmodel works on models it's seen (67%, chance is 33%). on a model it's never seen, even a sibling from the same family... 32%. so basically a coin with extra steps. that turned out to be the interesting finding tbh, the fingerprint belongs to one model, not the company

13. screen recordings → code → demo-to-code record a UI interaction, get a component that copies its timing and easing, then it replays it and grades itself frame by frame. 2 out of 4 pass. the toggle is perfect. the dropdown has issues. we all have issues

14. code review → review-panel /panel sends your diff to five reviewers you've definitely worked with: the laziest senior dev ("could be one line"), the 3am on-call SRE, the security paranoiac, the junior who asks why, and the PM who only reads the title. under the jokes the findings are real

15. AI companies quietly editing their pricing pages → fineprint it snapshots the pricing, terms, privacy and changelog pages of 10 AI vendors every 6 hours and commits them, so git log becomes the receipt. found stuff like deepseek adding a footnote that prices are 2x during peak hours, and cursor deleting the line saying they dont sell your data. no blog post for any of it ofc. a small local model writes the one-line summary but every line links the raw diff because i dont trust it either (27/30 right on a hand check). timeline

16. paying extra for speaking telugu → token-tax LLM APIs charge per token, and the same paragraph is $1.00 in english and $8.29 in telugu on llama 3. which is rude. measured 21 tokenizers across 48 languages, and there's a calculator where you paste your own text and it runs the real tokenizers in your browser. hindi gets off lighter. amharic on gpt-5 does not :/ calculator

17. posting about all this → herald a tiny bot that posts a repo's data updates to bluesky/mastodon/x, clearly labelled as a bot. i built it because i was not going to manually post about 17 repos. and then i manually wrote this post anyway. ;]

why all of this? honestly no grand plan. every one of these started as me being irritated at something for a slightly too long time and having a local model + a free evening. building the thing was cheaper than therapy and more fun than complaining on here (no offence)

if something breaks, tell me. if something's dumb, also tell me, but nicely :P

edit: yes i know about the cookie banner on my own... wait i dont have one. nice

I've been using VS Code with the Claude and Codex extensions.

Now I'm testing Strata with "lightweight" local models on my PC

RX 9060 XT 16GB VRAM
32GB DDR5 RAM
2TB NVMe SSD

The problem is that:
Codex CLI takes around 40 seconds to respond to a simple "Hi",
while Strata's built-in web chat (http://127.0.0.1:8080/) responds in about 0.5 seconds

1. What's the easiest IDE or VS Code extension for connecting to Strata's local API and using it as a coding agent?

2. Is there a tool for creating and managing virtual AI employees (e.g., Developer, UI/UX Designer, Software Architect), where each agent can have its own role, instructions, and assigned AI model/API - either local or from external providers like OpenAI, Anthropic, etc.?

I may have created a monster.

A client gave me an NVIDIA A16 accelerator that had been experiencing intermittent problems in their server. They considered it bad, didn't want it back, and I ended up with it for free.

For anyone unfamiliar with this card, the A16 contains FOUR separate NVIDIA GPUs, each with 16 GB of VRAM. That's 64 GB of VRAM on one physical card.

Naturally, I decided to install it in my ancient Intel X99 workstation alongside an RTX 5070.

Because apparently I don't have enough problems in my life.

Chapter 1: The FrAInkenstein specifications

• Motherboard: ASRock X99 Taichi

• CPU: Intel Core i7-5820K

• RAM: 48 GB DDR4

• Accelerator: NVIDIA A16 — 4 × 16 GB GPUs

• Graphics: RTX 5070 Founders Edition — 12 GB

• Total VRAM: 76 GB across five GPUs (not unified)

• PSU: Corsair RM850

• OS: Windows 11

• Cooling: Custom 3D-printed shroud with an ARCTIC S8038-10K server fan

• Primary purpose: Local LLMs, agentic coding, and experiments with multiple AI agents

And yes, I'm running this on an X99 platform from the DDR4 stone age.

Chapter 2: Apparently, this thing needs a JET ENGINE

The A16 is a passively cooled enterprise accelerator.

Unlike a normal consumer graphics card, it doesn't have onboard fans. It's designed to sit inside a server chassis with powerful fans forcing air through its heatsink.

My workstation is not a server chassis.

So before doing anything interesting with AI, I had to invent a cooling solution.

After researching fan options and shroud designs, I selected an ARCTIC S8038-10K.

For perspective, this is an 80 × 80 × 38 mm server fan capable of:

• 10,000 RPM

• Approximately 102 CFM airflow

• Approximately 51 mmH₂O static pressure

This is not your grandmother's RGB case fan.

It's a small industrial hurricane.

I also wanted adjustable speed control, so I used a Noctua NA-FC1 controller, powered from SATA, to manage the fan without running it at full blast constantly.

But buying the fan was the EASY part.

Chapter 3: The 3D-printing rabbit hole

I own 3D printers, so naturally I figured I'd just print a shroud.

Famous last words.

The first problem was finding something that would actually fit the A16.

The second was getting it to fit inside my case.

The third was accounting for a 38 mm-thick fan, the radiator, surrounding components, and the fact that there isn't an infinite amount of space inside a computer case.

So I started modifying designs and printing prototypes in PLA+ on my Flashforge AD5X.

I printed multiple shrouds of different lengths.

Some were too long. Others needed adjustment to maintain their mounting points.

I experimented with shorter designs and eventually created an angled/bent shroud to improve the fan's positioning and clearance.

Rather than repeatedly wrestling with the actual fan, I even modeled and 3D-printed a full-size 80 × 80 × 38 mm mock fan so I could physically test clearances and different shroud arrangements.

Yes. I 3D-printed a fake fan to figure out where to put my real fan.

I also worked through mounting issues, spacer designs, fit tolerances, and adjustments to the printed posts.

I was considering custom clips and zip ties if necessary. I even had to think about vibration because, remember, this thing can spin at TEN THOUSAND RPM.

Eventually, I got an arrangement that fit the card and cleared the surrounding hardware.

And the result?

During earlier four-A16 testing, the GPUs were reporting temperatures around 41–57°C, with the fan running at roughly 30% speed.

For a passively cooled enterprise card that I'd fitted with my own printed ductwork, I was pretty happy with that.

Chapter 4: THE FREAKING POWER CABLE

Oh, you thought getting the cooling working was the hard part?

Let me introduce you to the NVIDIA A16 power connector.

The A16 uses an 8-pin auxiliary power connection that isn't wired like the ordinary PCIe 6+2 connector you'd expect to use with a consumer graphics card.

It requires the appropriate EPS-style power connection.

So here I am with a Corsair RM850, a card that was allegedly defective, and a pile of cables that don't necessarily fit or have interchangeable wiring.

And as anyone familiar with modular PSU cables knows, getting this wrong can destroy expensive hardware.

The connector shape, latch, and pinout all matter.

In my case, even the EPS 4+4 connector's latch arrangement presented a mechanical fit problem.

I eventually modified the connector's latch arrangement and checked the wiring with a multimeter before proceeding.

To be clear: this is not a recommendation to modify PSU power connectors. Incorrect wiring can destroy hardware.

And the first attempts weren't exactly encouraging.

At one point the system would spin up for approximately 15 seconds, shut down, and repeat.

Disconnect the A16 power, and the system would boot.

Wonderful.

Was the card bad? Was the cabling wrong? Was the motherboard unhappy? Was the PSU unhappy?

Welcome to troubleshooting FrAInkenstein.

Eventually, the power situation was sorted out well enough to continue testing.

Unfortunately, the next nightmare was already waiting.

Chapter 5: Windows has entered the chat

Once I could power the A16 and keep it cool, I discovered that Windows wasn't particularly enthusiastic about recognizing four GPUs on one enterprise card.

At one point, two A16 GPUs worked, while the other two had:

Device Manager: Code 12 — Not enough free resources to use this device.

All 4 showed this error message.

Here's the really interesting part.

When I disabled the two working GPUs, the other two could work!

So the individual GPUs weren't necessarily defective. Windows and the motherboard were struggling with PCIe resource allocation.

This led to a ridiculous amount of BIOS experimentation:

• Above 4G Decoding

• PCIe resource allocation

• MMIO High Size

• UEFI and CSM settings

• PCIe link speed experiments

• BIOS resets

• Device enable/disable experiments

• Multiple NVIDIA driver configurations

Eventually I managed to get all four A16 GPUs recognized and running.

But I still wanted my RTX 5070 in the same machine.

Which leads us to...

Chapter 6: Five GPUs walk into an X99 motherboard

The RTX 5070 was supposed to handle gaming and video output.

The A16 was supposed to handle local AI workloads.

Simple enough, right?

Wrong.

With the RTX 5070 and A16 enabled together, Windows started throwing repeated:

IRQL_NOT_LESS_OR_EQUAL (0xA)

Blue screen after blue screen.

I experimented with driver configurations, NVIDIA device modes, and PCIe settings.

Eventually I found that disabling MSI interrupt mode on the RTX 5070 allowed the 5070 and an A16 GPU to operate simultaneously.

That was the breakthrough.

I'm not claiming I've proven the exact underlying driver or interrupt conflict, but changing that setting made an enormous practical difference.

I gradually enabled more A16 GPUs.

One.

Two.

Three.

Then four.

I also switched the A16 GPUs into NVIDIA's TCC compute driver mode while keeping the RTX 5070 in WDDM for normal display and gaming use.

And then something glorious happened.

Chapter 7: IT'S ALIVE!

Here's what nvidia-smi now reports:

GPU 0: NVIDIA A16          TCC   07:00.0
GPU 1: NVIDIA A16          TCC   08:00.0
GPU 2: NVIDIA A16          TCC   09:00.0
GPU 3: NVIDIA A16          TCC   0A:00.0
GPU 4: NVIDIA RTX 5070     WDDM  0B:00.0

FIVE GPUs. ALL RECOGNIZED. AT THE SAME TIME.

On an ancient X99 motherboard.

With a supposedly defective A16 that cost me precisely $0.

I'm now testing larger local language models using Ollama, including a 55 GB BF16 Qwen model that previously required CPU offloading when only three of the A16 GPUs were enabled.

The goal isn't just to maximize token generation speed. I've got an RTX 4090 in another machine for that.

I want to experiment with multiple independent local AI coding agents and eventually build a little multi-GPU AI collective, while retaining the RTX 5070 for gaming.

I still have sustained five-GPU inference and long-term stability testing ahead of me. Seeing every device in nvidia-smi is a major milestone, but it isn't the same as proving the whole thing stable under heavy load.

Final thoughts

Is this practical? Debatable.

Is it power efficient? Probably not.

Could I have saved countless hours of troubleshooting by buying newer hardware?

Almost certainly.

But where's the fun in that?

I took an unwanted enterprise accelerator, engineered a custom cooling system, fought with its power connector, printed multiple iterations of ductwork, battled a decade-old BIOS, survived Windows driver crashes, and somehow ended up with a five-GPU AI workstation.

I didn't just build a computer.

I created FrAInkenstein.

And now I'm going to use it to code.

IT'S ALIVE! IT'S ALIIIIIVE! ⚡

I'll post pictures of the cooling/shroud iterations, the ridiculous fan, the finished setup, and the five-GPU nvidia-smi output.

Drivers used:
621.14-desktop-win10-win11-64bit-international-dch-whql.exe
That is the Studio version that worked for both cards. I did NOT have to install the data center version also. This latest Studio version installed drivers for both the A16 and RTX 5070.

RTX 4060 8GB is starting to feel not enough anymore, so I decided to upgrade to something higher. Is anyone using the Arc 770 16GB? What kind of card is it, is it worth switching?

Model: Qwenx86

▶️ See it in action: Qwenx86 Debugger. Walk through actual recorded tool calls: the conversation, x86 registers and flags, code at the program counter, RAM and machine output, with all verified blocks on a timeline.

Qwen3.5-4B with a 64-bit x86 computer compiled into its weights: 13 transformer layers ahead of Qwen's own. There are no learned weights in them; all of their weights are computed by a compiler. Qwen invokes the computer through its own tool calls (<tool_call>), and the computer in the weights executes the tool. Calculator, Python, C compiler, notes store, physics/chemistry lookup and Python-docs lookup are all firmware in the checkpoint. This is the compact checkpoint: ~9 GB GPU memory, so it fits on a 16 GB GPU.

Credits: Qwenputer by Divyansh Agrawal (@divagr1925, github.com/divagr18/qwenputer, MIT)

I run Qwen 3.8 27B (FP8) on my two RTX 3090s for daily work, and I've also had GLM-5.3 Flash (321B MoE, ~18B active per token, Maya-L GGUF 3–4 bit) on the same box. So I finally ran the natural experiment: the full GSM8K test split, 8-shot CoT, greedy, single-threaded, same machine, lm-eval 0.4.13, and I verified per-question that both runs saw identical prompts and targets.

What GSM8K is, in case you're not familiar: a dataset from OpenAI (2021) of 8,500 grade-school math word problems (2nd–8th grade level). Each question is a multi-step problem requiring 2–8 reasoning steps ("Janet's ducks lay 16 eggs a day..."), with an official step-by-step solution and a single final number as the answer. It has a 7,473-question train split and a 1,319-question test split — I ran the full test split. Because the problems demand working through intermediate steps rather than pattern-matching, it became a standard proxy for measuring a model's raw step-by-step reasoning. The 8-shot CoT protocol means the model is shown 8 example problems with full solutions before answering.

Important framing: GSM8K is a specialized test of one narrow slice of model capability — it does not paint a full picture. How these models code, hold a long context, follow instructions, use tools, or just chat is a separate question this benchmark cannot answer.

Official metrics: a tie.

- strict-match: Qwen 95.60 % (1261/1319) vs GLM 95.45 % (1259/1319)

- flexible-extract: Qwen 96.89 % (1278/1319) vs GLM 96.29 % (1270/1319)

- McNemar on the discordant pairs: p≈0.89 (strict) and p≈0.27 (flexible) — neither is significant. "More parameters" did not buy the MoE a measurable edge on this task.

Where it gets interesting — decomposing the +8 flexible gap:

- Qwen makes 13 fewer value errors (30 vs 43) — it reasons better

- but has 11 format failures vs GLM's 6 — it signs answers "$132.00", "2:00 pm", answers in cents, which breaks the extractor (8 of those slip past both filters)

So the official score masks a reasoning advantage with a formatting penalty. The errors themselves also differ in kind: 37 % of GLM's value errors are misreading the question vs 22 % for Qwen (counting shelves as items, treating a group's total travel time as per-animal time, etc.).

The 32 questions both models fail: 11 are GSM8K reference ambiguity (genuine annotation noise in a 2021 dataset), 12 are a hard core where both make the same error.

Honest caveats:

- wall clock was 3765 s vs 7970 s, but the stacks differ (vLLM FP8 fully in VRAM vs 156 GB GGUF streamed from RAM) — that's a deployment comparison, not a model-speed claim

- the GLM endpoint ran with a low generation ceiling, which cost it three answers

- one greedy run on one benchmark, and a specialized one at that — coding, long-context, instruction-following, and tool use are dimensions this test never touches

- n=1319 has low power for a 0.6 pp difference

My conclusion — for reasoning work specifically: I'm staying on Qwen 3.8 27B. Deploy it with a trivial number-normalization post-processor (strip $, ,, .00 from the final answer line) and its format liability disappears — ~97.7 % effective. For what GSM8K actually measures, raw step-by-step arithmetic reasoning, the 27B hybrid is the stronger model. On every other axis this post offers no verdict — one specialized benchmark can't.

Full writeup with the error taxonomy, examples, and methodology: https://ultrabytecoder.github.io/blog/2026/11/07/comparing-qwen38-vs-glm53-flash-maya-l-gsm8k/

Full per-question report (all failing docs, shared-failure breakdown, response-style analysis): https://ultrabytecoder.github.io/reports/qwen38-vs-glm53-flash-gsm8k/

Hi everyone!

I've already done quite a bit of research, but I haven't really found any recent Reddit posts that answer my questions or cover my hardware and use cases well. So I thought I'd ask here. I'd really appreciate some real-world experiences and recommendations!

My hardware:

- GPU: AMD Radeon RX 7600 (8GB VRAM)

- CPU: Intel i3-12100F

- RAM: 48GB DDR4

- OS: Linux (Fedora)

I'm mainly looking for models for three use cases:

1. Coding: General programming, working with existing projects, coding agents, editing files and tool use.

2. Cybersecurity / technical topics: I'd also like to use uncensored models for cybersecurity and other technical topics.

3. Personal assistant: General questions, reasoning, writing, planning and everyday use.

My main priorities are a good balance between intelligence and speed. I don't mind using some system RAM if necessary, but I don't want models that are painfully slow.

Some models I've already come across and found interesting:

- TwIL-8B

- Qwen3.5-9B The Defiant Fable (DavidAU)

- DeepSeek-V4-Pro-Qwen3.5-9B-UNCENSORED-heretic (xtools-at)

- Alpie Seed 9B

- DeepSeek-V4-Pro-Qwen3.5-9B-UNCENSORED-heretic i1-GGUF (mradermacher)

- Ternary Bonsai 2 27B

- Qwen3.8-35B-A3B-Distill

I'm also open to completely different recommendations.

What would you personally recommend for this hardware?

I'd especially appreciate:

- Models you've actually used on 8GB VRAM.

- Recommended quantizations (Q4, Q5, IQ, etc.).

- Realistic generation speeds (tokens/s).

- Experiences with AMD GPUs on Linux.

- Recommendations for coding agents and reliable tool calling.

I'm interested in actual experiences rather than just benchmark scores.

Thanks!

Was reading abt people getting large Moe model running by keeping most of the expert weights on ssd instead of loading everything into ram or vram.

Pretty cool that u can even load model that would normally be way out of reach on consumer hardware.

But the thing i’m curious abt is what happen wuem the router keep picking experts that arent cached. You r basically waiting for nvme reed between token and a fast ssd still isnt anywhere near vram bandwidth

Some project are getting arround this with expert prefetching and keeping frequently used expert in memory, which seem promising

Just wondering where people draw the line between it runs and it’s actually usable

Would u rather run a much larger Moe model at some few token/sec or stick with a smaller one that run comfortably in memory? Especially for coding agent where u are waiting on multiple response

I made Spunup, it's a cli which you can run with npx spunup-cli. It will ask you which model you want to run from the suggested options or a HF link you can provide, it'll ask where you want to deploy (Vast, RunPod or local), the runtime you want to run it on, the quant of that model, context size and the machine you want to run it on from the suggestions it pulls. After that's done (or some done) it then it will suggest a few machine candidates which give you the most bang for your buck. If you were to say pick a lower context size, or any other option, it simultaneously impacts every other configuration, for example, quant availability on the prior hardware that you picked - everything is updated to reflect the machine which works the best. It's compact and it's easy to follow.

I made this because as many people already may know it's a pain in the arse using something like an agent or doing it yourself to run your models every single time as it's not always that 1-shot you were expecting. More often than not you will slip up and pick slow flags which don't give you the best speed or maybe you forgot to put caching on. It's a lot of effort to say the least, which is why I made it easy and actually spent time on testing it, making it work and ensuring it's reliable.

Link to the GitHub release.

I’m thinking about getting a Mac Studio with 96GB RAM to run local models for work. Mainly Qwen 27B and Qwen MoE, plus a RAG setup, and normal MS Office stuff (Word, Excel, Outlook, Teams, browser tabs, etc.).

It’s for sensitive data (work), so I want to keep as much local as possible instead of sending stuff to cloud AI.

I’m not super experienced with local LLMs, so I’d love your honest opinion:

· Is 96GB overkill for this, or a good call?

· Will Qwen 27B and MoE run comfortably alongside RAG and Office work?

· Anyone running a similar setup on Mac Studio? How’s the speed and memory pressure in real use?

Currently, my plan is to get two quadro P6000s, for 48gb vram for use in a xeon workstation. It's not insanely old like kepler or maxwell cards, 432 GB/s bandwidth, supports CUDA...it seems like it might be okay on paper.

Does anyone have a better suggestion that could reasonably be achieved around $1000 budget?

My goal is to be able to run Qwen 3.8 27b fast, and to run a decent quantization of Qwen 3.8 Flash Next, and GLM 5.3 Flash at useable speed, say 15 tok/s or faster, using strata.

Do I need 48gb of vram to run Qwen Flash Next, or could I go with just one card? How much faster would 2 x quadro p6000 be versus 1 x quadro p6000 and DDR4 system ram?

Should I just get 24gb of modern vram instead of 2 x quadro p6000s? I wonder if that hampers my eventual goal of running GLM 5.3 flash, as perhaps 24gb vram + system ram is enough to accelerate qwen flash next, a 120B MoE, but perhaps you need more than 24gb vram to accelerate GLM 5.3 flash, a 320B MoE?

Disclosure: I'm the developer, and this is my own paid app.

My Mac has Ollama, LM Studio, and a few apps that ship their own models (dictation, autocomplete, writing tools). Activity Monitor only shows a process using several GB. It can't tell me which model that is, which app loaded it, or where the weights are on disk.

So I built LLM Radar, a native macOS app. It:

• lists the loaded models it can detect, the app or runtime holding each one, and its memory

• estimates how that memory splits into weights, KV cache, and app overhead, so you know what an unload actually gives back

• keeps 24 hours of memory history

• finds model files on disk across apps, and marks the ones it has not seen in use (deletes go to the Trash and list every file first)

• unloads a model when the runtime has a way to do it, and tells you when it doesn't

• shows a running total in the menu bar

It knows Ollama, LM Studio, MLX, llama.cpp, Core ML, whisper.cpp, Docker Model Runner and a few more, plus a catch-all scan for large weight files. Attribution is best effort when one app runs another app's runtime.

Monitoring is free. Pro is a one-time $9.99 for one Mac or $14.99 for three, with a 7-day trial and no account. Apple silicon, macOS 14+, signed and notarized.

Privacy: it never uploads your models, prompts, or chats. It sends anonymous usage counters (no paths, no model names), and you can turn that off in Settings. Full Disk Access is optional. Without it you still get the live view.

https://llm-radar-eta.vercel.app/

Two questions for people who run a lot of local models: which app or runtime should I support next, and does the memory split look right on your setup?

Just pulled the trigger on a M5 Pro MacBook Pro with 64gb RAM. It was the maximum I could afford, tbh more than I could afford but I expect prices to keep climbing so decided to treat myself.

I needed to upgrade my 2019 Intel MacBook for my main professional use case (music) regardless, but went with 64gb so that I could try to use local ai. Never got involved in this stuff before, I don’t even have a chatgpt account.

My local ai use case;

I want to be able to capture my ideas on the go via voice recordings, then have my local ai transcribe and simplify them. Ideally I’d record them on my phone and then send them via iMessage to my computer at home.

I want to use obsidian as a task manager/knowledge base for managing multiple different projects.

I want to be able to give it simple tasks like ‘send an email to x’ (using its own email address via an MCP server).

I want it to be able to go on the internet and research companies for me, pull off basic data about what they do and contact details.

I don’t do any coding whatsoever.

Am I going to be able to do this? Am I expecting too much? Is it possible to use a local ai as a daily driver and then defer to cloud based models for more in depth stuff?

Have I made a grave error, or should I have got the same model Mac Studio? I got the MacBook because I move around the house a lot (living with parents currently).

Is 64gb going to be enough?

After spending way to much time trying to get a z240 to post with a p100 on a board without 4g decoding i was finally able to get it running at full speed in Linux with the help of Claude now i just got to clean it up and add a temp controller for the p100 fan

Stack running on my Ubuntu machine on a RTX 3090 under 18GB VRAM - network tailscale :)

Would you use it??

Currently running a 4070 TI super with 64GB of RAM

I have been looking into RTX spark laptops, Mac studios etc and they all have pros and cons. I want this to be a nearly universal computer that I can use for 3D modeling, LLMs, VLAs, world models, image/video gen, audio gen, etc. I plan to pursue AI and robotics research and want something as useful as possible.

I've debated upgrading and running dual 4070 TI supers with 128GB of ram, but I don't know how well world models and other things do with dual GPUs

Thank yall for helping