1. Qwen 3.8 27B Successfully Reverse-Engineers arm64 Code in 30 Minutes
Qwen 3.8 27B, which ranks first in the 4B to 40B size class on Artificial Analysis's intelligence index, successfully reverse-engineered a commercial application's license check. Operating on a Lenovo ThinkStation PGX with an Nvidia GB10 Grace Blackwell chip, the model performed static analysis of arm64 code, identified and corrected its own errors, recovered an obscured RSA key, and created a working authentication bypass within 30 minutes. The model also demonstrated the ability to recognize and refuse initial jailbreak attempts before auditing the code.
- • Qwen 3.8 27B ranks as the top model in the 4B to 40B size class on Artificial Analysis's intelligence index with a score of 52.
- • The model successfully reverse-engineered a commercial application's license check using static analysis of arm64 code.
- • During the 30-minute process, the model identified and corrected its own errors to recover an obscured RSA key and bypass authentication.
- • Performance reached up to 50 tokens per second on an Nvidia GB10 Grace Blackwell chip using SGLang, NVFP4, and DFlash2 speculative decoding.
This showcases the model's ability to perform complex, multi-step reasoning and self-correction locally, unlocking advanced security auditing workflows.
2. Vercel Releases Zig-Based Coding Agent 'fx'
Vercel has released `fx`, a lightweight and fast coding agent written in Zig. This release coincides with a broader industry shift where LLMs are lowering the barrier to entry for complex systems programming languages like Rust and Zig. Developers are increasingly using AI to assist with performance optimization and to navigate low-level technologies such as eBPF, DWARF files, and custom network drivers. For example, Cloudflare's Artifacts service now runs a pure-Zig Git-protocol engine compiled into a 100 KB WebAssembly module.
- • Vercel released fx, a Zig-based coding agent marketed for its small size and high speed.
- • Cloudflare's Artifacts service utilizes a pure-Zig Git-protocol engine compiled into a 100 KB WebAssembly module.
- • LLMs are reducing the barrier to entry for complex languages like Rust and Zig, allowing developers to rely on AI for performance optimization.
- • AI assistance is enabling developers to work with complex technologies like eBPF, DWARF files, and custom cryptography.
The release of fx provides developers with a highly optimized, low-overhead coding agent that leverages Zig's speed and small footprint.
3. Claude Code with Opus 5 Outperforms Qwen 3.8 27B on Large-Scale Code Porting
An experiment compared the local Qwen 3.8 27B model against Opus 5 on porting a 2.1MB C file (39,000 lines) to a single-file HTML/three.js project using a single prompt. Claude Code running Opus 5 completed the task in 21 minutes with 'okay' quality. In contrast, Qwen 3.8 27B running locally via FP8 on vLLM took 4 hours and 18 minutes on the Hermes harness, and 1 hour and 40 minutes on the Codehamr harness, with both local runs producing 'bad' quality output.
- • Claude Code using Opus 5 completed the 2.1MB C file port in 21 minutes, producing 1759 lines of 'okay' quality output.
- • Qwen 3.8 27B running on the Hermes harness took 4 hours and 18 minutes to produce 949 lines of 'bad' quality output.
- • The Codehamr harness running Qwen 3.8 27B completed the task in 1 hour and 40 minutes, yielding 1056 lines of 'bad' quality output.
- • The local Qwen 3.8 27B setup utilized FP8 on vLLM with an RTX 6000 Pro 96GB GPU.
This benchmark highlights the performance boundaries between local models and frontier APIs when executing complex, single-prompt codebase migrations.
4. Understanding Agent Harnesses and the Open-Source Pi Framework
Agent harnesses are emerging as a key architectural pattern, providing a structured environment for AI models to operate as agents. Typically comprising a system prompt, tools, an agentic loop, and a translation layer, harnesses allow developers to swap models from various providers or run open-weights models locally. Pi, developed by Earendil, is a free, open-source harness that runs locally on a laptop and features over 5,000 community-shared extensions to maximize user agency.
- • An agent harness consists of a system prompt, a set of tools, an agentic loop, and a translation layer for model compatibility.
- • The translation layer allows developers to swap models from different providers (e.g., Anthropic, OpenAI) or use open-weights models.
- • Pi is a free, open-source agent harness that runs locally on a laptop and supports over 5,000 community-shared extensions.
- • Harnesses can be fully owned, customized, and run locally on a user's own hardware.
Harnesses give developers complete ownership and local control over agent execution, decoupling the agentic loop from proprietary API providers.
5. DeepSeek Harness Enables Encrypted, TOR-Based Agent Messaging
DeepSeek Harness (DSH) has gained traction for its progressive, frustration-free setup and unopinionated design. The tool features a webUI for easy check-ins and enables end-to-end encrypted, TOR-based messaging with AI agents. In a recent implementation, a developer successfully integrated DSH with SimpleX by instructing the AI to perform the integration directly, demonstrating the tool's flexibility without requiring manual pull requests or community plugins.
- • DeepSeek Harness (DSH) features a webUI for easy check-ins and a progressive, frustration-free setup process.
- • DSH enables end-to-end encrypted and TOR-based messaging with an AI agent.
- • A user successfully integrated DSH with SimpleX by directing the AI to perform the integration directly, bypassing pull requests or community plugins.
- • DSH is unopinionated, allowing developers to fully customize its behavior.
This tool provides developers with an unopinionated, highly customizable agent environment that prioritizes privacy and secure communication out of the box.
6. Qwen 3.8 27B NVFP4 Achieves 120 tok/s with 451K KV-Cache on RTX 5090
A developer successfully configured the Qwen 3.8 27B NVFP4 model to run on a power-limited (400W) NVIDIA RTX 5090 using vLLM. Running on Linux (Bazzite) with the UI deactivated to maximize memory utilization to 0.98, the system supports a 196K context per session and a 451K global KV-cache with concurrency enabled for three parallel sessions. The setup achieves an average speed of 120 tokens per second, with benchmarks validated via llama-benchy 0.4.0.
- • The setup supports a 196K context window per session and a 451K global KV-cache across three parallel sessions.
- • The system achieves an average generation speed of 120 tokens per second on a power-limited (400W) NVIDIA RTX 5090.
- • The environment runs on Linux (Bazzite) with the UI deactivated to achieve 0.98 memory utilization.
- • Performance benchmarks were conducted using llama-benchy 0.4.0 across context lengths from 4K to 185K.
This configuration demonstrates how developers can run massive context windows and parallel sessions locally on consumer hardware.
7. Atomic Dynamic GGUF Quantizations Released for Qwen 3.8 27B
The Atomic Chat team has released Atomic Dynamic (AD) GGUF quantizations for the Qwen 3.8 27B model, evaluating them on an RTX PRO 6000 using a voxel island creation task. The team recommends the AD-Q6_K variant (25.0 GB) as the safest choice, yielding 98.7% top-1 accuracy compared to BF16 at 49 tokens per second. For tighter memory constraints, the AD-Q4_K_M variant drops the size to 17.1 GB while retaining 95.6% accuracy and boosting speed to 67 tokens per second.
- • The AD-Q6_K quantization is recommended as the safest choice, offering 98.7% top-1 accuracy compared to BF16 and 49 tok/s decode speed.
- • The AD-Q4_K_M quantization reduces the model size to 17.1 GB while maintaining 95.6% top-1 accuracy and achieving 67 tok/s.
- • The AD-Q5_K_M quantization provides 97.3% top-1 accuracy at a 20.2 GB size with a decode speed of 57 tok/s.
- • All quants are available for download via the atomic.chat app or the AtomicChat Hugging Face collection.
Developers can now deploy highly optimized local quants of Qwen 3.8 27B, balancing memory footprint and accuracy on professional workstation GPUs.
8. GLM-4.5-Air Gains Multi-Token Prediction Support in Llama.cpp
Building on the initial integration of Multi-Token Prediction (MTP) into llama.cpp, the project has now added support for the GLM-4.5-Air model. This 106B parameter Mixture-of-Experts (MoE) model can now leverage MTP to improve generation speeds on hardware with high memory capacity but limited compute, such as Strix Halo or NVIDIA 3090 GPUs. The necessary MTP block for GGUF files is available via a repository maintained by jacek2024.
- • GLM-4.5-Air is a 106B parameter MoE model with 12B active parameters.
- • MTP support in llama.cpp now covers the GLM-4.5-Air and full GLM-4.5 models.
- • The implementation is optimized for high-memory, limited-compute hardware.
- • Users can access the required MTP block for GGUF files via a repository maintained by jacek2024.
This update extends the performance benefits of MTP to the GLM-4.5-Air model, allowing for more efficient local deployment of large MoE architectures on hardware with high memory but limited compute.
9. New Benchmark: MXFP4 on B300s Outperforms 1-Bit GGUF on A100s for Kimi K3
Building on previous cost-benefit analyses for self-hosting the Kimi K3 model, new benchmark data reveals that native MXFP4 on 8x B300 GPUs is significantly more efficient than 1-bit quantization on older hardware. While 1-bit GGUF on 8x A100s offers a lower hourly cost, the B300 setup's superior throughput makes it 3.3 times more cost-effective per million tokens.
- • Hosting Kimi K3 via vLLM on 8x B300 GPUs using native MXFP4 costs $190 per million tokens at 92 tok/s.
- • Running 1-bit UD-IQ1_S GGUF on 8x A100-80GB GPUs costs $620 per million tokens at 9 tok/s.
- • The B300 configuration is 3.3 times more cost-effective despite the higher hourly rental rate.
This benchmark provides critical data for infrastructure engineers choosing between hardware and quantization strategies for massive MoE models.
10. Nvidia Notifies Customers of AI Product Price Hikes Above 15%
Nvidia has notified its customers of upcoming price increases for its AI-related products. The announced hikes will exceed 15%, a move that is expected to directly impact hardware procurement costs and downstream cloud GPU rental rates for developers hosting their own models.
- • Nvidia has officially notified its customers regarding price increases for AI-related products.
- • The announced price hikes for these AI-related products are above 15%.
This price hike will directly increase hardware acquisition costs and likely drive up cloud GPU instance pricing, impacting developer infrastructure budgets.