Raphael🔶 retweeted
Qwen3.8-27B has reportedly been compressed from 55.6GB to just 5.9GB, while retaining 98.2% of its aggregate benchmark performance.
That’s an 89.4% reduction in model size.
The work comes from PrismML, which has released Bonsai 2, the second generation of its model compression system.
What makes this result interesting is that the reduction in storage hasn’t been accompanied by a comparable collapse in the reported benchmark results.
The numbers behind Bonsai 2
Original Qwen3.8-27B checkpoint: 55.6GB
Bonsai 2 checkpoint: 5.9GB
Storage reduction: 89.4%
Aggregate benchmark performance retained: 98.2%
Evaluation coverage: 20 benchmarks
Previous Bonsai 27B version: approximately 95% retention
The improvement over the first generation is worth noting.
PrismML reports that performance retention increased from roughly 95% to 98.2%, despite maintaining an aggressive compression target.
That suggests the team has improved how it removes numerical information from the model without disrupting as much of its useful behaviour.
How does Bonsai 2 achieve this?
The central technique is ternary quantisation.
Conventional neural networks store weights using numerical formats such as FP16, INT8 or 4-bit representations. These formats support different levels of numerical precision, with corresponding storage requirements.
Ternary quantisation takes a more aggressive approach.
It represents model weights using just three possible values:
-1
0
+1
Scaling factors help preserve information about the magnitude of the original weights.
Instead of storing every weight as a conventional high-precision number, the system uses a much smaller representation and scaling information to recover useful numerical ranges.
This dramatically reduces the storage required for the model.
However, there is a difficult problem with aggressive quantisation.
Model weights encode relationships that influence how a model reasons, writes code, follows instructions and processes information. Removing too much numerical detail can distort those relationships and damage the capabilities developers depend on.
The objective isn’t simply to reduce the number of bits.
It’s to find a representation that removes unnecessary numerical precision while preserving as much useful model behaviour as possible.
What improved over Bonsai 1?
The reported increase from approximately 95% to 98.2% aggregate performance retention is one part of the Bonsai 2 update.
PrismML also highlights improvements in three areas that are particularly relevant to modern AI applications.
1. Coding agents
Coding agents need more than the ability to generate a function from a prompt.
They must understand existing repositories, navigate dependencies, modify multiple files, execute tests, interpret errors and revise their implementations.
A model can perform well on isolated coding questions but still struggle when asked to complete an extended development task.
Preserving performance across these workflows is therefore an important test of compression quality.
2. Multimodal reasoning
Multimodal models work with different forms of information rather than relying exclusively on text.
Depending on the task, this can involve interpreting images alongside written instructions, extracting information from visual inputs and reasoning across different types of content.
Compression needs to preserve the relationships required to process these inputs, not just the model’s ability to answer ordinary text questions.
3. Long-horizon tool use
This is particularly relevant to autonomous agents.
A long-horizon workflow may involve several connected decisions:
Inspecting information.
Choosing a tool.
Executing an action.
Reviewing the result.
Identifying mistakes.
Adjusting the next action.
Errors can accumulate across these steps. A model that loses consistency during a long workflow may produce a poor final result even if it performs well on individual questions.
One RTX 3090 with 24GB of VRAM is reportedly delivering 1,035 tokens/s of aggregate throughput across 64 concurrent Qwen3.8-27B sessions.
The system runs at a 250W GPU power limit using HyperQwen, an open-source inference stack built around vLLM.
The reported performance:
GPU: NVIDIA RTX 3090, 24GB VRAM
Power limit: 250W
Model: Qwen3.8-27B
Single-session decode: ~127 tokens/s
64-session aggregate throughput: ~1,035 tokens/s
Configured context: Up to 150K tokens
Inference stack: HyperQwen + vLLM
The interesting part is how the software handles multiple requests without wasting GPU resources.
Why concurrent inference changes the equation
Running one AI session is different from serving dozens of users simultaneously.
In a single-session setup, the GPU primarily processes one request at a time. But when multiple users connect, the inference engine has to manage their prompts, generation steps and memory requirements together.
Poor scheduling can leave GPU resources underutilised or create unnecessary delays between requests.
HyperQwen uses vLLM’s serving architecture to improve this process.
Two features are particularly important.
1. Continuous batching
Traditional batching can group requests together and process them as a fixed batch.
The problem is that requests rarely finish at exactly the same time. A short response might complete while another request is still generating thousands of tokens.
Continuous batching allows the engine to introduce new requests as existing ones finish, rather than waiting for the entire batch to complete.
This keeps work flowing through the GPU and helps improve overall server utilisation.
2. PagedAttention
Every active generation session needs a KV cache to retain information from previously processed tokens.
As the number of concurrent sessions increases, KV-cache memory becomes a major constraint.
PagedAttention manages this memory in smaller blocks rather than requiring each request to reserve one large, continuous memory allocation.
This reduces memory fragmentation and allows the inference engine to manage KV-cache capacity more efficiently across multiple sessions.
Together, continuous batching and PagedAttention help vLLM serve more requests while making better use of available GPU resources.
Understanding the 1,035 tokens/s figure
There’s an important distinction between the two reported speed measurements.
The approximately 127 tokens/s figure represents single-session generation performance.
The 1,035 tokens/s figure is aggregate server throughput across 64 concurrent sessions.
It does not mean every user receives 1,035 tokens/s.
The total output is shared across active requests, and individual session speeds can vary depending on scheduling, prompt length, generation length and GPU contention.
This is an important distinction when evaluating inference benchmarks. High aggregate throughput is valuable for serving multiple users, but it doesn’t automatically mean lower latency for each individual user.
What about the 150K context?
The configuration reportedly supports contexts of up to 150K tokens.
However, maximum configured context and simultaneous long-context serving are two different things.
Longer contexts increase KV-cache consumption. With 64 active sessions, memory requirements can become substantial, particularly if every request uses a large portion of the available context.
The actual concurrency achievable at long context lengths will depend on cache precision, memory allocation and request sizes.
The 64-session result should therefore be understood alongside the workload used during testing, rather than assuming all 64 sessions were simultaneously processing 150K-token contexts.
HyperQwen makes deployment easier
HyperQwen also provides Docker profiles for different serving scenarios.
Raphael🔶 retweeted
Sorry guys. Software engineering and programming are dead. You just need to have perfect specs, unchanging requirements, an agentic deployment framework for high frequency releasing, and engineers with good taste and judgement.
cyber security engineers right now:
Introducing GPT‑6 Cyber: a major advance in security research that pairs stronger capabilities with better model alignment.
The model powered the Linux kernel research we announced yesterday, and security teams at companies like Mozilla, Palo Alto Networks, Calif, and Cisco—alongside our own at OpenAI—are already putting it to work.
GPT-6 Cyber is available to select Daybreak Red customers and we are expanding access over time.
openai.com/index/introducing…
Raphael🔶 retweeted
Quem toma Macallan em hotéis de luxo está criando o imposto do pecado para punir quem quer tomar um cervejinha ou um vinho.
























