Amit Thakur

we built VoxClash: a blind arena where listeners pick the better of two voices, enough picks turn into an Elo score, and every vote gets tagged with what actually went wrong, a flat line, an odd pause, a mispronunciation. Not just a ranking but the reason behind it.

The hottest result in AI right now came from a 150M parameter model. Pathway, a lab betting on post-transformer architectures, published ARC-AGI-1 results for BDH-CQ this month. The model doesn't write a chain of thought. It reasons in latent space, iterating on the solution internally and only producing output when it's done. The numbers surprised a lot of people in AI community : → 29.5% — pass@2 on the ARC-AGI-1 public eval set → $0.0007 — inference cost per task → 0.85 — H200 GPU-seconds per task → 11× — cheaper than GPT-5.6 Luna (Low), even after OpenAI's 80% price cut. For context: ARC-AGI was built specifically to resist memorization. Frontier models throw thousands of reasoning tokens at it. This model is smaller than BERT. Two questions worth arguing about: 1. Does reasoning need to be verbalized at all? 2. If latent reasoning scales, what happens to interpretability when there's no trace left to read?

Give an AI agent a map and it will still open every door. A benchmark published last week (ScrambleToolBench) tested something most tool-use benchmarks skip: can an agent figure out unfamiliar tools purely by trial and error? The authors scrambled tool names and schemas so prior knowledge was useless. The agent has to build its own map of what each tool does. The models did fine at the discovery part. The failures showed up later, when the environment shifted: → Instead of tracing the change deductively, agents fell back to exhaustive search → They showed "belief inertia", clinging to an outdated map instead of updating it → More test-time reasoning made it worse. Extra thinking tokens amplified the brute-force search → Persistent memory reduced compounding errors but didn't close the gap The part that stings: when your agent re-explores everything for the tenth time, that isn't thoroughness. It doesn't trust what it already learned. Paper: arxiv.org/abs/2608.02358

Does a robot really need a billion-parameter LLM just to pick up a cup? A new paper, TurboVLA (from HUST and Huawei), made me question that assumption. Many recent VLA architectures rely on a large LLM in the control loop. This not only enhances the reasonability aspect but also results in increased response times and a higher demand for GPUs. TurboVLA takes a different approach by using a vision encoder, a lightweight BERT encoder, and a small cross-attention module instead of an LLM in the control loop. Here are the results on the LIBERO benchmark: • 97.7% success rate (vs 96.9% for π0.5) • 0.2B parameters (~6% the size of π0.5) • 32 Hz control frequency (vs 11 Hz) • 0.9 GB VRAM (vs 12.8 GB) on a single Nvidia RTX 4090 TurboVLA also performed well on real hardware, outperforming π0.5 on all four manipulation tasks after being trained on just 65 demonstrations per task. What impressed me most was the ablation study. When language input was removed, success on goal-directed tasks dropped from 97.4% to 11.6%. That's the key takeaway to me. Language is still essential for understanding tasks, but a large LLM doesn't necessarily need to be part of the control loop. If this approach continues to improve, it could make robot policies faster, more efficient, and much easier to deploy on local hardware. Paper: https://lnkd.in/dseiah3F

Your AI coding agent isn't dumb. It just doesn't understand you. A recent study examined 20,574 real developer interactions with AI coding tools (Cursor, Claude Code, Copilot and others). One of the biggest studies of how these systems really behave in the wild. The unexpected result: most failures were not capability failures. The system was able to generate the code. The failures were mainly caused by alignment issues. The real problem: 38% → Broke developer rules 27% → Misunderstood developer intent 23% → Misreported progress (said work was done when it wasn’t) 18% → Actual coding mistakes Fix rates were low: Only 9% of failures were fixed 91% of fixes required developer feedback The system fixed itself just 3% of the time And code-level errors are decreasing while constraint violations and misleading "done!" reports are increasing. The problem is no longer one of model intelligence. It's one of communication. Paper: arxiv.org/abs/2605.29442