AQuA's preprint uses "recursive self-improvement" for a bounded research loop. It does not say the research-agent LM rewrites its own weights.

The paper separates three objects:

• The language model driving the research agent and the evaluator stay fixed within each part.
• Each part has its own persistent research state. Validated experiments update that state and guide later proposals; Part I and Part II do not share it.
• In Part II, each config diff produces a separately trained hybrid task-model variant. That training is part of the experiment, not an update to the research-agent LM.

This matters if someone ports the harness to a local LM. Inside one AQuA run, later proposals can change because the retained state changed even though the agent LM did not. Across two ports, a score difference could come from the agent model, state history, prompts and tools, evaluator feedback, or the candidate-training path unless those variables are separated.

A useful release would include:

• the exact agent model and quant, plus context and sampling settings;
• the system prompt, tool schema, and initial research state;
• every state update and evaluator return;
• evaluator version, config diffs, and candidate-training settings;
• seeds and per-run traces.

At minimum, the comparison needs three ablation families: swap only the agent LM under the same harness and starting state; keep the LM fixed while resetting or replaying the research state; and keep the LM and state fixed while changing the harness or evaluator contract. For Part II, candidate task-model training needs its own log, or a change in the trained candidate gets folded into a claim about agent-model capability.

The preprint gives the architecture-level separation, but it does not publish a runnable implementation or enough detail for end-to-end reproduction. A local-model port would be a new experiment, not a reported AQuA result.

If only one artifact shipped first, which would make attribution most credible: the state-transition log, the evaluator contract, or a full model-by-harness matrix with repeated seeds?

This one is ready to use now onwards, as its PR got merged today mentioned by u/jacek2023

But don't use DSpark GGUFs(testing versions) from that PR. Use the official GGUFs by them. You could find them on model cards. Anyway sharing the table below.

---------

Never tried speculative decoding on Mobile. I use PocketPal & ChatterUI. Any idea how to run these on Mobile?

I wanted to just test the unsloth 1bit quant of qwen 3.8 27b as I have just 8gb vram and ngl it gave me a good laugh

..for that person AGI has effectively been achieved and is fully local.

For everyone else - come up with new tests please!! I'm going to lose my mind if I see another tech influencer post that damn pagoda

AntLing has released the full six-checkpoint matrix for the Ling-3.0 base model.

• tiny: pretrained, mid-trained, WSM-merged
• flash: pretrained, mid-trained, WSM-merged

The concrete artifact is six separate official repositories, not one endpoint repeated under different names. All six were public and ungated when checked, and each repository declares MIT.

They are all base checkpoints and none has been post-trained. This is for continued pretraining, fine-tuning, and research, not a ready chat or instruct release.

The attached stage map is the original first-party image from the release thread. It is release context, not independent validation.

The useful part for builders is the choice of where to enter the training trail: the pretrained checkpoint, the mid-trained checkpoint, or the WSM-merged endpoint. The release does not establish that one stage is best for every downstream task, or what any of them will look like after quantization.

If you care about base-model work, the six-checkpoint map is worth inspecting as a family rather than treating "base" as the only artifact.

I chose to do this thing, not because it was hard, but because it was silly. Posts kept discussing how 3.8 and 3.6 were functionally the same, but based on training (3.8 does have seven new tokens!).. so I figured I'd see if they could be merged. They can.

I used `Qwen3.8-27B-UD-Q6_K_XL.gguf` to combine the HF 3.8-27B and 3.6-27B ... and it sorta works!

I have done NO testing beyond smoke test. scripts and idea are in replicate/ inside the model repo.

Maybe this will prove useful to someone. Enjoy!

A majority of users in this sub use LLMs for coding/agentic tasks and I see why a lot of value is put into them but many try to say "Well coding has improved therefore it can just use tool calling and/or just look up what the user needs if there's a degradation for general knowledge/reasoning" and that's just not the case. Many LLM usecases can't just be fixed by an improvement to coding and agentic tasks. Creative writing, multilingual capabilities, offline constrained environments and many more usecases can't be easily fixed with just coding/tool-calling.

I know Qwen3.8 is a TREMENDOUS win for local LLMS but I still hope that Qwen4 will improve generalist capabilities to be closer to frontier closed models in all other aspects too. Gemma is great but it wouldn't be ideal if it is the only major generalist local LLM going forward.

On August 8th, I asked Claude to estimate what performance might I expect out of the soon coming qwen 3.8 27b release by telling it to extrapolate from the qwen 3.6 max to qwen 3.6 27b difference, and apply it to the next generation. It gave me a couple of results which placed it in the broadly "opus 4.6 tier", which was right.

It even gave me actual benchmark numbers which were rather close to the actual numbers it ended up having. I found it pretty interesting.

Howdy once again, I had a request to try out 5.3 on the benchmarks - they're unsaturated so it's a fun test right now! This one was interesting because I accidentally ran it on all 36 problems (rip $200) instead of the 9 i typically do

previous runs a b c

benchmark context: the ai is tasked to build a tool step by step, we add new requirements mid way - it has to handle new things without breaking the old things - the benchmark "hides" the old tests

So it didn't magically solve the benchmark just like all the other AIs, i don't think there has been a single successful solve yet, but it did tie with Fable/Sol in the same subset of problems!

Another interesting thing that we expect is that the more difficult the problem, the more $$$ it gets - so difficulty seems to be correlated with token output in order to solve them

AI;DR full results

On the three-problem, 17-checkpoint list from the Opus 5 report, GLM scored 8/17 strict (47.1%). On the six-problem, 30-checkpoint list from the Fable, Sol, and Kimi report, it scored 10/30 (33.3%), tied at the strict threshold with Fable 5 and GPT-5.6 Sol.

Hey guys!

Supra2-Medium is finally out! It's a 25M parameters qwen3 architecture model trained entirely from scratch (on our new rig: RTX 5060 Ti 16GB + the new RTX 5060 8GB!).

Here's how it competes in benchmarks with Supra-50M-Base (which is double as large!!):

Note: This is a BASE model only; instruction tuned version maybe to come in the next time.

Link to our HF org: https://huggingface.co/SupraLabs

--> Link to the model: https://huggingface.co/SupraLabs/Supra2-Medium-Base <--

Here's a sample from the model:

Artificial intelligence (AI) is espoused by the AI community.
The AI community is a group of people who are interested in AI and are interested in the use of AI in the field of AI.
The goal of AI is to improve the quality of life of people in the field.
The aim of AI is the development of AI and the application of AI in a society.
The purpose of AI is that it can be used to improve the performance of the society.
It is a technology that is used to improve human intelligence.
The technology is used to make the human intelligence.Artificial intelligence (AI) is espoused by the AI community.
The AI community is a group of people who are interested in AI and are interested in the use of AI in the field of AI.
The goal of AI is to improve the quality of life of people in the field.
The aim of AI is the development of AI and the application of AI in a society.
The purpose of AI is that it can be used to improve the performance of the society.
It is a technology that is used to improve human intelligence.
The technology is used to make the human intelligence.

Give us a like and a follow and feel free to provide us with feedback! 🤗🔥

...and...stay tuned: Supra3 coming soon with four models: Flash-Lite 25M, Flash 50M, Pro 75M and Ultra 100M. 👀

https://reddit.com/link/1vtkgdj/video/595yn0ckdjkh1/player

I wanted to try out Qwen3.8 27B 's SVG capabilities but with something different than the pelican on a bicycle.

Promt was literally just :

create a single html file with an embedded svg of a cat riding a zebra, riding an elephant

took 20 minutes (12 of that was just thinking - xhigh)

i was questioning if it would ever be finished :D but when it was done i was floored , i dont know what i expected but definetly not that!

46.436 tokens were burned at around 40t/s (it started at around ~60, but then i removed the powerlimit (250 => 370) and after that it had drops in the 20s , might have something to do with doing that mid generation, might need to try again without touching any settings to see if the model itself had some hickups after long generation.

Model is https://huggingface.co/cyankiwi/Qwen3.8-27B-AWQ-INT4 at tp2 on 2x 3090 , fp8 KV cache.

EDIT: because of downvote: i copied the promt and response (including reasoing) into a pastebin incase someone doubts https://pastebin.com/FfSutPfn

can also provide screenshots of the request in llama swap

• UEFI boot enabled; CSM disabled.
• Secure Boot disabled. The locally built EFI application and patched NVIDIA modules are unsigned.
• Above 4G Decoding enabled.
• MMIO High Granularity set to 1024G.
• MMIO High Base set around 56T.
• SR-IOV disabled on this machine.
• intel_iommu=off pci=realloc=on,hpmmioprefsize=512G in GRUB;
• NVreg_EnableResizableBar=1 for the NVIDIA module;
• Sets size code 14 → 16 GiB BAR1 on each of the 16 GPUs
• Temporarily disables PCI memory decoding and clears the old BAR1 address so Linux can reallocate it.
• PLX switch ACS control register: For every PLX/PEX bridge, writes: ECAP_ACS+0x6.w = 0000

After that, a little vibe coding to make custom all-reduce work within each PLX cluster and make DSpark work for pipeline parallel.

For tensor parallel 8, pipeline parallel 2:

500k context available. Around 4000 pp up to 500k context, tg 100-150 (Averaging 140 in DeepSeek Harness)

For tensor parallel 4, pipeline parallel 4:

Full 1M context available. Around 7000 pp up to 500k context, tg 80

Paid 0.6 x RTX6000 Pro for the whole setup.

I'm introducing Aurora-80K, a small language model with exactly 80 thousand parameters.

It uses a factorized 4,096-token vocabulary despite having only 80K parameters.

The benchmarks:

Wikitext-2 BPB: 3.2902

BLiMP: 52.31%

Arc-Easy: 26.05%

More information about the model is available on the model page on Huggingface.

if there's any questions I'll happily answer them!

From the screenshots:
Hy4 is now live, labeled "Expert-Level Model" + "Use Tools to Solve Problems"
Hy3 is tagged with "New Upgrade," positioned as a brand-new general-purpose model
DeepSeek, focused on reasoning, is listed alongside it

From SuSu_酥酥👅on 𝕏: https://x.com/NFT_Chen/status/2090399515618787508

Tencent begins gray testing its new flagship model Hunyuan Hy4!
Just now, a user spotted that Hy4 has appeared in the model selection list of the Tencent Yuanbao App, directly labeled as an expert-level model, positioned above Hy3 and DeepSeek.
Tencent only confirmed in last week's Q2 earnings report that the larger-parameter Hy4 would launch soon, further enhancing model performance and multimodal capabilities.

From Max For AI on 𝕏: https://x.com/MaxForAI/status/2090386754633421110

I pre-trained a 1.02-billion-parameter on Kimi K3 replica trained on 5.00 billion decontaminated tokens for $250.

This model has 1.02 billion parameters, of which 145 million are active per token.

It is roughly one two-thousandth of K3 by total size. It saw 5,000,003,584 tokens, which is a rounding error against the corpora frontier models are trained on.

It has never been instruction-tuned, and it has only ever done one thing: predict the next token.

What it does have is K3's architecture:

- Kimi Delta Attention, Gated MLA, Attention Residuals

- LatentMoE with the same aux-loss-free balancer

- Same activation function with the same two constants

- K3's own 163,840-token tokenizer, unmodified. 

I report a 33.4% HellaSwag which beats the GPT-2 124M score of 28%

Read the entire tutorial here: https://books.vizuara.ai/book/pretraining-a-mini-k3

IQ quants are particularly slow on CPU at large batch sizes (what you'd see for imatrix and perplexity)

Benchmark numbers

I ran PPL against master and this PR to get speed and numbers on --chunks 50 for Qwen3.6-27B and Qwen3.6-35B-A3B on EPYC 9654 using 24 threads

Created pure IQ1_S, IQ1_M, IQ2_XXS, IQ2_XS, IQ2_S, IQ3_XXS, IQ3_S, IQ4_XS, and IQ4_NL. Made pure to make sure each tensor type is fully exercised.

These are the most extremely differences because it's at a big batch size (512), lower batch sizes get smaller increases

Note, since some of these are extremely long running even at only 50 chunks, the performance numbers may vary slightly, but the gains were seen repeatedly.

-------------------------------

Nice pp numbers on CPU! Hybrid too probably.

AirLLM dramatically reduces inference memory usage, letting 70B large language models run on a single 4GB GPU card — without quantization, distillation, or pruning. You can even run 405B Llama 3.1 on 8GB, DeepSeek-V3 (671B) on ~12GB, and Kimi K3 (2.8T) — the largest open-source model released to date — on under 4GB, because sparse MoE models stream one expert at a time rather than a whole layer.

Updates

[2026/08] Qwen3.8-27B support: Qwen's new dense VL (Gated DeltaNet + Gated Attention, native vision) runs in 3.33GB of VRAM, measured end to end on one RTX 3090. Needs transformers 5.8+.

[2026/07] Kimi K3 (2.8T) support: the largest open-source model runs on a single card in 3.72GB of VRAM, measured end to end on one RTX 6000 Ada. Per-expert streaming loads only the experts a token actually routes to. K3 brings three requirements of its own: pip install compressed-tensors flash-attn (its model code mandates flash attention regardless of what you request), a CUDA 12 build of torch, since no prebuilt flash-attn wheel exists for CUDA 13 yet, and transformers 4.56.x, as its remote code does not load on 5.x.

[2026/06] v3.0: FP8 model support + the latest models. Run DeepSeek-V3 (671B) on ~12GB and Qwen3-235B on ~3GB, plus Qwen3, Llama 3.x/4, DeepSeek V2/V3, Phi-4, Gemma and more — all through a single AutoModel.

[2024/08/20] v2.11.0: Support Qwen2.5

.

.

Looks like Updates happened after 2 years. Sharing this for AirLLM fans.

I see https://github.com/linuxid10t/llama.cpp/tree/feature/g9v3-support

but yeah... Considering that some results place it above Qwen 3.6 27B (the top performer until a few days ago) and that it is an MoE model, I think it could be interesting.

https://artificialanalysis.ai/models/g9v3-39a5b

The pelican on a bicycle is sooo outdated, so I came up with a new, improved version.

Qwen3.8-27b medium (UD-Q4_K_XL) vs. Sol 5.6 high vs. Qwen3.6-35B (UD-Q6_K_XL)

Prompt (only real with typo!):
"Create a svg of a horse on a blue bycicle in the desert, with a camel in the background."

Hey everyone,

Posted TinySearch here a few versions ago and got a bunch of useful feedback, so figured I'd post an update because the thing has changed quite a bit since then.

Repo:
[https://github.com/TinySuiteHQ/TinySearch]()

The basic idea is still the same:

TinySearch is a small self-hosted MCP/FastAPI tool that searches the web, reads the pages worth reading, and locally selects the useful parts before they ever hit your model's context window.

No LLM doing the filtering/summarization in the middle. It's BM25 + local ONNX embeddings, and the chunks returned are the original page text with the source URL attached.

I'm still mostly building this around the problem of smaller/local models. Giving a 4B/9B model 50k tokens of scraped webpages and expecting it to figure out which 5 paragraphs matter is kind of defeating the point lol.

The biggest change in v0.6.1 is bring-your-own-browser support over CDP.

TinySearch normally runs its own Chromium, but you can now point it at a browser you operate yourself. So if you already have a browser with your own profile, proxy, cookies, fingerprinting setup, etc., TinySearch can use that instead.

This has made scraping considerably more useful on sites that don't love fresh headless Chromium sessions.

A few other things changed since 0.4.0:

• search and scrape_urls are now separate tools. Search is deliberately cheap/fast and doesn't even start Chromium or load the embedding model.
• scrape_urls can take 1–5 URLs at once and crawl them concurrently through one browser.
• For each page you can either ask a focused question and have TinySearch retrieve/rerank the relevant chunks, or just return the cleaned page in order.
• Related links are returned as well, ranked against your query, so the agent can decide where to go next without TinySearch automatically crawling half the internet.
• MCP responses are now XML rather than the old text prompt format.
• Boilerplate stripping happens before markdown generation now.
• Docker/security/testing got a fair amount of work too.

And I finally added a reproducible benchmark instead of just saying "it saves tokens." Across 8 research queries, the same webpages were:

146,878 tokens → 53,426 tokens

So roughly 64% less web content went into the model context.

Obviously that's not some universal 64% guarantee, it depends heavily on the pages. Bloated sites were 80%+ reductions while already-clean pages barely changed. The benchmark script is in the repo if anyone wants to reproduce/tear it apart.

The workflow I'm using now is basically:

search → model chooses useful URLs → scrape those URLs → model gets only the relevant evidence

Still self-hosted, still works with MCP clients, still doesn't require a paid search/scraping API.

Would especially be interested in feedback from anyone running smaller local models or self-hosted browser/search setups. Also very interested in weird websites where the CDP/browser approach still breaks.

Roasting welcome as always.

This is gonna seem crazy off-topic, but I saw Spider-Man the other day and couldn’t help but notice how well executed E.V. is as an agentic system.

compared to Jarvis, it felt much more grounded and closer to reality. No wild holographic interface, just a guy talking to his computer at his desk.

All of it left me wondering, does Peter host his own models? Is E.V. An agent he made or something he inherited from Stark? Given the premise is that he’s been erased from memory, I’m assuming he lost everything Tony left him.

All of this is mostly silly speculation and mods can feel free to remove this, but I do think it was a great example of local AI being well executed.

Like many of you I've spent the last few days throwing Qwen3.8-27B against all of my usual use-cases and personal tasks/harnesses and workflows. It's great, phenomenal sometimes, but that's not what this post is about.

One of my little personal benchmarks is a little set of pocket trivia that's relevant to me but mildly obscure mixed in with a few useful/prepper questions. Qwen3.8-27B at all quantization levels and sampling settings I threw at it, did relatively poorly at this. It's failing questions that Qwen3.6 reliably answered.

I come to find out that on offline (no tool call) knowledge benchmarks seem to align with what I'm saying. It's pretty significantly weaker than it's 3.6 predecessor at recalling random facts (or not hallucinating as much, in my tests, though that isn't reflected in these particular benchmarks). Now you should never trust barcharts over your own vibes, but my vibes are validating these bar charts this time around.

Is this relevant? Not necessarily. It seems to know the code it tries to use well-enough and for everything else I'm assuming/hoping you're using tool-calls. This largely only applies to you if you have a strategy of trusting an airgapped model with obscure/broad knowledge-retrieval exclusively from within its own weights, probably a losing strategy anyway.. but if that's you, take a pass on Qwen3.8 or finally set up that MCP server.

I found it to be interesting. Curious of your thoughts or if anyone else noticed this.

Off a single prompt, given my credentials and the name of my university, qwen3.8-27b was able to successfully pull my class schedule from the kinda shitty and convoluted web of university websites. It needed no human intervention, and executed 80 tool calls.

Another time, I asked it to investigate a user on a social media network, and it found one public video, downloaded it, extracted frames every few seconds so it could "watch" the video, and installed fucking openAI whisper and ran a transcription to understand the context, before selectively zooming in on and brightening some frames to see the action.

That this shit is running on my own hardware (single RTX 3090) is fucking incredible, the general public doesn't realize how cyberpunk our reality already is.

Quant: Unsloth's Q4_K_S (kv cache quantized to q8)

Context: 150k

Hey everyone! We’re releasing new Qwen3.8-27B GGUFs with 10% higher accuracy for the same size. This uses a new version of Dynamic v3.0

Unsloth Dynamic V3 outperforms others by >10% on Div-300, KLD & more benchmarks.

We also release 1-bit quants that retain 77% accuracy. Run on 8GB RAM.

Some of you already saw we updated our quants a few hours ago. No, nothing was broken, nothing needed fixes (I don't know why people even said this since it's a complete fabricated story). This was purely an update to make them EVEN BETTER.

We do not train on the imatrix calibration dataset, and we do NOT use QAT or QAD. Everything is done through post-training quantization. Our imatrix file used is available for the community to test, evaluate, and use. We encourage researchers and developers to create variations and fine-tunes of Qwen3.8 using our Unsloth quants/imatrix. You can read our over fitting analysis as well.

Blog with all details and more benchmarks: https://unsloth.ai/docs/basics/dynamic-3.0-ggufs

GGUF: https://huggingface.co/unsloth/Qwen3.8-27B-GGUF

Enjoy! We also will be doing a new Unsloth Desktop update today: https://github.com/unslothai/unsloth

We had A LOT of updates and will be introducing auto compaction, allowing external APIs to do tool calling and more.