It takes time to create work that’s clear, independent, and genuinely useful. If you’ve found value in this newsletter, consider becoming a paid subscriber. It helps me dive deeper into research, reach more people, stay free from ads/hidden agendas, and supports my crippling chocolate milk addiction. We run on a “pay what you can” model—so if you believe in the mission, there’s likely a plan that fits (over here).Every subscription helps me stay independent, avoid clickbait, and focus on depth over noise, and I deeply appreciate everyone who chooses to support our cult.Help me buy chocolate milkPS – Supporting this work doesn’t have to come out of your pocket. If you read this as part of your professional development, you can use this email template to request reimbursement for your subscription.Every month, the Chocolate Milk Cult reaches over a million Builders, Investors, Policy Makers, Leaders, and more. If you’d like to meet other members of our community, please fill out this contact form here (I will never sell your data nor will I make intros w/o your explicit permission)- https://forms.gle/Pi1pGLuS1FmzXoLr6Thousands of engineering teams are burning margin, forcing heavy frontier models to handle basic production tasks because smaller, cheaper open-weight alternatives can’t deliver reliable outputs. And on the surface, they’re completely right.A model like Qwen3–4B — one of the best small open-weight architectures on the market — gets basic arithmetic wrong almost all the time, landing a correct answer just 32% of the time. With odds like that, you might as well hit the roulette and gamble like a proper degenerate.But if you dig into the failure data, an interesting stat emerges — it actually computes the correct answer inside its internal states an impressive 80% of the time. Somehow, the model gets to the correct answer and then veers off track. This tells us that the issue isn’t in the base intelligence (the model has the knowledge somewhere), but in navigation (discovering the knowledge reliably and then stopping). In fact, when we tracked whether models finished their responses naturally versus hitting the token limit, every single naturally completed answer was correct (across 500 generations). Wrong answers are destinations that our model failed to reach, not destinations that our model lacked in its map (full EOS analysis in the appendix).This means that models get trapped in an optimization loop — formatting, restructuring, and elaborating indefinitely — until they brick the run before ever stating the final result. What we need is a system that reliably find and unlocks the knowledge already hidden in the language model.Last time I wrote about Latent Space Reasoning, the system we broke down required a pretty sophisticated setup requiring trained judges, specialized aggregation, and a universal embedding projected space. Since then, our team at Irys has been exploring simpler ways to unlock the hidden knowledge in models that bring the power of latent space reasoning to less technical teams. And our results have been very compelling — Injecting just two random vectors into the model’s embedding space before it starts generating forces it to break the lock-in, spiking that 32% success rate straight to 51.6%. Re-read that number — we almost doubled accuracy by adding 2 random tokens.Bump that to ten random vectors with a basic plurality vote, and the success rate hits 72%. (Use plurality, not majority voting — majority actually performs worse than baseline when individual seed accuracy is below 50%. Details in the appendix.)At ten vectors, every single task in the benchmark gets solved by at least one seed — 100% oracle coverage extracted purely from random noise.On a Redis debugging task, the baseline model spit out 14 incoherent words. With two random tokens, every single seed produced a complete 650-word diagnostic plan.On 12 legal reasoning tasks, the top seed beat the baseline on 11 of them.Smaller models with perturbation beat or matched larger models of the same family more than half the time, proving that this technique unlocks a new axis of capabilities w/o needing increased hardware or training investment.These results allow us to get better performance from smaller models than from bigger models AND for lower cost (small model + multiple runs is much cheaper than big models).^^Experiment details on GitHub. Once again, our system unlocked performance that parameter scaling did not.Given how impactful our findings are for democratizing intelligence for everyone, we’ve open-sourced what we could on our latent space reasoning repo — github.com/dl1683/Latent-Space-Reasoning. While the effects of our research are statistically significant (McNemar p < 0.001 across two separate models), we recognize how small our sample size is. This is where we’d love to collaborate with the rest of our open community to scale up the experiments and look into different outcomes.The finding: A Qwen3–4B model computes correct arithmetic answers 80% of the time but only states them 32% of the time. The model isn’t failing to reason — it’s failing to finish. It gets trapped formatting answers it already computed.The fix: Injecting 2 random vectors into the model’s embedding space before generation breaks the lock-in. No training, no fine-tuning, one line of code. Accuracy jumps from 32% to 51.6% on a single seed, 72% with plurality voting across 10 seeds, and 100% oracle coverage — every task solved by at least one seed.It generalizes. On a Redis debugging task, baseline output was 14 incoherent words. With 2 random tokens, every seed produced a 650-word diagnostic plan. On 12 legal reasoning tasks, the best seed beat baseline on 11. On incident response, evolved vectors surfaced honeypot deployment, MITRE ATT&CK analysis, and HSM credential rotation from a 4B model that baseline could only get “rotate credentials, check logs” out of.Direction doesn’t matter. Random noise and carefully optimized projections produce identical results (Mann-Whitney p = 1.000). The perturbation provides energy, not information. Leading candidate explanation: stochastic resonance. Three independent groups (Kim et al., Shi et al., Pfau et al.) reached the same conclusion through different methods.Small models + perturbation beat bigger models. Scaling from 4B to 14B bought 4 percentage points on our arithmetic benchmark. Changing how we interrogated the 4B model bought 40. The 4B runs on a $429 GPU at 200 tokens/sec. The 14B needs a $1,999 GPU at half the speed. At cloud rates, 10 perturbation seeds cost $0.009/query versus $0.45 for GPT-5.6 Sol thinking tokens — 56x cheaper.Practical guardrails. Use 8-bit quantization, not 4-bit (4-bit nearly eliminates the effect). Use plurality voting, not majority (majority performs worse than baseline). If your model already scores 75%+ on a task, perturbation can hurt mean accuracy — it helps stuck models, not cruising ones.What doesn’t work. Our original verbosity claim was a code bug. The scorer is barely trained (broken on 9/12 legal tasks). DeepSeek showed a negative mean effect at high baseline. The data breach task exposed hallucination when the model lacked the knowledge entirely. Sample sizes are modest: 25 arithmetic, 5 planning, 12 legal tasks.What’s next. Temperature comparison (the test that determines if this is a new technique or a mechanistic insight), gated attention probe, position-shift ablation, scorer improvement. Full pipeline preregistered and open-source.The thesis: The industry’s default answer to “my model isn’t good enough” is a bigger model. Our results say that for a meaningful class of tasks, the capability was already in the small model — the bottleneck was the inference path. Lifting the ceiling gets the headlines. Raising the floor is where the new value gets created.Everything is open-source: github.com/dl1683/Latent-Space-ReasoningI put a lot of work into writing this newsletter. To do so, I rely on you for support. If a few more people choose to become paid subscribers, the Chocolate Milk Cult can continue to provide high-quality and accessible education and opportunities to anyone who needs it. If you think this mission is worth contributing to, please consider a premium subscription. You can do so for less than the cost of a Netflix Subscription (pay what you want here).Want access to a repository containing all of our research? 300+ files containing our notes of various experiments, discussions with cutting-edge teams, and insights into where the industry is headed next. Get a Founding Member Subscription to AI Made Simple. Want to talk to me for details/get my insights into the tech ecosystem? Reach out to me through any of my socials over here or reply to this email.The standard narrative (small open-weight model hallucinations/mistake are a result of their lower intelligence) is true quite often, but as we’ve derstand why, let’s quickly remind ourselves of what models are doing when they do inference.Language models generate text autoregressively — one token at a time. Because each token becomes part of the hard context window for every subsequent decision, the first token constrains the second, and the first two dictate the third. In our research across multiple models and sizes across multiple domains, we found that the first 20 generated tokens tend to disproportionately impact the AI context generation (even in very long context generations; research shared in our comprehensive proprietary AI research map available to all founding members of the Chocolate Milk Cult over here). This leads to the “autoregressive lock-in” phenomenon we have discussed extensively in the past.Image SourceIn practice, this will manifest in several ways:Models will spend tokens on the formatting and run out of their token budget, even when they know the answer.Models might follow a reasoning path, realize it’s no good (either themselves or by your injection), but the false path will STILL influence the outputs.The models you pay for by token are occasionally setting their token budgets on fire to format answers they’ve already computed. We can call this structural failure formal presentation mode. Left to its own devices, the model burns through its footprint producing immaculate headers, enumerated steps, and clean LaTeX expressions. In other words, it commits to a visual template and mindlessly fills it in — performing the aesthetic of math rather than actually doing the math (anyone getting shades of pulling up a terminal in front non coders to seem “hackery”).Knowing that, we decided to compute the geometry of the model’s search space (nerd stuff, not the most relevant here; check next section, GitHub experiments or gimme a shout if you want deets) and then used that geometry to disrupt that default trajectory by prepending a couple of random, noisy tokens to the embedding space. This pushed the models into exploratory computation mode — a messy, stream-of-consciousness scratchpad.Look at the text execution on the arithmetic problem (45 + 23) * 17 - 89:Without prefix (Wrong — bricks on the formatting template):Let me solve this step by step.