Kylezz (@KylezResearch) profile picture

Student researcher exploring AI infrastructure, hardware, and how tech companies create value. Substack: https://xitter.cf/t.co/nAojxfbQWh

Silicon Valley
Joined June 2025
Photo by Kylezz (@KylezResearch)Photo by Kylezz (@KylezResearch)Photo by Kylezz (@KylezResearch)Photo by Kylezz (@KylezResearch)
Replying to @KylezResearch
If AI is going to reach software-like margins, the economics cannot depend on the lab paying for every token forever. Local LLMs are not just a privacy story. They are a margin story. New essay on Substack: kylezz.substack.com/p/the-fr…
1
1
514
Kylezz retweeted
The era of System One Vision Model is here! Introducing VFlash: parsing the visual world in parallel at unmatched speeds for Physical AI. Most embodied prediction tasks like object localization, robot trajectory planning, and dense 3D motion are fixed-length float vectors. For example, a bounding box is always 6 tokens, a 10-waypoint robot arm trajectory is 54: we know these beforehand. Instead of decoding one token at a time, we can output the entire geometric shape in one go. VFlash enables up to 12x faster action decoding and a 5.1x overall robot inference speedup on edge GPUs like the Jetson Thor and DGX Spark. What’s surprising is that it ends up even more accurate than the VLM backbone, with up to 61% lower 3D trajectory error. The intuition is that VFlash avoids the cascading errors of autoregressive decoding, where every coordinate is written in ink and every later point loses the chance to backspace. Everything that moves will be autonomous, and everything autonomous will need to think on its own chip. The next inference revolution is physical reasoning at the speed of reflex. And as always, it’s open paper, open source! Link in thread:
107
98
33
1,009
47,402
Many robotics startups build on top of the Universal Manipulation Interface (UMI) paper, a simple and efficient technique to collect data and easily use to train a policy that controls a robot. How it works:
10
21
4
259
38,541
Kylezz retweeted
Last week I experimented with GPT-6 Astra controlling my robot arm. The results were pretty incredible and reinforced a thesis I've been developing about the future of AI robotics. Instead of giving an AI direct control of the robot's motors, I gave Astra a set of basic capabilities: - A RealSense depth camera to observe its environment - Linear movements within a bounded workspace - A gripper with a fixed downward orientation From there, I had Astra write its own robotics software, using YOLO for object detection and OpenCV for localization. The result? I can now give the robot a prompt like "arrange these blocks in a 2×2 grid," and it can identify their positions, plan the movements, and execute the task. Here's what I think is interesting: We're seeing increasingly capable multimodal LLMs that can reason about physical environments and write the code to interact with them. Rather than relying exclusively on end-to-end "physical intelligence" models to directly control robot joints, we can use coding agents to generate deterministic robot programs that can be inspected, tested, and validated before execution. There are still limitations. Astra's coding and reasoning can be slow, sometimes taking 5-10 minutes to implement a new capability. But once that code works, the robot can execute it repeatedly without waiting for the model to regenerate it. And modular software architectures are already helping reduce that iteration time too. I believe this approach could be one of the fastest paths to bringing AI into real industrial robotics. Imagine a factory where an operator describes what needs to be automated, and an AI agent observes the environment, writes the robot program, and iterates until the task works. We're not there yet. But the building blocks are coming together.
26
12
3
104
4,398
Wow this is one of the most important local AI breakthroughs of the year
Today we are happy to share one of our first open research releases: Latent Sparse Attention (LSA), a step towards subquadratic attention that matches accuracy of full attention at ultra-long context. Sparse attention attends to only a few tokens per query, but it has to find the right ones. At 10M tokens, that search takes 98% of the attention layer's time. LSA makes sparse attention up to 22.7× faster and full attention 72.4x faster. With @kubicek_ales @caciolai @PengLiangzu @SukritSumant @Ben_Hoov @FraserGreenlee @RMBattleday @radim_urban @thoefler @jcrwhittington
1
1
3
250
Voice Ring: Voice library with sound direction and emotion recognition. It reacts to the direction of sound using the on-device Libraries Voice Direction model + emotion2vec and SamLowe models for emotion recognition. libraries.dev/voice-ring
13
20
3
511
22,486
A lot of my CUDA/GPU posts explain how kernels, threads and memory work. but i never explained how it looks like in code so im turning that into a repo with runnable CUDA C++ examples, from basics to GEMM, profiling and transformer kernels. check it out: github.com/navaneethkrishnan…
2
10
65
2,307
Vision foundation models like DINO and SigLip now power much of robot learning. But they are built for RGB. What about depth? Introducing DeFM: a foundation model for depth images, built for robotics. 🌐 de-fm.github.io Weights, code, and demo are out today 🧵
22
73
11
447
27,909
Quick video showing some of the "Reactivity & Recovery" capabilities of Instant Robot Learning at @Machenta_: 1. One real demonstration: putting blue object in grey box and closing box. 2. Robot reacts in real time when object and box are moved around, with a closed-loop end-to-end policy. 3. Robot recovers when object is pulled out of gripper, and re-grasps it. 4. Robot notices that object is removed from box, and places it back in. 5. Robot notices that box lid is opened, and re-closes it. The important part: 1. None of this reactivity and recovery needed to be shown in the demonstration: it all comes from the intelligence of the pre-trained model. 2. Model has never seen these objects before. It is trained 100% in simulation, and these objects were not in the simulation. machenta.com/blog/instant-ro…
6
15
4
102
6,719
Meet MatAnyone-E: high-quality video matting, much faster. ✂️ Compared with MatAnyone 2 at 4K: ⚡ ~7.4× faster inference 💾 Just 7.6% of the peak GPU memory ✨ Comparable matting quality Runs at 73 FPS at 1080p and 29 FPS at 4K on a single NVIDIA H200. Project: shuyun-wang.github.io/projec… Paper: arxiv.org/abs/2610.35724 Code (coming soon): github.com/Shuyun-Wang/MatAn…
8
23
2
155
7,455
Wrote up how agent tool calls interact with GPU memory and scheduling in inference serving.
4
5
13
627
Gonna test it out today
Run a 763B-parameter model locally. DeepSeek-V4.1-Flash-1017 on a 12GB GPU. Frontier quality with GSQ-RCO quants, directly supported in the Strata inference engine. Further info below. Much more to come. Follow for updates.
27
Introducing 𝑨𝒕𝒕𝒆𝒏𝒕𝒊𝒐𝒏 𝑹𝒆𝒔𝒊𝒅𝒖𝒂𝒍𝒔: Rethinking depth-wise aggregation. Residual connections have long relied on fixed, uniform accumulation. Inspired by the duality of time and depth, we introduce Attention Residuals, replacing standard depth-wise recurrence with learned, input-dependent attention over preceding layers. 🔹 Enables networks to selectively retrieve past representations, naturally mitigating dilution and hidden-state growth. 🔹 Introduces Block AttnRes, partitioning layers into compressed blocks to make cross-layer attention practical at scale. 🔹 Serves as an efficient drop-in replacement, demonstrating a 1.25x compute advantage with negligible (<2%) inference latency overhead. 🔹 Validated on the Kimi Linear architecture (48B total, 3B activated parameters), delivering consistent downstream performance gains. 🔗Full report: github.com/MoonshotAI/Attent…
327
2,001
524
13,294
5,165,272
AI weather models see the world on a grid. One cell over the Alps says 24°C, but inside it, the peaks are 12°C and the valleys 36°C. Big labs fix this by building bigger, higher-resolution models. We tried something cheaper. Keep the global model, and train a small model on top that learns how mountains, valleys and coasts shape the local weather. We trained it in 1 hour on a single GPU. It takes forecasts over France from ~28 km to 5.5 km, and gets closer to what weather stations actually measure, especially in the mountains. You can read more about how we trained the model on our blog post: huggingface.co/blog/EmmaScha… and try the model yourself on our demo space: huggingface.co/spaces/EmmaSc…
19
27
7
272
14,635
Context isn’t just what you put in a prompt. It’s also what stands between a robot and its goal. Robot policies in everyday environments must generalize not only across objects, but also across the spatial contexts in which they appear. Excited to share COWBOY 🤠 (CoRL 2026) — our sim-to-real recipe for contextual whole-body manipulation. One generalist grasping policy coordinates base, arm, dexterous hand, and active vision end-to-end, adapting its motion and grasps to object and scene geometry. Trained in simulation, deployed zero-shot in the wild. w/ @JasonJZLiu @LiuMuxinl 🧵(1/N)
14
46
12
188
64,474
I bet such flow and local decisions models will soon be integrated into operating systems
Jev Founder, Diogo Amogo, just released a PDF on building a Jev Harness for coding agents this is a blueprint on how to make your coding agents 200× faster and 400× cheaper Send this PDF and the article below to your Claude Code or Codex instance and start shipping 200× faster 👇
33
A good overview. TBH you could just change the final layer of an LLM and its activation function to build your own Jev. It will likely be absorbed into LLMs in the next few months. Definitely something very suitable for local.
52
Kylezz retweeted
A full MIT course on visual autonomous navigation. If you work on robotics, drones, or self-driving systems, this one is worth bookmarking‼️ MIT’s Visual Navigation for Autonomous Vehicles course covers the full perception-to-control stack, not just isolated algorithms. What it focuses on: • 2D and 3D vision for navigation • Visual and visual-inertial odometry for state estimation • Place recognition and SLAM for localization and mapping • Trajectory optimization for motion planning • Learning-based perception in geometric settings All material is available publicly, including slides and notes. 📍vnav.mit.edu/ If you know other solid resources on vision-based autonomy, feel free to share them. —- Weekly robotics and AI insights. Subscribe free: 22astronauts.com
11
313
8
2,100
76,244
Brilliant paper by NVIDIA. they found a way to make KV cache transferable between models. the target model skips prefill entirely, and the conversion runs 2.7 to 25x faster than processing the context again. let's understand why this is so important today. LLM APIs are stateless, so every turn sends the entire conversation back to the model. the model reads it again before generating a new token, and all of it is billed as input. prompt caching lets providers hold the KV cache for a stable prefix and bill cache hits at roughly 10% of the base input rate because that compute was already done. this 90% reduction is one of the biggest levers in LLM serving. but the cache only works on the model that produced it. since keys and values depend on that model's weights, another model cannot directly reuse them. this becomes a problem with LLM routing. if traffic moves to another model for cost or capability reasons, the accumulated KV cache becomes invalid. the entire context must be processed again and billed at full rate. NVIDIA's recent paper treats this as a representation problem. prefill's main output is the KV cache, so transferring it means converting one model's cache into the representation another model expects. they first checked whether this conversion had enough structure to exploit. for Qwen3 14B → 32B, a linear regression from a single source layer reconstructed 56% of the variance in the target model's keys. because models can have different layer counts, there is no natural one-to-one layer mapping. so, for every target layer, they rank the source layers by predictive power and use the top eight together. that pushes reconstruction to 79%. the mapper has three parts: > each target layer and head gets its own linear map, solved in closed form instead of with gradient descent. > cross-layer selection chooses the source layers that best predict each target layer. their ablation shows this contributes the most. > RoPE adds a position-dependent rotation to keys. they remove it, fit the mapping in position-free space, then apply the target model's rotation again at inference. across six model pairs from Qwen3, Llama 3.1, and Ministral 3, four retain 73 to 98% of the receiving model's standalone accuracy. conversion is also 3 to 25x faster than processing the context again. prior cross-model KV reuse methods either train a neural adapter for every pair or require architecturally identical models. this approach is closed-form and training-free, but there are still important limitations. every tested pair belongs to the same model family, such as Qwen → Qwen or Llama → Llama. cross-family transfer is still future work. the tested pairs also share KV head count and per-head dimension. mismatched configurations remain untested. and the work currently covers dense full-attention models only, not sliding-window or attention-recurrent hybrids. link to the paper: arxiv.org/abs/2608.03893 i wrote a first-principles breakdown of how KV caching works the article is quoted below.
55
303
25
2,216
240,052
Chinese researchers did it again! Moonshot AI proved that 95% of attention computation is completely wasted.. They’ve open-sourced the exact attention mechanism powering Kimi's long context.. and it's 16x faster. It’s called MoBA (Mixture of Block Attention). Every time you feed an AI a massive prompt, every token desperately tries to look at every single token that came before it. The math scales quadratically ($O(N^2)$). It’s like reading a 500-page book and re-reading the entire thing from word one every single time you want to understand a new sentence. Moonshot looked at this waste and said: No. Instead of forcing full, brute-force attention across everything, MoBA applies the principles of Mixture of Experts (MoE) directly to the attention layer. How it works: • It chops the context history into discrete blocks. • A lightweight dynamic gating mechanism lets each query token instantly "vote" and route only to the specific blocks that actually matter. • It achieves up to 95% sparsity on long contexts without sacrificing performance. The results are staggering: It maintains full-attention accuracy on 1-million-token contexts while slashing massive compute overhead. We are watching the structural efficiency barrier of long-context AI get smashed in real-time. While Western labs argue about how to afford million-token context windows, Moonshot open-sourced the blueprint to make them radically cheap.
52
342
33
2,365
106,769
I have been playing with freetoken for the last two weeks and was really impressed. It figured out a clever way of caching the experts in MOE models by automatically trading off system memory bandwidth and VRAM bandwidth. Local AI exploitation is imminent now!
Qwen3.8-Flash-Next now runs on a single RTX 5090 at 68.3 tok/s — no extreme quantization, no speculative decoding. · Production-level checkpoint: GB300-validated NVFP4 checkpoint from RadixArk · 63GB host RAM — less than what 1-bit quants of this model need · The 51GB n-gram table? It lives on your NVMe, at ~0.5% throughput cost In the video: one prompt → a playable minecraft-style world, then FreeToken on my 5090 desktop fixing a real FreeToken bug in 10.5 minutes. Meet FreeToken 🧵
2
1
3
544