A 367K-Parameter Transformer That Runs on a 1990s Pentium PC With Just 540 KB of Free Memory
Claude Fable 5.2 reportedly wrote a working Transformer language model, while Opus 5.5 generated its training data.
The project, called Tiny 2.1, is built in C for DOS using Turbo C 2.0.
Here's what makes it interesting:
367,000 parameters in total.
Approximately 380 KB for model weights.
Executable and weights together fit in around 435 KB.
Requires approximately 540 KB of free DOS memory to run.
Small enough to fit on a standard floppy disk.
It's a constrained experimental language model, not a ChatGPT replacement, but a fascinating demonstration of how efficiently Transformers can run on decades-old hardware.
GitHub: https://t.co/WcxR7oeX5U
Duo v1: Building AI Characters That Can See, Hear, Speak, and Interact With You in Real Time
Most AI video models generate scenes, but they don't actively participate in them.
In a new research project, InclusionAI introduces Duo v1, built around a Reciprocal World Model (RWM), where AI intelligence and the virtual world interact continuously.
What does this enable?
Imagine showing an AI assistant a plant through your camera. It watches what you're doing, listens to your questions, and responds with speech, facial expressions, and synchronized video. You can interrupt it, change the subject, or show it another object while it's responding.
The architecture has two key modules:
Intent Module: Understands audio, video, context, and decides when and how to respond.
Realization Module: Generates synchronized speech and video based on those decisions.
This enables more natural applications such as interactive AI companions, virtual assistants, guided experiences, and audiovisual games.
The key idea: Don't just generate a virtual world. Build intelligent entities inside it that can perceive and interact with the real world.
Project: https://t.co/gspYnbnwcF
GitHub: https://t.co/94bLBzTEHt
Paper: https://t.co/TTzV5dNUNr
From AI Writing Code to AI Maintaining Its Own Codebase
A Grok engineer reportedly helped an AI coding agent ship 3,000 production PRs in a single month.
The approach:
Turn every coding mistake into a new lint rule.
Use videos, screenshots, and tests to verify the agent's work.
Continuously improve code quality through automated checks.
Allow the agent to merge its own PRs once quality standards are met.
The bigger idea isn't just AI generating code. It's AI learning from its mistakes and helping maintain the entire codebase.
The future of AI engineering is moving beyond prompt engineering toward autonomous software development.
#AIEngineering #Grok #AgenticCoding
Qwen 4 Max Takes on a Cyberpunk City in Three.js
A developer tested Qwen 4 Max by building a 3D cyberpunk city featuring procedural buildings, neon lights, moving traffic, and trains.
The visuals look impressive, with a noticeable improvement over Qwen 3.8 Max.
Another promising showcase of AI-powered 3D development.
#Qwen4Max #ThreeJS
A Developer Just Unlocked 80GB VRAM on an NVIDIA CMP 170HX
A developer successfully modified an NVIDIA CMP 170HX GPU using a voltage-glitching technique, reportedly unlocking its full 80GB VRAM and 126 Streaming Multiprocessors (SMs).
The interesting part? The hardware setup involved a Raspberry Pi Pico 2, fine wires connected to the GPU board, and custom scripting.
According to the developer:
The technique surfaced just five days before the experiment.
They used the Pico 2 to perform the modification.
AI-assisted scripting helped with the restricted write-access portion.
It took nearly 15 hours of work to get everything running.
They plan to attempt the same modification on a second CMP 170HX.
The reference image shows the GPU board, Pico 2 and wiring used in the experiment.
An interesting example of how hardware enthusiasts are finding creative ways to unlock more potential from existing AI hardware.
Why download hundreds of gigabytes of abliterated AI models when you can achieve similar results with a tiny LoRA?
A new community experiment demonstrates how refusal behavior in Qwen3.8-Flash-Next can be modified using a lightweight LoRA adapter instead of downloading an entirely modified model.
Here's what makes it interesting:
Tiny footprint: A 571K-parameter LoRA adapter (2.3mb in size) instead of storing another massive model.
On-demand activation: Enable or disable the adapter at runtime.
Same base model: Apply the adapter to an existing quantized GGUF model.
Minimal degradation: The author reports statistically similar perplexity and benchmark performance.
Flexible inference: With llama.cpp, the LoRA can be activated per request rather than permanently applied.
The reported experiments include a reduction in refusals from 93/100 to 3/100 on JailbreakBench's harmful prompts.
The bigger idea: Instead of maintaining multiple copies of the same model with different behavioral modifications, developers can use lightweight adapters to customize model behavior dynamically.
This is an interesting application of LoRA beyond conventional fine-tuning.
Model: https://t.co/5ndephlGRp
Implementation: llama.cpp supports runtime LoRA loading and activation.
What if your idle laptops, desktops, and workstations could become one distributed AI inference server?
Meet Superfluid, an open-source LLM serving system that turns multiple machines into a unified inference infrastructure.
Instead of running independent model servers, Superfluid coordinates workloads across machines while keeping inference local.
Here's what makes it interesting:
Multi-agent scheduling: Prioritizes interactive user requests over background agent workloads.
Distributed inference: Combines multiple machines into a single API endpoint, even across different hardware vendors.
Smart load balancing: Routes requests based on measured machine performance and available resources.
Fault tolerance: Machines can join, disconnect, or crash without losing in-flight requests.
Durable sessions: Every generated token is logged before delivery, allowing conversations to recover after failures.
Runtime flexibility: Supports llama.cpp, MLX, and BaseRT.
The reported benchmarks are impressive:
1.5-second first-token latency while eight agents are working.
534 tokens/sec across six heterogeneous machines.
10,656 tokens/sec across twelve Mac Studio M3 Ultras.
The bigger idea: Instead of buying an expensive GPU server, developers could combine the computing power of machines they already own into a private AI inference cluster.
Local AI infrastructure is evolving from single-machine deployments to distributed computing.
GitHub: https://t.co/e2ZY6Bhekw
Paper: https://t.co/yrulKqj23D
Can an LLM understand what changing another model's weights will do without ever running that model?
A new experiment called Weight-Space Reading explores this fascinating possibility using open-weight Qwen and Muse models ranging from 9B to 30B parameters.
Some interesting findings:
73% balanced accuracy: Qwen 27B predicted subtle weight-edit effects using direct weight access, compared with 57.8% using text descriptions.
Self-inspection remains uncertain: No conclusive advantage was established for models reading their own weights.
False predictions: On Muse-30B, 34 standard edits and 6 no-op controls produced no detectable behavioral changes, yet agents frequently predicted changes.
The researchers have also released an evaluation harness, experimental code, and an open-source toolkit for weight-space programming.
The bigger question: Could LLMs eventually inspect, understand, and predict the behavior of neural networks directly from their parameters?
This could open an entirely new direction in model interpretability and automated weight editing.
GitHub: https://t.co/IvnBltFvs8
Paper: https://t.co/bnpb4HrN8w
Running a 40B-parameter AI model on a 12GB GPU at 64 tokens/sec?
RustingStrata is challenging conventional local inference engines with some impressive benchmark results.
In a recent comparison using Recursive Flint UD-Q5_K_XL on an RTX 3060 12GB with 30GB system RAM:
64.6 tokens/sec decode speed vs. 48.6 with llama.cpp.
33% faster warm decoding.
1.14โ1.30K tokens/sec prompt processing.
No reported quality degradation.
How does it achieve this? Two key optimizations:
Adaptive expert placement based on the generated response rather than just prompt routing.
Smarter RAM page management to keep frequently needed expert weights accessible.
The interesting part is that the model is larger than available VRAM, yet careful CPU-GPU memory management makes surprisingly fast inference possible.
This shows how much performance can still be unlocked through inference-engine optimizations without changing model weights.
GitHub: https://t.co/rrq6V9Cv9M
What if a high-quality text-to-speech model needed just 4.5 million parameters and could run 70ร faster than real time on a CPU?
Meet tiny-voca, a fully open-source English TTS model designed to run locally, even inside your browser.
What's impressive:
Tiny footprint: Just 4.5M parameters and 18 MB.
Fast inference: Around 70ร real-time speed on 4 CPU threads.
Two voices: Male and female, with 24 kHz audio.
Multiple runtimes: PyTorch, ONNX, and browser support.
Efficient architecture: Uses a lightweight source-filter synthesizer instead of a neural vocoder.
Fully open: Code, weights, training recipe, and dataset are available.
The model was trained from scratch in just 7.7 hours on a single RTX 4090.
The interesting part? Not every useful AI model needs billions of parameters. Carefully designed architectures can deliver impressive capabilities with surprisingly little compute.
Try it: https://t.co/MYTm2jxgzH
GitHub: https://t.co/8G5pVdgODA
Weights: https://t.co/Ij7GHk0tqM
Dataset: https://t.co/hUWSTGd6Ee
Local AI inference is getting a serious upgrade. llama.cpp v1.0.0 brings major improvements to running large models on consumer GPUs.
One of the biggest improvements is smarter MoE offloading and LRU caching, allowing larger models to run even when they don't fully fit in VRAM.
Key highlights:
MTP Speculative Decoding: Reportedly boosts Qwen3.8-27B from 74 to 134 tokens/sec on an RTX 5090.
Quantized KV Cache: FP8 and Q4 cache options reduce memory consumption and help support longer context windows.
Better Quantization: Unsloth Dynamic V3.1 GGUF reportedly delivers 5โ10% higher accuracy at the same model size.
Improved MoE Caching: Smarter expert management improves performance when working with models larger than available VRAM.
Better Infrastructure: Updated Web UI and improved server security.
Running powerful AI models locally is becoming increasingly practical. Better memory management and speculative decoding are making hardware limitations less restrictive.
GitHub: https://t.co/47RhBHSCcG
Model: https://t.co/t8qOBGPexA
Are American open-source models starting to adopt architectural ideas pioneered by Chinese AI labs?
Sebastian Raschka recently highlighted striking similarities between Inkling 2 Small and Kimi K3.
Both architectures share several interesting design choices:
Attention Residuals: Reusing earlier-layer outputs through direct connections to token representations.
1M-token context: Support for extremely long context windows.
Sparse MoE: Activating only a fraction of the model's parameters per token. Inkling reportedly activates 17B.
Hybrid attention: Combining GQA, Sliding Window Attention, and short convolutions.
The interesting takeaway is that architectural innovation is becoming increasingly global.
AI research is no longer a one-way competition. Ideas are crossing borders, influencing architectures, and accelerating progress across the entire industry.
What if you could turn multiple coding agents into a coordinated engineering team with a single command?
Meet Troupe, a lightweight multi-agent orchestration tool designed to make parallel AI coding more reliable.
Instead of agents overwriting files, creating conflicts, and getting stuck in endless review loops, Troupe introduces structure:
Isolated workspaces: Each agent gets its own Git worktree and branch.
Conflict prevention: Overlapping tasks run sequentially, with dedicated ownership of shared files.
Clear acceptance criteria: Every task has predefined completion requirements.
Controlled reviews: Limited review cycles prevent endless back-and-forth.
Human oversight: Approve plans, manage permissions, and monitor agent activity.
The entire workflow, from planning and task assignment to parallel development, review, and PR creation, is coordinated.
Getting started:
npm install -g troupe-cli
troupe setup
Run Claude Code or Codex inside tmux and start a mission.
GitHub: https://t.co/yJdBeqYWQ6
A new Meta + NYU study challenges a long-standing assumption in multimodal AI.
After evaluating 200+ models, researchers found that vision encoders don't necessarily need to be pretrained separately.
Key findings:
Vision does not always require a separate pretrained encoder.
Dedicated vision parameters are still important.
These parameters can be integrated into the early layers of the language model without sacrificing performance.
This approach can also deliver faster inference.
The bigger takeaway: Multimodal models may not need increasingly complex architectures. Better parameter allocation could be enough to make them simpler, faster, and more efficient.
What if you could run 4K AI image generation on a GPU with just 8GB of VRAM?
MiniMax-H3-Image, a 33.1B parameter image-generation model, is getting a major boost from community-driven quantization.
The results are impressive:
VRAM requirements reportedly reduced from 68GB to just 6.4GB with Q2_K quantization.
Native 4096ร4096 image generation.
Six-step image generation using the official distilled version.
Supports both image generation and editing.
Accepts up to 16 reference images for better control.
The open-source community has already released more than 20 quantized versions.
The interesting part? A model that once required high-end hardware is now becoming accessible to consumer GPUs.
Getting started:
Download a suitable GGUF quantization from Hugging Face.
Install the required ComfyUI nodes, VAE, and text encoder.
Load the official generation or editing workflow.
This is another example of how quantization is making powerful AI models accessible to everyone.
Qwen 4.0 Max Preview may have received a significant stealth upgrade.
The latest Pelican test results suggest noticeable improvements in image generation:
Anatomical accuracy: Highly realistic pelican features and natural cycling movements.
Scene consistency: Coastal landscapes, reflections, lighting, and background elements remain coherent across frames.
Text rendering: Clean, readable text without character distortions.
Visual quality: Better lighting, shadows, material details, and convincing 3D cartoon aesthetics.
What's particularly interesting is the improvement in both visual fidelity and physical logic.
It seems Qwen is getting better at understanding not just how things should look, but how they should interact.
What if AI inference could become 1,000ร faster using physics from the 1980s?
Meet CRAM, an energy-based model inspired by Hopfield networks that challenges conventional approaches to AI reasoning.
The reported results are remarkable:
1,000ร faster training.
280ร lower compute requirements.
Nearly 100% Sudoku accuracy with just 30 training puzzles.
No backpropagation through time (BPTT).
Adaptive inference using energy minimization.
The interesting idea is simple: instead of repeatedly generating outputs, the model minimizes an energy function until it converges toward a solution.
Could energy-based models become an alternative paradigm for AI reasoning?
Paper: https://t.co/R0tw1jrmEE
Blog: https://t.co/1YpNjCCjrU
What we shipped this week @google
Monday: Two new 8th-gen TPUs
Tuesday: Gemini 4 Carbon
- AlphaProof Code verified Signal protocol
- Gemini Robotics 2.5
Wednesday: AlphaGenome 2 for disease research
- Gemini Decisions API in AI Studio
Thursday: Gemini 4 Hydrogen
- intelligent eyewear pre-orders
Friday: U2 new album (ok not us but exciting!)
onwards!
Run DeepSeek V4.1 Flash on RTX 3090/4090-Class GPUs with Tandem-vLLM
Tandem-vLLM 0.2.0 brings DeepSeek's massive MoE model to more affordable GPU setups using CPU-GPU expert offloading.
What's new?
Supports Ampere, Ada, Hopper and Blackwell GPUs.
Runs with a second GPU as an expert helper.
Stores compressed experts in system RAM and caches frequently used ones on GPUs.
Supports OpenAI-compatible APIs and continuous batching.
Reported performance:
Up to 93.1 tokens/sec with 2ร RTX PRO 6000.
26.7 tokens/sec with 2ร RTX A6000 using helper-GPU mode.
Requires at least 24GB VRAM on the main GPU and 128GB+ system RAM.
Real RTX 4090 benchmarks are still pending.
The interesting part: You no longer need multiple high-end GPUs to experiment with enormous MoE models.
Engine: https://t.co/jHn9zwSByr
Model: https://t.co/wmpFpt8WQK
#DeepSeek #LocalAI #vLLM #GPU #LLM