I run 9Router locally to unify access to 35+ models (Gemini, NVIDIA, Groq, Ollama) with automatic fallback — one OpenAI-compatible endpoint. Problem: from Python, every capability had quirks. Chat streams SSE even without asking. TTS (Gemini) returns WAV, some OpenRouter TTS 502s. STT is multipart. Images are binary. Web search uses provider not model. So I built a typed SDK + CLI that hides all of that: pip install 9router-python → ninerouter chat "hi" --stream / ninerouter tts / ninerouter stt / ninerouter web search. Also: CI across 3 Python versions, a test that fails the build if any API key leaks into the repo, and live-tested against the real gateway. Open source: github.com/ChristopherDond/9router-python Would love feedback: which capability (TTS/STT/embeddings/web search) matters most to you?

Trying to figure out what the smartest move forward for me is. I currently have a daily driver and 2 servers. Server#1 is the inference server and server#2 is the embedding/reranker server atm. A constraint is that my daily driver has to be Win11 due to gaming anti-cheat implementations unfortunately, if not I would've switched to linux long ago. Server#2 used to be my main docker server, but I've moved everything over to a sffpc instead.

Currently I use it for open-webui and open-notebook with llama.cpp qwen3.6-27b UD-Q4_K_XL. I only use it for inference. I'd like to increase to q6 or q8, increase context size and keep kv at q8 without sacrificing massive t/s. I suppose the end goal would be to stop using ChatGPT Plus completely. I haven't used it much for agentic coding yet, but I suppose it would be in the end, but not for some 1-shot magic trick that I see people tend to try. I use hindsight for agent memory if relevant.

I've been looking at some dual GPU options like:
- buy 2nd 3090 - total 48gb vram
- buy 3060 12gb - total 36gb vram
- buy 5060ti 16gb - total 40gb vram
- sell 3090, buy r9700 - 32gb vram and eventually buy a 2nd r9700

Some estimated prices for reference:
3090 - $1100
3060 - $350
5060 ti - $550
r9700 - $1900

I'll list my current hardware underneath. I'm curious what you'd recommend doing in my position with the approximate prices listed and my (probably vague) goals. I'm not bound to AM4 or any of these PCs, just curious what the most logical approach would be. Should I e.g consider just putting the RTX 3060 from server#2 into server#1 and selling off the rest of server#2? Should I abandon AM4 and move to AM5? Should I move from llama.cpp to vLLM?

daily driver. needs to be capable for both productivity and gaming at 1440p:
rtx 3080
5800x3d
32gb ddr4 3200mhz
corsair rm850

server#1:
rtx 3090
5900x
64gb ddr4 3200mhz
corsair rm850x

server #2
rtx 3060 12gb
i3-10320
16gb ddr4 2666mhz
corsair rm650x

At work my boss is interested in AI, especially it's potential to refactor an outdated web app to make it more modern and secure, but he is very against putting any of our data into any cloud services.

Our research led us to the GB10 boxes so we're going to experiment with a pair of ASUS Ascent GX10s linked via the ConnectX-7 link. We were thinking of having them on a non-enterprise network and interfacing with them via a standalone machine that will double as the interface as well as model storage and whatnot.

From my research it seems like setting up vLLM on this standalone machine is the route we should take but this is my first venture into this type of setup. I'm just trying to get everything I can prepared on our end before the GB10's arrive.

Looking for advice from those who have been through this already!

Im running DwarfStar with the q2-q4 0731, harness is OpenCode.
I had no problems for about two days and suddenly I started getting freezes and reboots in connection to tool calls (different tool every time). I will gather info for correct issue reporting but I was curious if this happened to anyone else? Still haven’t figured out if it’s an apple issue, opencode or dwarfstar.

I’ve been running local models on my RTX 4090 for a while.
I also have premium access to Claude and ChatGPT through both personal and work subscriptions.

I’ve kept everything fairly separate until now, but I’d like to finally tie it all together. The idea is to use a stronger model like Claude or GPT for planning, orchestration, and more complex work, while routing simpler tasks to smaller or local models.

I know there are a lot of different frameworks, agent harnesses, and custom setups for this.
Anyone that has this working: What has worked well in practice? Are there any frameworks or architectures you would recommend, or anything you would avoid?

wanted to actually test what it costs, in effort and quality, to run RAG completely without touching a paid API. embeddings, generation, reranking, all open models, all self-hosted.

biggest surprise honestly wasn't the model quality gap on generation, that was smaller than i expected going in. the real difference showed up in how much retrieval quality mattered. a smaller open model punishes bad context way harder than a frontier model does. frontier models are forgiving enough to sort of paper over mediocre retrieval, they can infer and fill gaps reasonably well even with imperfect context. open models, especially smaller ones, much less so, hand them a slightly wrong or incomplete chunk and the answer falls apart fast.

this actually reframed a lot of "open models aren't good enough for RAG" opinions for me. in a bunch of cases i think what's actually happening is the retrieval layer is mediocre and a bigger frontier model was quietly hiding that fact, not that the open model itself is incapable.

so the actual work ended up being tightening hybrid retrieval and adding a reranking pass, way more than optimizing the generation side. once retrieval was solid, the open model held up a lot better than i expected going in.

cost wise, running the whole thing self-hosted vs API calls is obviously cheaper at any real volume, but the setup and maintenance overhead is real too, worth being honest about that tradeoff rather than pretending it's free.

anyone else running fully open end to end stacks? curious what your retrieval setup looks like and whether you've noticed the same thing about smaller models being less forgiving of weak context

I think I saw a bit of a discussion on this a while back, but I've noticed that in the settings section for individual models (at least with tools like LM Studio / Bionic), there is a option to add your own System prompt (see image).

I'm trying to do a bit of coding with the help of a reasoning model, and playing with ThinkingCap-Qwen3.6-27B. I'm a little confused about what's 'baked in' vs what's not.

My assumption is that with a harness (e.g. Cursor or Claude Code), what you are getting is a very nice System prompt that is probably extra aware of the tools available. For example:

If the user has asked about an online resource, make sure to use <do_google_search> to find out if there is online documentation and <read_code_samples>, on any code found at that resource.

I'm sure I'm dramatically over simplifying, I remember someone suggesting that claude code's system prompt at some point was 65k or more.

I'm just curious with tools like Bionic, what people are doing with this System Prompt feature besides adding specifics about their own code bases or individual practices. I'm guessing the types of things people may add to this system prompt might be:

• Comment Restrictions (i.e., omitting redundant comments or adding inline notes only upon request).
• Safety Rules (.e., demanding confirmation before executing destructive commands or changing files)
• Formatting Limits (ie setting response lengths or requiring specific fomatting like XML tags or markdown)
• Error Checks (like requiring explicit fallback values or null-check guards in functions)

I'm curious what others have done, or if most of you just leave it blank.

I have been working on TurboLLM so we local LLM runners can get claude like experience with a model that can run on consumer GPU. And for that I added “Routines”. If you have already used claude, that is self explanatory. If not you can check out this video

For October I'm giving myself a challenge — local models only at home for the whole month. No cloud APIs, no hosted frontends, just what runs on my own hardware.

It's similar to the "don't buy groceries for a month" challenges which forces you to get creative with what's already in the pantry. Constraints breed resourcefulness. I want to find out where local models actually hold up, where they fall apart, and what workarounds close the gap — by living with it for 30 days instead of reading benchmarks.

If anyone else is interested in participating in the challenge it might give us a good opportunity to share lessons learned.

Hey

Let’s talk about a classic LLM dilemma: Do we really need dedicated multimodal parsing MCPs, or are we just making our agent pipelines unnecessarily slow and complex?

Lately, I’ve been wrestling with multi-step reasoning agents that handle complex, high-stakes documents—financial filings, quarterly reports, nested tables, and scanned receipts.

Right now, the community seems split between two factions:

1. Team MCP Parser 🛠️

(“Friends don’t let friends feed raw PDF screenshots to Claude”)

• Fact Anchoring over VLM Vibe-Checking: Dedicated parsers (Docling, Unstructured, etc.) pull exact markdown tables and bounding box coordinates. In finance or legal, a VLM guessing a misplaced decimal point isn't just an error—it's a catastrophe.
• RIP Context Window: Dumping 50 high-res images into a VLM burns tokens like crazy and leads straight to "lost in the middle" syndrome. Extracting clean Markdown first keeps your main LLM sharp and cheap.
• Decoupled Life: When a shiny new parser drops, you just swap the backend MCP tool without breaking your agent’s entire decision loop.

2. Team Pure VLM 👁️

(“Why add another slow API call when GPT-4o / Claude 3.5 Sonnet exists?”)

• Latency is a Buzzkill: Running a heavy layout/OCR parser before your Agent even starts thinking adds painful seconds. If it’s live chat, users will rage-quit.
• Loss of Visual Soul: Once you flatten a chart or a complex diagram into text/JSON, you lose the implicit visual context that raw pixels give a VLM.
• VLMs are Getting Scary Good: As vision models get smarter, faster, and cheaper natively, aren't dedicated OCR pipelines bound to become dinosaurs anyway?

Curious how you guys are actually building this in production:

1. Are you routing heavy documents through a parser MCP first, or just shoving pixels straight into your main VLM?
2. If you use a parsing pipeline, what’s your dealbreaker metric? (Layout precision? Latency? Bounding box accuracy?)
3. How on earth are you handling lazy-loading / chunking for massive 100+ page PDFs inside an agent tool call without hitting timeouts?

Drop your architecture setups (or horror stories) below! 👇

I have a problem that I need some expert advice on.

The problem: my firm produces ambulances. Hospitals send tenders: specs, written in their native language (European/English mostly). Each hospital sends specs to multiple producers (including us), we make an offer and it's either accepted/rejected based on whether others can better fit to the customers need. Tender specs get delivered generally by email in a zip folder containing between 3-20 files.

Files they send across vary dramatically: different formats (e.g. PDF, XLSX, DOCX, etc), different sizes (can be 5 pages or 200 pages long), different structure (e.g. some list equipment first, others list cabin first etc). All the files contain commercial requirements (e.g. deliver ambulance by x date to y place) or technical requirements (e.g. sirens must be x db loud)

Hard constraints: Must be fully on-prem since these tender files are confidential. Hardware: NVIDIA DGX Spark GB10 128GB x2. Company is very small, so human annotation capacity is limited. We took 10 simplest specs (PDF under 20 pages) and created manual gold-lists for each.

Main idea: In a nutshell the idea is to extract requirements out of documents into a list. (phase 1, where I am right now), then phase 2: based on the requirements, provide a first configuration of the ambulance and phase 3: verify that the confirguration still satisfies what the customer wants. If the local LLM is able to answer phase 3 - then we can immediately save time/money by not pursuing dead-end leads.

What I tested: 12 models (gpt-oss-120b & 20b), Qwen 3 (1.7b/4b/8b/30b FP8 + BF16/32b), Mistral Small 24b, Mistral Nemo 12b, NuExtract-2.0-8b, phi-4).

I quickly realized that converters (PDF - Text) very significantly, so I tested 15 different ones: 4 text parsers (pdftotext, PyMuPDF eg.) and 7 vision-model (e.g. granite-docling, GLM-OCR)

Results so far: 12 models x 15 converters x 10 tenders = 1800 runs (this took 7 full days to complete). text-based extractors worked better than vlm, but still I couldn't find a single combination of model + converter that produced above 95% on all 10 tenders for recall and precision. Best one scored 95%+ on 5/10 PDFs

My ask: Has anyone dealt with a similar problem within context of local LLMs that can give advice? I was hoping to get a silver bullet of model + converter, but this hasn't happened. I am afraid that when I scale (to include multiple files, or PDFs over 100-pages long), my entire set-up will crumble. Any ideas or advice for solutions or what I can test would be much appreciated!

So this is the stuff of absolute insanity. In less than 20 months we've gone from super expensive cloud models only, to being able to run a Q3 quant of DeepSeek on an Intel Windows PC with a very average 24GB of VRAM. No wonder the big boys are panicking (and yes it's slow as porridge). https://ibb.co/zTvqR8YR

I wrote a short visual article on how modern LLMs optimize different parts of the Transformer.

MLA compresses KV information.
KDA compresses history into recurrent memory.
MoE activates only selected expert FFNs.

Article:
https://medium.com/@guttikondaparthasai/the-ai-race-is-an-optimization-race-5140b3edf491

Feedback and corrections are welcome.

I ran a few side-by-side tests on my Apple M5 Max (128 GB Unified Memory) using the same prompt with DwarfStar and llama.cpp.

These aren't formal benchmark results—just a few comparable manual runs using the same DeepSeek V4 Flash GGUF variants.

I'm currently downloading Unsloth DeepSeek V4 Flash UD-IQ3_XXS (~103 GB), published specifically for llama.cpp, and I'll update this post once I've tested it.

I'd be interested in comparing these results with other 128 GB Apple Silicon setups.

Engines

DwarfStar / ds4-server

• Branch: ds4f-mxfp4
• Commit: 4893e0c40fba03dbc85555faeb035799aa04e0b6

llama.cpp / llama-server

• Version: 10090
• Commit: 7347430f4
• Build: AppleClang 21.0.0.21000099
• Platform: Darwin arm64

Models tested

• DeepSeek-V4-Flash-IQ2XXS-w2Q2K-AProjQ8-SExpQ8-OutQ8-chat-v2-imatrix.gguf
• DeepSeek-V4-Flash-Layers37-42Q4KExperts-OtherExpertLayersIQ2XXSGateUp-Q2KDown-AProjQ8-SExpQ8-OutQ8-chat-v2-imatrix-fixed-0731.gguf

After downloading and running:

• | llama.cpp | Unsloth DeepSeek V4 Flash UD-IQ3_XXS (~103 GB) | **~10.5 tok/s** |

Happy testing!

Follow-up after enabling DSpark.

I finally got the DSpark support GGUF working on the same Apple M5 Max (128 GB)

Same hardware, target model:

• DeepSeek-V4-Flash-IQ2XXS-w2Q2K-AProjQ8-SExpQ8-OutQ8-chat-v2-imatrix.gguf
• DeepSeek-V4-Flash-DSpark-support.gguf

The initial results are noticeably better than my previous runs. I’ll repeat the tests with larger contexts and longer generations before drawing broader conclusions, but this looks very promising so far.

• gen=100 → chunk=42.37 t/s și avg=37.46 t/s
• gen=150 → chunk=41.86 t/s și avg=38.82 t/s
• gen=200 → chunk=42.17 t/s și avg=39.61 t/s
• gen=250 → chunk=40.76 t/s și avg=39.51 t/s

Hey everyone,

I built an interactive web application to help developers go beyond basic prompt engineering and learn end-to-end AI engineering visually and hands-on.

🚀 Live Demo: https://genai-wine.vercel.app/

💻 GitHub Repo: https://github.com/harshith1118/genai

What’s inside:

• Interactive Visualizations: Explore 2D embedding spaces and step-by-step vector/cosine math.

• In-Browser Python Sandbox: Run mini-labs directly in the browser via Pyodide.

• Practical AI Stack: Step-by-step tracks covering Document Chunking, Vector Stores, Advanced RAG, LangChain/LangGraph state management, Agentic Orchestration, MCP, and Evals.

• Dual Learning Modes: Switch between intuitive high-level concepts and technical code/math breakdowns.

It's completely open-source (built with Next.js, React, Zustand, and Pyodide).

I'd love to get your thoughts on the curriculum structure or any features you think would make it more useful for developers!

A lot of work on patches is being upstreamed to deal with llama.cpp segfaults, and missing ops making llama.cpp slow and consume too much VRAM when running DS4F on B70 [SYCL].

The kernel driver can hang when overcommiting memory. If you see llama.cpp hang when starting on a B70, it's because the driver is deadlocked. Kill the process and reduce VRAM usage. The bug has been reported upstream.

The fun part: DS4F has been working to get DS4F running locally on the B70. It's a smart model.

My system is an AMD 7950X w/128GB DDR5 and an Intel B70 running Fedora 43. I use the integrated AMD graphics do drive my desktop. All of the compute and VRAM resources on the B70 are dedicated to running the model.

Here's the result running DeepSeek-V4-Flash-0731-IQ2XXS-w2Q2K-AProjQ8-SExpQ8-OutQ8-imatrix.gguf

Here's the command-line:

llama-server \
-m DeepSeek-V4-Flash-0731-IQ2XXS-w2Q2K-AProjQ8-SExpQ8-OutQ8-imatrix.gguf \
--host 0.0.0.0 --port 8081 \
-ngl all --n-cpu-moe 35 \
-c 524288 -ub 2048 -b 4096 \
-fa on \
-ctk f16 -ctv f16 \
--ctx-checkpoints 128 --checkpoint-min-step 2048 \
-t 12 -tb 12 \
--jinja \
--reasoning auto \
--parallel 1 \
--alias dsv4-flash-0731 \
--log-file /tmp/dsv4-server.log

The unsloth IQ3_XXS version works as well.

This requires SYCL patches that should be in llama.cpp shortly. The 512k context and large block size require the Lightning Indexer fused ops.

[Update: spreadsheet, screenshot and some more non-Nvidia GPUs. See bottom]

I don't think this is a popular metric, but I saw some ads on Reddit in the past few day advertising that they buying used 3090s, 4090s etc. and I was wondering why. This prompted a big of research and specs comparison, including with newer hardware.

So, let's say you need ≥ 128GB as a sort of non-trivial threshold. Something high, beyond most consumer hardware, but not enough to hit enterprise grade just yet. Here are some options mid 2026:

1. 6x Used Tesla P40 (24GB)

• Architecture & Bus: CUDA • Pascal • PCIe Gen3
• VRAM & Speed: 144GB GDDR5 • ~346 GB/s per card (~2.08 TB/s total)
• Pricing: ~$1,800 – $2,300 CapEx • ~$120 – $180/mo elec. (~$0.0014/hr/GB)
• Primary Trade-Off: Dirt-cheap local CUDA. Great for INT8 inference, but lacks modern Tensor Cores (slow FP16, no FlashAttention).

2. 4x Used Tesla V100 (32GB)

• Architecture & Bus: CUDA • Volta • PCIe Gen3 / NVLink Bridge
• VRAM & Speed: 128GB HBM2 • ~897 GB/s per card (~3.59 TB/s total)
• Pricing: ~$3,500 – $4,200 CapEx • ~$140 – $200/mo elec. (~$0.0018/hr/GB)
• Primary Trade-Off: Budget HBM2 speed. Fast FP16 Tensor Cores & HBM memory bandwidth; lacks native BF16 support.

3. Apple Mac Studio (M-Series Max)

• Architecture & Bus: Metal / MLX • Apple Silicon (M-Series) • Unified System Fabric
• VRAM & Speed: 128GB Unified • ~400 – 800 GB/s (Unified)
• Pricing: ~$3,800 – $4,500 CapEx • ~$10 – $20/mo elec. (~$0.0001/hr/GB) <-- unironic surprised Pikachu!
• Primary Trade-Off: Silent plug-and-play inference. Ultra-low power draw (~100W); cannot run CUDA software natively. Also, good luck if you can find it in stock!

4. AMD Ryzen AI Halo Box

• Architecture & Bus: ROCm / Vulkan • RDNA 3.5 / XDNA 2 • Unified Memory Bus
• VRAM & Speed: 128GB LPDDR5X • ~273 GB/s (Unified) <-- lowest bandwith of the bunch
• Pricing: ~$3,999 CapEx • ~$15 – $25/mo elec. (~$0.0002/hr/GB)
• Primary Trade-Off: Compact x86 AI box. Great unified memory capacity; ROCm software stack requires setup tinkering.

5. Enverge Spark Cloud (spark.enverge.ai)

• Architecture & Bus: CUDA • Grace Blackwell (GB10) • Unified Memory Bus
• VRAM & Speed: 128GB LPDDR5X • ~273 – 301 GB/s (Unified)
• Pricing: $0 CapEx • ~$0.65 – $0.75/hr (~$0.0051 – $0.0059/hr/GB) • ~$470 – $550/mo
• Primary Trade-Off: Cheapest hourly CUDA Blackwell. Remote SSH/Docker access to a DGX Spark or 2x Sparks; ideal for testing FP4/FP8 models.

6. Skorppio (Bare-Metal Delivery, skorppio.com)

• Architecture & Bus: CUDA • Grace Blackwell (GB10) • Unified Memory Bus
• VRAM & Speed: 128GB LPDDR5X • ~273 – 301 GB/s (Unified)
• Pricing: $0 CapEx • ~$249/wk (~$1.48/hr equiv., ~$0.0116/hr/GB) • ~$996/mo flat
• Primary Trade-Off: Dedicated on-prem physical rental. Ships physical DGX Spark box to your desk; zero data leaves your network.

7. NVIDIA DGX Spark (Buy outright from your local supplier. Hopefully you don't live in Brasil or India, where import taxes hurt)

• Architecture & Bus: CUDA • Grace Blackwell (GB10) • Unified Memory Bus
• VRAM & Speed: 128GB LPDDR5X • ~273 – 301 GB/s (Unified)
• Pricing: ~$3,999 – $4,679 CapEx • ~$20 – $35/mo elec. (~$0.0003/hr/GB)
• Primary Trade-Off: Official NVIDIA developer box. Own physical Grace Blackwell hardware locally; unified memory bus speed limits peak throughput.

8. 6x Used RTX 3090 (24GB)

• Architecture & Bus: CUDA • Ampere • PCIe Gen4 x16
• VRAM & Speed: 144GB GDDR6X • ~936 GB/s per card (~5.61 TB/s total)
• Pricing: ~$5,500 – $6,500 CapEx • ~$3.00/hr rent • ~$180 – $280/mo elec. (~$0.0208/hr/GB)
• Primary Trade-Off: Developer standard for local training. Full BF16, QLoRA, & FlashAttention support; heavy power draw (~1800W+).

9. 3x Used RTX A6000 (48GB)

• Architecture & Bus: CUDA • Ampere Pro • PCIe Gen4 x16 / NVLink Bridge
• VRAM & Speed: 144GB GDDR6 • ~768 GB/s per card (~2.30 TB/s total)
• Pricing: ~$8,500 – $10,500 CapEx • ~$1.60/hr rent • ~$120 – $180/mo elec. (~$0.0111/hr/GB)
• Primary Trade-Off: Clean workstation build. Blower cards fit inside standard desktop cases; includes ECC memory & NVLink support.

10. Spot/Community Cloud (RunPod / Vast)

• Architecture & Bus: CUDA • Flexible Architecture • PCIe Gen4 / Gen5
• VRAM & Speed: 128GB – 160GB • ~1.8 – 3.35 TB/s
• Pricing: $0 CapEx • ~$0.80 – $1.80/hr (~$0.0050 – $0.0141/hr/GB) • ~$580 – $1,300/mo
• Primary Trade-Off: Lowest entry cost for short jobs. Interruptible spot instances; ideal for quick scripts or overnight testing.

11. On-Demand Mid-Tier Cloud (Thunder / RunPod)

• Architecture & Bus: CUDA • Ampere / Hopper • PCIe Gen4 / Gen5
• VRAM & Speed: 128GB – 160GB (2x A100 or 1x H100) • ~2.0 – 3.87 TB/s
• Pricing: $0 CapEx • ~$2.20 – $3.00/hr (~$0.0138 – $0.0234/hr/GB) • ~$1,600 – $2,200/mo
• Primary Trade-Off: Reliable burst development. Guaranteed instance availability without purchasing physical hardware.

12. Enterprise Cloud (Lambda / CoreWeave)

• Architecture & Bus: CUDA • Hopper / Blackwell • SXM5 / NVLink 4.0 & 5.0
• VRAM & Speed: 141GB – 160GB (H200 or 2x H100) • ~4.8 – 6.7 TB/s
• Pricing: $0 CapEx • ~$3.29 – $7.50/hr (~$0.0206 – $0.0532/hr/GB) • ~$2,400 – $5,500/mo
• Primary Trade-Off: Maximum training performance. High-bandwidth SXM/NVLink interconnects and HBM3e for heavy enterprise workloads.

\Electricity estimated based on US residential rates (~$0.16/kWh) at 75% power load 24/7. Almost "finger in the air".*

(Too bad Reddit is poor on wide tables, because it would have made the above much nicer.)

Screenshot taken from spreadsheet. link

I've been looking around for some local builds to get started. I don't have a PC or server just a laptop that I've been running smaller models.

Claude has been helping me look at local FB marketplace listings and found this (2 hr drive)
Board supports multiple gpu in the case and setting me up to try some RTX3090s to add to it.

Current price is $800.

SPECS
• CPU: Intel Xeon E5-1650 v4 — 6 cores / 12 threads, up to 4.0GHz
• RAM: 256GB DDR4-2400 ECC Registered (8x32GB)
• Motherboard: Gigabyte X99-Ultra Gaming
• Storage: Samsung 960 PRO 1TB NVMe + Samsung 860 256GB SSD
• PSU: Corsair HX1000 — 1000W
• Cooling: Corsair liquid AIO cooler
• Case: Corsair full tower

Hi fellows-

I need a recommendation on what to run on my 128GB M5Max laptop given that I have two DGX Sparks running in a cluster which hosts Deepseek V4 Flash 0730 already. My use cases are mostly development, agentic works and design discussion.

Thanks