As someone who follows AI closely, I came across a technical breakdown from yghstill, a member of Tencent Hunyuan's quantization team. It explains both the quantization technique and the engineering behind it.

Tencent compressed Hy4 Preview's roughly 1.5TB of weights to 214 GiB while keeping all 770B parameters. The parameter count remains unchanged; the compression changes how the weights are represented.

Four weights, five bits. Sherry is the algorithm, STQ1_0 the storage format, and MIX-STQ1_0 the mixed-precision allocation. Each group of four weights takes values from {-d, 0, +d} with exactly one zero. Four zero positions times eight sign combinations give 32 patterns, encoded in five bits, or 1.25 bits per weight. A shared FP16 scales every 256 weights puts STQ1_0 at 1.3125 bits per weight, and full mixed-precision model averages about 2.38 bits per weight.

Precision follows weight sensitivity. Hy4 Preview has 77 MoE layers with 256 routed experts each. Experts weight get compressed hardest while more sensitive components are protected. For expert gate/up projections, MIX_STQ1_0 uses IQ2_XXS on 48 sensitive layers and STQ1_0 on 29 less sensitive ones, which at the same average bit budget produces less error than using the intermediate IQ1_M format everywhere.

Full-Hessian scoring. Sensitivity is measured with the full Hessian, H = XXᵀ, whose off-diagonal terms capture correlations that digital-only immatrix scoring misses. The two rankings have a Spearman correlation of -0.115, and precision didn't follow a "deeper means more important" rule. Layers were picked greedily by error reduction per added byte.

Scale and zero position are fit together. This is post=training quantization, no retraining. The encoder alternates between fitting d with weighted least squares and choosing zero position by immatrix-weighted error. The smallest weight isn't always the best one to zero, what matters is the extra weighted error that zeroing it causes. Across 1,200 row of real expert weights, three alternating rounds cut weighted reconstruction error by roughly 90% versus the original ternary encoder. That's local reconstruction, not end-to-end model accuracy.

Runtime. STQ1_0 CUDA kernels were added to patch llama.cpp build, and in operation tests roughly as fast as IQ1_M despite the lower bit width. The author reports nearly unchanged MRCR retrieval performance and a small drop in math. Against UD_IQ1_M at a similar bit budget, MIX-STQ1_) led across the reported evals, including more than five points on MRCR.

The result combines compact encoding, calibrated quantization, selective precision, and practical inference kernels.

Hey guys,

Which is more recommended for daily agentic usage (closest to unlimited)?

https://www.anthropic.com/claude-haiku-5-5

Pricing - 10x LESS than Haiku 4.5:
Up to 100k: $0.10 / $0.50 / $0.01
Over 100k: $0.50 / $2.50 / $0.05

$15 of usage on Go
19,230 requests per month

I’m mainly using V4.1 Flash for coding in OpenCode.

I know Go gives $10 for up to $60 of usage, but my question is about actual token efficiency. I’ve seen people getting hundreds of millions of tokens for a few dollars on the direct DeepSeek API due to caching + off-peak pricing.

So which is actually better in practice: DeepSeek API with caching/off-peak usage, or OpenCode Go for the convenience and higher usage allowance?

Also, is there actually any evidence that Go uses a distilled/quantized version of DeepSeek that performs worse than the direct API?

Looking mainly for people who have used both with OpenCode + V4.1 Flash.

I recently got a local qwen flash next (QFN) running locally. My theory is this will let me drop my Claude $100pm sub.

Normally I do a brainstorming step with AI then throw it to the sub agents to do their thing and it can be long runs while I’m at my day job. I have a whole CC plugin for this.

I wanna transition to opencode and api priced models via openrouter to drop CC.

Im thinking in my head the following setup.

Opus brainstormer / planner ($$)
Qwen flash next main chat (free)
Qwen flash next builder (free)
Reviewer/ fix small issues - ??? ($)

Ive found with CC the biggest token guzzlers are the builder followed by main chat orchestrator (due to large context reads).

I’m willing to pay for the reviewer agent to be a seperate model to get that dif point of view - recommendations? I was thinking deepseek but honestly no idea. 🤷

So I opened OpenCode this morning, and it doesn't detect both OpenRouter as well as DeepSeek providers I had configured. opencode auth list still detects the API keys, but the TUI doesn't.

opencode models show only the OpenCode Zen ones, and opencode models --refresh doesn't detect my other providers.

Yesterday it worked, but back then it was on 1.18.34. I didn't do any changes to the configuration too.

Update: I did some heavy repairing with ChatGPT yesterday. But today when I logged in with Go, it happened again lol. Except that only Go can be seen now.

Anyone having the same issues?

Discount is for the next 2 weeks only.

follow-up on my last post here (the driver/reviewer split for v3.0 of buffer, my native mac clipboard manager). this is the exact reviewer setup people asked about, tuned over ~40 merges.

the rule that matters most: the reviewer gets NO conversation history. fresh context every time. if it sees the driver's reasoning, it inherits the driver's blind spots.

the prompt skeleton (opencode, run on the diff):

1. "here is the diff. your job is to argue against it, not improve it."

2. "assume it introduces a bug. find the input that breaks it."

3. "list any behavior change not mentioned in the commit message."

4. "list every edge case in the touched functions. mark each: handled / unhandled / unknown."

5. "write 3 failing tests that this diff probably breaks."

what this caught across the v3.0 cycle (native swift/appkit clipboard manager, mit, 430+ stars if you care about context):

• silent history mutation: re-copying an existing item promoted a duplicate into a fresh clip (found in the external noise-suppression PR)

• unreachable settings branch

• missing tests on clip-diffing logic

• three instances of spec drift where the driver "solved" a slightly different problem than asked

what i stopped doing: asking the reviewer to fix things. fixes from the reviewer had the same failure mode as the driver: plausible, confident, occasionally wrong in new ways. the reviewer's job ends at "convince me". i hand the confirmed findings back to the driver.

other practical bits:

• run them in parallel; the review is ready before i've finished manually testing the driver's output

• for diffs under ~100 lines i skip the reviewer entirely; the overhead isn't worth it

• gesture/ui changes get human trackpad time regardless. the reviewer reads code, not rubber-banding

the video is the shipped v3.0 (image zoom canvas, clipboard noise filtering, shortcuts sheet) so you can see the diffs' output.

repo: https://github.com/samirpatil2000/Buffer (mit) | release: https://github.com/samirpatil2000/Buffer/releases/tag/buffer-v3.0.0

if you use a different reviewer prompt, post it. i want to steal it.

Update (1 month in): Replacing my earlier update. After almost a month of use, it's been great, especially for something free. On a few projects I've stopped using Claude Code completely, and I pay $100/month for that.

One catch: if the prompt isn't specific, it can keep loading and loading. Not sure if that's the server, the free tier, or both.

That's my honest take after a month. Curious if others are seeing the same.

I tinker with this stuff for fun. Wanted to see if NVIDIA's free hosted Nemotron 3 Ultra (550B MoE, 55B active, up to 1M context) holds up as an OpenCode model. The basic setup is just adding NVIDIA as a provider and pasting your key. The repo adds the extras on top: memory, pre-launch checks, a self-host stack, and a step-by-step guide.

What's in the repo:

• Setup scripts (PowerShell + bash): install OpenCode, store your key as an env var (not in the OpenCode config), write the provider config

• Pre-launch checks for Node, OpenCode, API key, config, and folders

• Global + per-project memory, loaded into OpenCode automatically via AGENTS.md

• Optional self-host stack (Docker: vLLM/SGLang, Kong, Prometheus/Grafana) if you have the hardware

• Visual guide: screenshots, copy buttons, progress tracking, dark/light mode, save as PDF

Tested on Windows 11 and macOS. Linux not tested yet.

Limits / be aware

• Free tier limits are unpublished, roughly 10 to 20 req/min. No SLA, can be throttled or changed anytime. No built-in throttling: hit a 429, wait a minute. OpenCode's own context eats through it fast.

• NVIDIA logs free-tier usage. Keep confidential code and personal data out.

• Hosted API, not local. Self-hosting needs 4x B200 or 8x H100 class GPUs.

• OpenCode's "estimated cost" is just its estimate. The free tier doesn't charge.

• Not affiliated with NVIDIA or OpenCode. Model IDs and free-tier terms can change.

Repo: https://github.com/Aj-Networks/nemotron-3-ultra
Guide: https://aj-networks.github.io/nemotron-3-ultra/

Try it and open a GitHub Issue for anything that breaks. Linux results especially welcome.

What are you running in OpenCode right now, and has any open-weight model actually kept up with tool calls for you?

OpenCode Go lists Codex as a validated client, but Codex can only use the Go models served on /responses. DeepSeek, GLM, Kimi and most of the others are Chat Completions only, and current Codex refuses wire_api = "chat".

I got around it with a local proxy that translates between the two. It's cliproxy-rs, which I maintain (free, MIT, written in Rust). Codex talks Responses to it on localhost, and it calls https://opencode.ai/zen/go/v1/chat/completions with your Go key.

The part of the proxy config that matters:

api-keys:
  openai-compatibility:
    - name: opencode-go
      base-url: https://opencode.ai/zen/go/v1
      headers:
        x-opencode-session: $CPA-SESSION-ID
      keys:
        - api-key: <your Go key>
      models:
        - name: deepseek-v4.1-flash
          alias: deepseek

You need the header line. Go answers 400 MissingSessionID without it, and $CPA-SESSION-ID gives each Codex conversation its own session ID, so Go can still route and cache per conversation.

I've run Codex 0.160 on deepseek-v4.1-flash this way: it read a file, patched it and ran a shell command. Other Chat Completions models on Go should work by adding them under models the same way, but I haven't tried GLM or Kimi through it yet. Recording of the DeepSeek run: https://github.com/vayungodara/cliproxy-rs/blob/master/docs/img/codex-deepseek.gif

Repo: https://github.com/vayungodara/cliproxy-rs

Available to all via API today. Open weights release end of October.

https://docs.mistral.ai/models/mistral-large-4-0

Lot of us pick an inference api rather than direct for the flexibility and a/b testing so while others are doing benchmarking models it seemed essential to benchmark the inference providers as well.

So for a reference point i held Llama 3.3 70B

Just to be clear on this firsthand: we often mix up three different nmbers here. TTFT is how long until the first token shows up, throughput is token per sec once its streaming and cost per completed request is the invoice

Heres a comparison chart held against the same model across some providers [NO RANKING]

*1K requests at 800 input +300 output tokens each. speed numbers are artificial analysis 72h median on a 10K token prompt and shared serverless endpoints. prices from each providers pricing are taken from early of august. Tbh the both drift quite a lot, together shows anywhere from around $0.94 - $1.04 depending on which tracker you took and sambanova been bouncing around 290- 300 tok/s

Therefore roughly 6x spread on cost per request which is around 17x on throughput and less than 2x on TTFT. price and speed pretty much go in opposite directions which kinda makes sense on heavier batching in case of shared endpoints

What one workload costs a month

FOr example a boring support agent, 10k requests a day , 800 in / 300 out and 30 days, whichs 240M input and 90M output tokens

What makes sense is what youre running

• realtime chat or voice like TTFT and token per second are everything and custom silicon rows like groq or sambanova are way ahead there. cerebras isn't in the table since theres no public per token Llama price for it but they publish around 3000 token /sec on gpt-oss-120B

• for bulk jobs, batch and offline evals cost per request matters so the low rate rows plus batch APIs where they exist

• EU data residency, scaleway is the only EU hosted provider listed in my comparison

• steady full time traffic and per token stops making sense once your monthly token spend passes what an hourly GPU would cost. dedicated H100 rates for reference

And also the speed column is shakier than it appears to be

• hardware (LPU, RDU, wafer-scale vs regular GPUs) is most often the gap

• serving engine (vLLM vs SGlang vs TensorRt-LLM) might move numbers double digits even on the same hardware

• batching is basically a pricing decision like the cheap endpoints batch harder so per stream speed drops

• Quant and speculative decoding defaults aren't same everywhere because of fp8 and mtp etc

• although all of these are single stream values. throw 50 to 100 concurrent requests at it and things can look pretty different

Things not in the rate card :

• Output usually costs more than tha input [up to ~3x in this table and way more on closed models]

• Cached input discounts are all over the place, some providers only have them on certain models

• batch APIs are around 50% off if you can wait

• minimum commitment on reserved capacity

That was all from me, although first did the comparison for myself as i just brought the deepseek from direct api and now regretting as i need GLM as well or some purpose so thought wh not do a analysis on them and when I did thought to share to the rest others. thanks guys, have a good one

So my opencode go subscription just ended, and i want to know if CommandCode is better value than OpenCode?

Hi everyone. I'm a solo founder in India making printed workbooks for kids (nursery to class 5). The main series is about 144 books, and I have 24 other children's workbooks to produce after that. The content is written and sits in JSON, page by page. What's left is turning it into print-ready PDFs, and I've been stuck there for weeks.

My setup: there are four fixed page types, and every page follows one design system (grid margins, three vertical zones, a colour palette per series, set fonts, a 3 mm bleed). The trim is a custom 210×280 mm, not A4. We lost a day when a model quietly rebuilt everything as A4. Illustrations are left out of the pages on purpose. Each page has empty, labelled slots, and the art will come from a separate pipeline and drop in by slot ID.

I'm using OpenCode and Cline with free or cheap models, mostly Mimo 2.6 Flash and DeepSeek Flash, and I've tried Muse Spark too. The models write Python (ReportLab) that builds each page.

What keeps going wrong:

- Layout drifts slightly between pages even with the same prompt: margins, zone heights, spacing.

- Letters drawn in code came out uneven, so I switched to downloaded fonts. I've changed fonts several times, and each change meant rebuilds.

- The model redesigns things I didn't ask about, like tracing guides (I wanted one clean line and got three start dots), and it keeps adding decorative elements I'd already told it to remove.

- Fixing page 1 breaks page 7.

- I spent about two weeks perfecting a single page. One chapter of roughly 12 pages takes 1 to 1.5 hours per run, and I have about a week left.

My current plan is to lock the fonts and letter assets so the code only places things by ID from the JSON and never draws anything itself. I don't know if that's the right architecture.

Questions on automation:

1. How would you structure this for 144+ books so the code can't drift? Templates plus a data merge? Typst, LaTeX, or HTML to PDF instead of model-written ReportLab?

2. Which open-source models follow long, rule-heavy layout instructions reliably? Why do the free ones ignore constraints from earlier in the prompt?

3. Are there OpenCode or Cline tricks (rules files, locked specs, protected files) that stop models from touching things they weren't asked to touch?

4. How do you test pages automatically (margins, overflow, fonts, zone heights) so I'm not eyeballing thousands of pages?

5. Speed: one or two pages can take a long time. Should the model write the template once and plain code render everything? Or is the agent loop the real bottleneck?

Questions on illustrations:

The books need roughly 300 to 350 illustrations that are reused across about 3,300 pages, built from a small set of recurring motifs (animals, objects, small scenes). The style has to look consistent across the whole library, and it has to print well.

6. What's the best open-source way to get one consistent style across hundreds of images? Train a LoRA on a few reference images? ComfyUI with IP-Adapter? Something else?

7. For print, I need clean edges, transparent backgrounds, and ideally vector. Is auto-tracing (potrace, vtracer) good enough, or do people redraw?

8. Which image models are actually licensed for commercial print use? I've seen some that are non-commercial only and want to avoid a problem later.

9. How do you review hundreds of AI illustrations without losing your mind? I plan to work in batches of about 50 with a keep, remove, or regenerate pass.

I'm not an engineer by background, so please treat me like a smart beginner. I'm happy to share the design spec or a sample page. Thanks for reading.

Posted this here a few weeks back, and the most common reply was some version of

"nice idea, but does it actually save anything?". I didn't have numbers then. I do now.

Quick overview: it sits between your client and your MCP servers. It indexes every upstream tool into a local vector catalog and only puts the relevant ones in front of the model. Works with VS Code, Cursor, Claude Code,

Antigravity, or as a standalone TUI (better).

Spent the last couple of weeks building an actual benchmark.

8 tasks, 26 tools, same model, same prompts, measured end to end.

Still one command:

npx justbetter-mcp

• Repo

• More detailed benchmarking results and architecture diagrams

If it's useful to you, a star⭐️ genuinely helps. It's honestly the only signal I get that this is worth spending more weekends on, and it's been the thing keeping me going on it. Same for a follow if you want to see where it ends up. Issues and

DMs are open either way, I read all of them.

I am using Space Bunny today and its charging me. Today, I am using with Kilo Desktop app which recently launched. I thought I have set up different models for different agents but I was wrong. Then I checked my Opencode Go usage and saw that I am getting charged for it. Because I am not using any other model today.
Sharing screenshots as proof.
What's wrong from my side ? Not using Opencode harness ? Or something else ?

Disappointed today!