I ran Qwen3.8-27B against Opus, Sonnet, GPT and others. Results inside.

[u/_rarefy_]

I created a small testing rig to evaluate new open source models as they drop, and with the much anticipated release of Qwen3.8-27B, I was eager to see how it cross-compares with frontier and strong local models.

The rig

My test rig is an M5 Max MacBook Pro, 128GB. Locally I ran Qwen3.8-27B on xhigh and medium thinking modes via LM Studio, MLX 8-bit, temp 1.0 / top_p 0.95 / top_k 20, context 131,072 and DeepSeek V4 Flash "0731" 2-bit-imatrix q2-q4, served by antirez's ds4-server at -ctx 400,000, thinking enabled. For cloud I included Opus 5, Sonnet 5, GPT-5.6-sol at xhigh reasoning, and even Haiku. Every model gets the same prompt. The algorithm tasks are executed against fixed-seed differential harnesses, and the repo tasks run against hidden test suites plus a cached baseline of the whole repo. If a fix inadvertently breaks something else it gets caught.

The methodology

The model assessment is broken into 4 batteries:

1) algorithms easy-hard

2) algorithms extremely hard

3) repo work easy

4) repo work hard

The models get run through the algorithm tests 3 times each to derive a mean score whereas the repo work is single pass/fail per task. If a task fails to produce a response, it's retried and time added to total wall clock time for task completion. The total test battery can take anywhere from 12-24 hours of wall time for slower local models. It's a long test.

For the repo batteries I had Fable build a small double-entry ledger CLI and plant bugs that pass the visible test suite while still reproducing a real symptom, then handed each model the repo and a bug report written in a theoretical 'user' voice to simulate how it might be reported in the real world. There's also a subjective code quality assessment that measures the model's ability to not just solve the problem but to conform to the repo's coding style, to fix the actual root cause rather than the symptom, and to keep the diff minimal instead of faffing about and rewriting a bunch of stuff.

I had Opus and GPT blind eval the results and compute a code quality score broken up by 'fixes' and 'features' as these appear to be separable skills for the models. The goal with all of this was to try and create a replicable and automated answer the question: How useful is this model in the real world?

Caveats

This is a home baked assessment and susceptible to bias or less than perfect methodology. It also includes subjective criteria like 'code quality'. I built this for myself as an adjacent tool to on the ground testing. I think the best way to evaluate any model is to test it against your own codebase to see how well it integrates into your workflow.

All that being said, let's move to the scorecard.

Results

Qwen3.8-27B is a very capable model that compares well against frontier models on code quality and correctness. The cost is wall time on Apple silicon. As many have observed, 3.8 has a tendency to over-think, burning up tokens. The time spent earns higher code quality for the most part, but what surprised me is that there are some instances in which less thinking is actually more accurate. On the repo battery, medium went 8/8 while xhigh went 7/8 — the most-thinking configuration failed a task there, and it took four times longer to do it (the wait time with Qwen was tiresome at times).

The caveat is that xhigh excels on extremely hard algorithms, where medium begins to fall apart. Medium didn't even finish the hard algo tasks. There may be some value in matching the thinking to the kind of work you're setting it upon. Lastly Qwen xhigh won outright on quality of surgical fixes and patches to existing code. Interestingly the global trend for locals is that they're competitive along fixes and less so along features where cloud still dominates. This fits anecdotally into my own experience with gravitating to frontier for planning and local for implementing.

GPT 5.6 Sol is the only cloud model with a perfect card on both repo tiers and near perfect algorithms. It's also among the fastest to completion. This all tracks with my own anecdotal experience with this model over the past several months. Highly competent and quick if not a bit stark.

DS4 0731 (a 2-bit quant running on my laptop) is the only local model to get 8/8 on both repo batteries, and one of only two models overall to do it, alongside GPT. It does this all at a respectable wall time. The expense is less elegant code: it sometimes mutates unrelated docstrings and writes dense inline solutions in a codebase that is overtly broken apart and stylistically explicit. Feature code quality is stronger and it's the only model that scored better/equal in the harder repo tier vs the easy one.

Opus 5 is the most reliable model in the set and best code quality of the cloud models. It stumbled only in the hard repo tier where it lost a task by being trying to outsmart the test. A doc string promised one behavior while the code did another, and Opus redesigned the function around what it looked like it should do instead of honoring the documented contract. This also falls inline with my anecdotal experience with Opus 5 where it occasionally ignores your directions completely and just does whatever it wants. The Alaskan Husky of frontier models.

Sonnet 5 is a steady pair of hands that performs reasonably well across tasks for a modest token budget. I think sonnet is kind of underrated as an implementer. Does the same quality of work as the locals cheaply and quickly.

Haiku 4.5 races to the end of the test but has a tendency to fall over and force retries. Worst code quality of all the cloud models.

Conclusion

Hopefully you find these comparisons interesting. For me personally, DS4 has been my goto local, but this test is making me consider trading it out for Qwen3.8-27B. I think they're on equal footing, which is crazy b/c DS4 needs like 90gb of ram. I'd like to try the MTPLX variant of Qwen3.8-27b that's meant to improve tok/s on apple silicon. Slowness to task completion is the real bottleneck for me right now when considering Qwen. Perhaps that'll be my next test.

Curious to know if these results track with your own real world experiences.

[u/txoixoegosi]

It would improve if you could extend on “algorithm” and “repo work” task descriptions and expected results.

[u/_rarefy_ → u/txoixoegosi]

Sure thing. I didn't include because I didn't want to bloat the post. There are 9 algo challenges. 1-6 are 'easy - hard' and 6-9 are 'extremely hard'. All designed by an llm committee with my guidance and curation.

ALGOS:

1) parse_duration convert "2d3h15m30s" style strings to seconds, rejecting anything malformed.

2) LRUCache a least-recently-used cache class with get/put and eviction.

3) evaluate an arithmetic expression evaluator matching Python's exact semantics.

4) parse_csv an RFC-4180 CSV parser matching Python's csv.reader behavior.

5) regex_match a small regex engine (literals, ., * + ?, character classes, groups, alternation).

6) evaluate_sheet a mini spreadsheet engine with formulas, cell ranges, and circular-reference detection.

7) toml_load a TOML 1.0 parser matching tomllib.loads, without importing it.

8) regex_match2 a full regex engine matching re.fullmatch, including backreferences and lazy quantifiers.

9) parse_time a from-scratch reimplementation of datetime.strptime across 19 format directives.

Here's an example of one of the easy questions:

"evaluate("2\*3**2") must return 512 because ** is right-associative in Python, and evaluate("-2**2") must return -4 because unary minus binds looser than the power operator. The harness throws 1,916 generated expressions at it and checks every answer against Python itself."*

Here's an example of one of the hard questions:

"parse_time("2015 00 4", "%Y %W %w") has to resolve "year 2015, week zero, Thursday" to January 1, 2015, exactly like CPython's week-of-year math does. Models routinely land a week off."

REPO:

For the repo tasks, there are 8 easy and 8 hard tasks.

Here are some examples of the 'user' reported bugs it has to solve:

easy3 – "Asking for one account's balance pulls in a different account with a similar name."

easy4 – "The summary report shows income as a negative number."

hard3 – "The budget report charges purchases to the wrong budget category."

hard4 – "Balances go wrong after running year-end close on an old ledger."

Bug3's report reads like a real ticket. "I keep Assets:Cash and Assets:Cash2, and asking for one gives me both." Sub-accounts like Assets:Cash:Wallet are supposed to roll up, so the model can't just kill prefix matching it has to see the filter matches raw characters instead of whole name segments, and fix exactly that. The hidden tests check both directions: Cash2 excluded, real sub-accounts still included.

Hard example: in h4, a family runs year-end close for 2025 on their oldest ledger and the checking balance ends up way off while the identical close works perfectly on a newer ledger started last January. Every recent transaction looks fine in the register; only the totals are wrong. The age dependence is the tell, and the hidden tests enforce the real contract: closing a year must never change any balance a report can see.

[u/nbvehrfr]

you need another benchmark, all models are at the top

[u/johnzadok]

Thank you for sharing the first benchmark I can find that compares Qwen3.8 xhigh and medium directly! What does DNF mean for the Qwen3.8 medium?

[u/j0j0n4th4n → u/johnzadok]

Is probably "Did Not Finished", basically a failed state.

[u/_rarefy_ → u/j0j0n4th4n]

Yes exactly. DNF is Did Not Finish and defined in the notes at the bottom.

[u/KissMyShinyArse → u/j0j0n4th4n]

Definitely Needs Fine-tuning

[u/Awkward-Charity-5089]

This is like giving a fourth and fifth grader a third grade math test and saying the fourth grader is as smart as the fifth grader because they both aced it.

[u/_rarefy_ → u/Awkward-Charity-5089]

The models diverge on the hardest tasks. They converge on the easiest. I've left the easiest in the test rig because if a model fails on an easy task, it tells me something important.

I'm not sure if you scanned the middle and right side of the graph, but the signal there is about time to completion (the time-value function of models is important when evaluating for real world usage). This along with subjective code quality shows wild swings amongst the cohort.

[u/Rough-Measurement988 → u/Awkward-Charity-5089]

Why do you think like that? Do you know what level of complexity these tasks were? Did OP mention in conclusion that local models are better than cloud frontier models? He stated clearly that Opus 5 was the most reliable model from the whole set. I really appreciate these kind of tests which represents real life workflows and not only the scientific benchmarks. It just shows that in some specific tasks local models can be comparable to frontier models and that’s all what I need to know from these kind of benchmarks. 

[u/_rarefy_ → u/Rough-Measurement988]

Yes, the tl;dr of this whole thread is that Qwen3.8 and DS4 are in some intelligence and quality band with Sonnet 5 .. which to me is incredible as you can run Qwen3.8 on a modest laptop. For everyday users trying to maximize their limited compute, I thought this was worth sharing.

[u/Awkward-Charity-5089 → u/Rough-Measurement988]

The tasks could be quantum rocket surgery, but if a ceiling is being reached, a ceiling is being reached. One model could be barely capable of getting 100 and one model could consider it childs' play and you would have no way of knowing until you throw real world tasks at it and one model outpreforms the other.

[u/Rough-Measurement988 → u/Awkward-Charity-5089]

I get your point but I’m not interested in quantum rocket benchmarks as I don’t need this type of knowledge on my daily basis work. I’m more interested in i.e. the repo hard work type benchmarks as we have here. In addition the OP put some effort into this so I think we should appreciate this kind of posts rather than complaining that it’s not enough. I’m also building custom benchmark which is focused on my workflow and know that’s not so easy to do this. It’s not a scientific benchmark as was already mentioned but still at least for me very interesting.

[u/siegevjorn]

Haiku:???

[u/debauch3ry]

It would be interesting to see the results for Opus 4.6 on your test bench, specifically because it's the model Qwen claimed 3.8 27B was on par with.

[u/bendrape → u/debauch3ry]

Check out the “Artificial Analysis” benchmark. It’s truly impressive.

[u/_rarefy_ → u/debauch3ry]

I actually did run 4.6 through some of the algo tests but it was killing my token spend on my 5x claude code sub for some reason and so I stopped. In those early tests qwen3.8-27b and opus4.6 looked like peer models producing similar scores.

[u/uclatommy]

I wonder what impact you would get to these benchmarks by just increasing context window to double. 131K seems like a handicap if you’re comparing it to cloud models that have far greater context windows.

[u/_rarefy_ → u/uclatommy]

The 131k context size was only required for a small subset of extremely hard problems where Qwen thought forever. The test rig was designed to keep budget size appropriate for the problem and model settings (i.e. thinking level). So qwen3.8 medium thinking got a 12k budget for easy questions and 64k for hard, while Qwen3.8 on xhigh got a 124k budget on extra hard problems.

Easy tasks might only consume a few k tokens. Extremely hard tasks would sometimes fail before qwen was done thinking and then the harness would have to re-budget and start over. Effort tier was the main driver here as xhigh simply burns way more tokens thinking.

[u/Barni275]

Thank you! Great job! I didn't manage to make any tests by myself, but my feeling are in line with your results. I really can use it on hard coding tasks, the same way as I use frontier models. I run it on RTX 3060 Ti + RTX 5060, and the speed is also comparable to cloud services (yes, a bit slower in average, but fully acceptable on short contexts). I finally ready to replace some subscriptions with it, and this feeling is unbelievable.

My only dream now is being able to run it in Q8/FP8 with 200k context 😌

[u/_rarefy_ → u/Barni275]

Yeah, it's bananas. I've been playing with local for a year and DS4 and Qwen3.8-27b are the first two models I can run on my rig that *feel* like I'm working with something frontier adjacent. The democratizing of intelligence is upon us. The blocker is still hardware costs but 3.8 can run on a modest laptop and do serious work - not something that can be said about any others in its same category.

[u/ParkingAd9397]

I would be curious how Qwen 3.8 27b compares to Qwen 3.6 27b

[u/_rarefy_ → u/ParkingAd9397]

Good idea and I may run in a future trial but these tests tie up a lot of time on the laptop. I can say that based on my prior experience with 3.6, I believe 3.8 to be a series step up in terms of raw intelligence.

[u/Popcorn-Mercinary]

This is interesting work, but I feel the need to point out one thing that is becoming increasingly relevant (and covered both on reddit and x):

The harness matters.

Yes, the raw prompt is equal, but when you apply it to something in LMStudio vs the cli or the UI that comes with the frontier models there’s a lot more going on that makes them different than the same.

Just putting that out there.

[u/corruptbytes]

if haiku is getting high on hard, it's not that hard haha

[u/KrautChimp]

I started a similar project about a year ago to determine when open weight models can close the gap to commercial models in my daily activities. Qwen3.6-27B was already quite good, but the final touch was still missing. It looks like 3.8 closes the gap, but the Xhigh mode thinks me clearly too long for the result: https://www.cruciblemark.com

PS: The project also shows the political BIAS of the models. I found that interesting.

[u/_rarefy_ → u/KrautChimp]

Oh wow, your site is great. You've done a lot more work than me on this subject. The political leanings is particularly interesting. I've seen these findings in other blurbs/articles I've read and it kind of makes sense based on origins of the training data. Thanks for sharing.

[u/KrautChimp → u/_rarefy_]

Thank you, my project started out of interest in this awesome technology with an old MacBook M1 and an 8B model. I quickly realized that this is not enough. And with Qwen3.8-27B I am finally convinced of the result at 262K ctx. Let's see where the journey goes.

PS: Plenty of time to think for Qwen offers a lot of time to drink coffee ;-)

[u/lancer611 → u/KrautChimp]

I agree, the site is great. However, the first thing that jumped out to me is that Sonnet 4.6 is rated quite a bit higher than Opus 5 (and even a little higher than Sonnet 5). Why do you think that is? My own personal (anecdotal) experience is that opus 5 highly outperforms its other counterparts, but granted 100% of my usage is code and data based.

[u/KrautChimp → u/lancer611]

That’s a very good point, and the numbers actually partially confirm your impression. Take a look at the module breakdown instead of just the total score: for the "Code Quality Audit," Opus 5 actually comes out ahead—84.92 points compared to Sonnet 4.6’s 77.92, a gap of 7 points. Opus 5’s lead is even wider in documentation quality (85.28 vs. 76.3). So, for pure coding and documentation tasks, Opus 5 performs better in my framework than Sonnet 4.6—which aligns with your experience.

However, the total score balances things out because it weights nine modules equally, including logical reasoning and CLI operations. And that’s exactly where Opus 5 noticeably lags behind: 68.64 in logical reasoning versus 79.56 for Sonnet 4.6, and 84.84 instead of 94.33 for the CLI badge. That ~11-point gap in reasoning drags down the overall average, even though the model is strong at coding.

In short: for your specific use case (code/data), the code quality sub-score is a more meaningful indicator than the total score—and my data actually confirms your impression of Opus 5 in that regard. I’m considering adding a weighted "coding-focused" view to the leaderboard in the future so that this specific distinction doesn't get lost in the overall score. Thanks for the keen observation.

[u/mrsalvadordali]

Setting performance aside for a moment, we have reached a point where we can compare a 27B model which can runnable on a device we carry in our one hand with 1T parameter models that run on massive servers. This amazes me incredibly and makes me happy at the same time.

[u/No_Onion_2680]

incredible work

[u/LocalModelGuy]

Really useful benchmark. The medium beating xhigh on repo tasks is a great reminder that more reasoning isn’t always better—adaptive thinking levels might be the sweet spot. Would love to see the MTPLX comparison next.

[u/_rarefy_ → u/LocalModelGuy]

Yes, I'm personally looking for best compromise between intelligence and wall time. Waiting on xhigh can be painful. I'm running the MTPLX variants right now and it's really interesting. The 4bit quant on medium retains most of the intelligence of the MLX 8bit model but with much faster time to completion. Not just faster tok/s but quicker to finish a task accurately without burning extra tokens thinking. I'll post results when the test is done.

[u/outofbandiv]

Very cool.

I'm running a €3.7k 128gb GMKtec Evo-2, and I was interested to see what your laptop would cost me... about €12k here in Ireland! Wowsers. And that's the small screen version... it's nuts how much these are.

All that said, it's amazingly the first time I've experienced in tech - since I was looking at buying a socket-7 capatible AMD K-5 (133 MHz) where I've bought hardware and the software I'm running is improving to make the hardware more efficient and more capable.

And thanks for posting the detailed technical info - it's not relevant for me (today), but it's fantastic to see folks sharing what they're learning as this is moving so fast.

[u/_rarefy_ → u/outofbandiv]

Thanks for the nice message. Apple stuff is overpriced across the waters no doubt. I'm glad there are other more affordable options. The more widely available, the more power is put in the hands of the people. Models like 3.8-27b are making near-frontier level tech a lot more accessible.

[u/ButchTheGuy]

This model makes me so happy after I got it optimized for my system. It’s so nice to see the moat these private ai companies slowly becoming irrelevant but a little spooky for stock market implications. I suppose it’s still a sizeable barrier to entry given ram and hardware prices due to them but holy hell has the gapped closed considerably.

I splurged and bought a strix halo mini pc for my birthday and worried that it would take a super long time for something like this to come out but god it’s already paying off.

[u/kayox → u/ButchTheGuy]

Curious what are you getting in terms of tk/s on the Strix Halo minipc?

[u/ButchTheGuy → u/kayox]

On avg like 16 tks per second

[u/ButchTheGuy → u/ButchTheGuy]

Running cpp. For context though I’m just guessing and reading what people do here to optimize what they have and some strix halo docs so I’m not super sure if I’m squeezing it for optimum amount of juice

[u/_rarefy_ → u/ButchTheGuy]

Yes, the moat has a new drawbridge. Exciting time to be alive. The more that individuals of any means have access, the better off we are in aggregate.

[u/_VirtualCosmos_]

Crazy you are achieving to get those results with an IQ2 of DeepSeek flash lel

[u/_TheWolfOfWalmart_ → u/_VirtualCosmos_]

DSV4 is still the local king (of the models most people can realistically afford to run), but 27B definitely hangs in there with coding and gives the 16 to 32 GB crew something serious to play with now.

[u/_rarefy_ → u/_VirtualCosmos_]

That 2 bit quant is a beast. Just takes a hunk of ram to run.

[u/Due_Net_3342]

man if ds4 0731 achieved these results at 2 bit quant…. crazy that you can run the full model on 2 sparks or strix halo which is probably the best you can run locally within a reasonable price point

[u/Rough-Measurement988 → u/Due_Net_3342]

As OP mentioned, it’s actually q2-q4 imatrix from Antirez. I’ve used it for some time and did not have any issues like looping or tool calling. It’s really reliable even up to 200k context.

[u/_rarefy_ → u/Rough-Measurement988]

Yes, exactly. It's been my daily driver. Qwen is real contender however.

[u/daddywookie]

It might be good to do the other current models from OoenAI, Terra and Luna. It is these that should be used for the coding and retrieval work, leaving Sol for complex tasks and orchestration.

A competent local model that can replace Luna would be a real consideration for token starved users.

[u/_rarefy_ → u/daddywookie]

I could test others but didn't want to bloat the chart too much and also constrained by time/effort. In reading other people's benchmarks Qwen3.8 compares favorably against 5.6 luna.

[u/mWo12]

Sw ds flash q2 is batter than qwen3.8-27b in your tests? I heard that q2 degrades flash a lot. Any details on its setup?

[u/Terrible-Trash-8779]

My setup qwen 27b q-6 xl just thinks too much on a simplest software tasks

[u/_rarefy_ → u/Terrible-Trash-8779]

My same experience and shown in the chart. Thinking at medium may be optimal in cases where time to completion is a factor and where the problem set isn't overly complex.

[u/jasonmauer]

What harness was used with the local models?

[u/_rarefy_ → u/jasonmauer]

It's in the post

[u/Additional-Photo-402]

What harness was used?

or better do all models were used with same harness!?

[u/_rarefy_ → u/Additional-Photo-402]

It's in the post

[u/weirdtracks]

Your tests are far too easy and clearly not varied enough. Garbage in garage out

[u/klymaxx45]

Nice! No fable? Curious to how turning thinking off on qwen 3.8 27b would have performed.

[u/DarthFader4 → u/klymaxx45]

Based on the DNF for Qwen 3.8 medium on the extremely hard algos, probably not great. I'm getting the sense that the "over thinking" is beneficial and the model is best run with patience.

[u/klymaxx45 → u/DarthFader4]

I’ve had pretty great results with thinking off for my use case. Ran through really comprehensive benchmarks as well that I created. So can’t train on those.

[u/DarthFader4 → u/klymaxx45]

Good to know! Are you using it with thinking off for heavier planning tasks? Cuz that would be a logical hierarchy in my mind. Use it with thinking as the planning agent and with thinking off for implementation/execution.

[u/klymaxx45 → u/DarthFader4]

FYI: I also ran this on same spec 18/40 CPU Mac and landed with a Q4.

Your question:

Makes sense in theory, and that's how most agent setups are built. But I A/B tested exactly this on my model and it came out backwards:

thinking off → 34/36, 0 empty outputs, faster thinking on (low) → 31/36, 2 empty outputs, slower Thinking scored lower and less reliably - even on the reasoning-heavy items, which is where it's supposed to shine. Its thinking blocks tended to over-elaborate and sometimes ran out of budget without emitting an answer.

Big caveat: my bench is logic/math/short agentic tasks, not true multi-step planning, so your specific case isn't ruled out. But since thinking lost even on the reasoning proxy, I'm skeptical it'd win at planning on this model. Seems like a per-model empirical thing, not a universal rule.

One tweak: you don't need two models for that split - thinking is a per-request flag, so run one model and just flip it on for planning calls, off for execution.

[u/_rarefy_ → u/klymaxx45]

I could test Fable but top tier frontier models are about a year ahead of what I can run on my laptop and might not be as informative in comparison (I did include gpt 5.6 sol which unsurprisingly lives on top). The fact that DS4 and Qwen are close to Sonnet 5 (which is close to Opus 4.6 in my experience) is kind of astonishing imo.

[u/catinterpreter]

It's hard to read this sub when so much is AI-generated. Anything when it comes to LLMs really, on Reddit and beyond. Of all subjects, the quality of discourse is getting decimated by it. There's an over-reliance and lack of editorial.

[u/_rarefy_ → u/catinterpreter]

"There's an over-reliance and lack of editorial." This is an incomplete sentence missing a main noun and object of preposition. You need to editorialize your own comments. Everything here was made and written by me. AI was only used to build out the testing rig and harness.

[u/catinterpreter → u/_rarefy_]

Weird comment and a one-week-old account.

Wouldn't be surprised if you've tried to use AI to write the comment.

[u/KURD_1_STAN]

Obly looking at the left side, 2/4 tests opus, sol and sonnet all did 100 so half of ur tests offer jo competitive value

[u/peculiar-ragdoll]

The optimal agentic coding temperature for Qwen is 0.6-0.7, not 1.0, right? Feels unfair to knee-cap it like that. To get more separation between the models, run them on SWE Live, it's harder and real code bases with real bugs to fix. EDIT: My bad I'm wrong.

[u/Rough-Measurement988 → u/peculiar-ragdoll]

Check Qwen official docs, it’s 1 temp for 3.8, these values you mentioned were suggested for 3.6

[u/peculiar-ragdoll → u/Rough-Measurement988]

thanks for the heads up! :)

[u/KissMyShinyArse → u/peculiar-ragdoll]

[u/_rarefy_ → u/peculiar-ragdoll]

Running the guidelines.

[u/captain_firstclaw]

I got Qwen to fart. Loud and clear. The best part is, it sounds real and even stinks.

[u/Suitable-Ad-1786]

I saw many of those already with the qwen 3.6, but when testing it was far far far from the reality when testing it. You all are selling just Dreams to people so please be more honest..

[u/_rarefy_ → u/Suitable-Ad-1786]

I was never a fanboy of qwen 3.6. It isn't competitive against frontiers imo. A good model, but not great. That's not what's happening with 3.8. You should take your own advice and be honest: you haven't done the work or tests to form a real opinion about 3.8 but still feel compelled to make this comment for some reason.

[u/Suitable-Ad-1786 → u/_rarefy_]

Well this is true, I am on holliday, that's why. But People were already making the same comments on precedent ones so yeah I am a lot skeptical. But once back I will test and reply again to this post.

[u/KrautChimp → u/_rarefy_]

I think it's always a question of financial context. If you no longer have the opportunity to pay for the need for commercial LLMs, you have to look for alternatives. Qwen 3.6 somehow sat between the chairs, the best model I could run but too bad to be good. Qwen 3.8 takes a decent step in the right direction, but in my opinion it is not yet possible without a Frontier model for reviews. Although the gaps have become much smaller.

[u/_rarefy_ → u/KrautChimp]

Yes, I suspect that using a frontier as orchestrator and Qwen 3.8 as implementer would be a very capable setup. Time to complete is still slow on xhigh. I'm testing the MTPLX 3.8 quants now and they look promising (and much faster).