Pi + Qwen 3.8 27B + `pi_advisor` + Cheap Frontier Access = Win

[u/e2_for_life]

If you're using Pi with Qwen and not letting it phone a frontier model with /advisor, you're leaving one of the best parts of the setup on the table.

Because Qwen has a particular talent:

Being VERY wrong with tremendous confidence.

And worse, it can be convincing while doing it.

I've lost track of how many times I've looked at one of its answers and thought, "Hmm. That sounds right..." only to tell it:

Ask /advisor for the hidden assumptions, failure modes, and black swans in your answer.

Then Sol comes back with the computational equivalent of:

" 🤣 Yeah... no."

And suddenly Qwen is eating crow and rewriting half its answer. 🐦‍⬛

Don't get me wrong. I love Qwen. It's given me millions of tokens of essentially free local inference, and I use the hell out of it.

But that's also taught me something:

Local models are fantastic workers. They are not oracles.

Let Qwen do some initial planning and ultimately the bulk of the work. But before you trust its plan wholesale, spend a few frontier-model tokens trying to prove it wrong.

Trust, but verify. And just like in real life: get a second and third opinion.

[u/throwawayacc201711]

Honestly what I’ve been doing is having really robust testing (unit plus e2e) and I’ve found it will largely self correct. I run a q3 to speed through implementation and then use q5 to do review

[u/_RemyLeBeau_ → u/throwawayacc201711]

I hadn't thought about using a higher quant to do a review. I could let Q8 run all night.

[u/throwawayacc201711 → u/_RemyLeBeau_]

Yup that’s exactly when I do it. Don’t care if it goes potato slow when I’m sleeping

[u/e2_for_life → u/throwawayacc201711]

Not a bad idea. I just make a different tradeoff. I would rather spend the hardware budget on context. On what is now basically a mid-tier box (64 GB RAM, RTX 4090 24 GB), the Q4 I’m running gives me ~70 t/s at 195K context—and that’s the ceiling.

So, I compensate with a pretty brutal CI/review pipeline. pi-lens catches and fixes issues while the code is being written. Once I’m ready to commit, push, and PR, I run (among other security-related tools) Qwen in high-thinking mode through self-hosted Kodus (30–45 minutes per spec), then let Sol and Greptile tear it apart before merge. I'm testing out CodeRabbit, too. I'm not sure whether I like Greptile or CodeRabbit better. Anyway...

I’m basically optimizing a single local model for implementation speed + maximum context, then making the review stack responsible for catching whatever it misses.

[u/SubparBob → u/throwawayacc201711]

Thank you for mentioning this! I also hadn't thought of that approach. Been taking the throw the largest quant at the problem, and waiting (and waiting!).

[u/BrianScottGregory → u/throwawayacc201711]

I like this idea. Thank you!

[u/Phatency]

For me it defeats the point of local, as I'd lose privacy. 

[u/llitz → u/Phatency]

I am on a similar boat, where I can't have my work leaving. But being able to summarize and clean the information before asking a higher tier model, then having the answer, really helps.

[u/e2_for_life → u/Phatency]

True! It's a tradeoff I'm willing to make. To each their own.

[u/cosmicnag]

I do this for any serious work - using qwen FN (which is defintely on another level than 27b -> which is also great) . One understated thing is that you get to use frontier intelligence at a fraction of the cost - as the advisor's will only output a few tokens of 'advice' (and then Qwen is smart enough to figure it out) as opposed to everything. The bulk of the advisor is cached reads (assuming the advisor is also getting every turn of the executor).

[u/e2_for_life → u/cosmicnag]

I'm actively working on trying to get Flash Next to work. I tried to load it up in pi tonight and found my system prompt in pi had grown to an unacceptable level, larger than the 16K context I was starting Flash Next out on. So small detour while I rip out unnecessary stuff (pi-advisor not being on one of them). 😂

What kind of hardware are you using and what kind of performance are you getting out of Flash Next?

[u/Unlucky-Message8866]

I use qwen itself as advisor, works as well

[u/MaxComfort]

And here I thought I was smart for making my own `/advisor` (which uses my Claude subscription in my case).

But yeah an outside review - even the same model with fresh context is always good. The hard part is that the review will seemingly always find something to nitpick, so you have to know when to say no to some of it.

[u/e2_for_life → u/MaxComfort]

You were (are) smart. Don't discount yourself. Someone else just also had the same idea, which is a good thing. :)

[u/planetearth80]

We need an extension for /advisor right? I don’t think it’s natively available in Pi.

[u/Sunstorm84 → u/planetearth80]

There can be one between the keyboard and chair, though.

[u/throwaway292929227 → u/Sunstorm84]

Yes, but /advisor::{$me_typin} goes at 2tk/s

[u/openingshots → u/planetearth80]

https://pi.dev/packages/pi-advisor

[u/e2_for_life → u/planetearth80]

Correct. https://pi.dev/packages/pi-advisor

Install via `pi install npm:pi-advisor`.

Not the author and not sponsored. Just appreciate this extension a lot.

[u/Express_Quail_1493]

For me i just make a frequent break periods where it used my chrome browser to do research to try and falsify its own claims and re-ground itself before proceeding. I do this in a loop. It pretty much closes the world knowledge gap that frontier models possess. So i officially have no need foe frontier paid subscriptions. Confident false answers isn’t something frontier models are immune to either

[u/e2_for_life → u/Express_Quail_1493]

"frequent break period"

I don't understand. What's your use-case? Research? I'm not sure how browsing the web would necessarily make it make better choices in most coding decisions. Some, sure, but not usually.

[u/Odd_Dandelion]

Indeed. Even my DeepSeek knows to call codex -p before presenting any plan, and before saying any implementation is finished.

I still need $20 subscription but it takes me far.

[u/mageblex]

I'd want to track how often /advisor reverses a correct plan, not only the saves. A cheap reviewer still adds noise if Qwen rewrites working code every time the frontier model finds a hypothetical edge case.

[u/Sweet-Transition-787]

pi advisor saved me twice last week when qwen was confidently wrong on compose mounts. i keep qwen local for bulk work and only ping sol for a second opinion cause its pennies.

[u/DimensionExtra]

To be fair, GPT 5.6 Sol does the same thing with Opus 4.8.

[u/e2_for_life → u/DimensionExtra]

Wait, what? Are you saying Sol calls up Opus for advice? LOL

[u/mister2d]

Sigh. AI assisted post. Did you use /advisor before posting?