Albert Cohen

A team of Claude Code agents with Opus 4.6 can execute large, complex software projects without human supervision when supported by harnesses and tests. Sixteen parallel agents ran continuously in isolated containers, coordinated through a simple locking mechanism on a shared repository, and collectively produced a clean room Rust C compiler capable of building the Linux 6.9 kernel across multiple architectures. The key insight was that sustained autonomy depends less on prompting and more on environmental design, especially high quality tests, concise and machine readable feedback, and structures that make parallel progress possible. Deterministic subsampled testing, aggressive regression prevention, and explicit project state documentation allowed agents to orient themselves and recover from errors. Parallelism enabled specialization, but only when large tasks were decomposed using external oracles to avoid duplication of effort. The experiment demonstrated that current models can reach the edge of end to end systems programming, while also exposing limits in robustness, efficiency, and architectural judgment that frequent changes still destabilize. https://lnkd.in/gWNvhx7D

6

Inside VOLT: Designing an Open-Source GPU Compiler (Tool) Recent efforts in open-source GPU research are opening new avenues in a domain that has long been tightly coupled with a few commercial vendors. Emerging open GPU architectures define SIMT functionality through their own ISAs, but executing existing GPU programs and optimizing performance on these ISAs relies on a compiler framework that is technically complex and often undercounted in open-hardware development costs....

20

Impressive milestone of the Technology Innovation Institute's quantum-inspired algorithms and quantum middleware teams together with NVIDIA. This is what happens when strong algorithms theory (graph tensor networks plus belief propagation) meets power GPU-acceleration. Thanks in particular to Ilia Luchnikov, Daniel Vieira, Stefano Carrazza, Stefano Mensa, PhD MBCS, Esperanza Cuenca Gómez, Mazen Khalil, Nicholas Harrigan, and Elica (Elitsa) Kyoseva. See https://lnkd.in/daynMAZh for details.

56

2 commentaires

The PyTorch 2.9 release delivers measurable performance gains on Arm CPUs, with contributions from Arm’s engineering teams across core areas of the stack. This includes optimizations through oneDNN and OpenBLAS, improved operator coverage, and stronger compiler consistency, all designed to deliver faster, more stable AI workloads on Arm platforms. These updates are part of Arm’s ongoing collaboration with the PyTorch community to enable open, efficient, and scalable AI performance for developers everywhere. Read more about what’s new and see you next week at PyTorch Conference: https://okt.to/91w4kU

8

In this new video (https://lnkd.in/dumY28mt), Fernando Pereira presents ongoing work at UFMG's Compilers Lab focused on the design and implementation of more efficient tensor compilers. A tensor compiler is a tool that translates machine learning models, expressed in high-level representations such as Torch, TensorFlow, or ONNX, into low-level, highly optimized machine code. Over the past two years, researchers at UFMG's Compilers Lab, in cooperation with Universidade Estadual de Campinas and Cadence have been developing improved kernel fusion algorithms and autotuning techniques. Kernel fusion is a classic compiler optimization that combines two or more sequences of loops into a single loop. In modern tensor compilers, this optimization can also be viewed as a variation of instruction selection, where the implementations of multiple kernels are replaced by a single kernel that preserves their combined semantics. We have designed and implemented a new kernel fusion algorithm that currently runs in the XNNC compiler from Cadence Design Systems [1]. Autotuning is a profile-guided optimization technique in which the compiler runs a program, collects profile data, and uses that information to select the best optimizations for the program before recompiling it. This feedback loop continues until performance converges to an acceptable level. We have designed an algorithm, called Droplet Search, that maps the search space of optimization parameters (such as unrolling factor, tiling window, and number of threads) to a coordinate space. Droplet Search then applies Coordinate Descent to find the best combination of optimization parameters for a given kernel [2, 3]. This algorithm is currently integrated into Apache TVM. References: [1] Michael Canesche, Vanderson Rosario, Edson Borin, Fernando Pereira: Fusion of Operators of Computational Graphs via Greedy Clustering: The XNNC Experience. CC 2025: 117-127 (https://lnkd.in/dsQJtSkz) [2] Michael Canesche, Vanderson Martins do Rosario, Edson Borin, Fernando Magno Quintao Pereira: The Droplet Search Algorithm for Kernel Scheduling. ACM Trans. Archit. Code Optim. 21(2): 35, 2024 (https://lnkd.in/dBfQid9z). [3] Michael Canesche, Gaurav Verma, Fernando Magno Quintao Pereira: Explore as a Storm, Exploit as a Raindrop: On the Benefit of Fine-Tuning Kernel Schedulers with Coordinate Descent. CoRR abs/2406.20037, 2024 (https://lnkd.in/dgxxfdYR). #compiler #research #academia #tensorcompiler #machinelearning

79

🚀 500 → 645 stars on 🍋 Lemonade repo in the time it took to write this post! Developers worldwide are sending a clear message: local LLMs need to be… 1️⃣ Optimized for each PC (NPU, ROCm, etc.) 2️⃣ Zero-friction for users and developers alike 3️⃣ Committed to open-source principles The team at AMD, alongside a fast-growing community of contributors and mentorship from Open Core Ventures Catalyst, is delivering on all three ✨ 👉 Star the repo: https://lnkd.in/ebfd_f75 👉 Join the conversation: https://lnkd.in/e8unnwXD Huge thanks to everyone making this possible, including: Victoria Godsoe Daniel Holanda Noronha Ramakrishnan Sivakumar Tomasz Iniewicz Kalin Ovtcharov Iswarya Alex Mike Kraus Somayeh Rahimipour Adrian Macias Richter Edan Sasson Joseph Melber Phil James-Roxby Ramine Roane Hisham Chowdhury Tyler Straub Kevin Ding Matthew Letts Joe Pizzini Ryan Radjabi Hyunho Ahn Patrick Worfolk Gabriel Weisz Rajeev P. Ashish Sirasao Alex Smith #LocalLLM #OpenSourceAI #technology #developers #AMD

47

9 commentaires

NeMo RL now supports the Decoupled Clip and Dynamic Sampling Policy Optimization (DAPO) algorithm. DAPO enhances the Generalized Reinforcement Policy Optimization (GRPO) by incorporating several advanced features: - Clip-Higher - Dynamic Sampling - Token-Level Policy Gradient Loss - Overlong Reward Shaping These additions aim to provide more stable and efficient reinforcement learning training. For further details, refer to the DAPO guide. https://lnkd.in/geGgziXy

112

Most LLM evaluation pipelines rely on static test sets or uniform sampling, allocating equal effort across all prompt categories. This leads to inefficient use of evaluation budget and slower failure discovery. I modeled evaluation as a resource allocation problem and applied multi-armed bandit algorithms (UCB1 and decaying epsilon-greedy) to dynamically prioritize high-risk prompt regions. Across 30 independent runs (20,000 plays each): UCB1 final regret: ~104 Epsilon-Greedy (decaying): ~12 p = 0.0012 (paired t-test) This shows a statistically significant advantage for adaptive exploration in concentrating evaluation effort where failures are more likely. https://lnkd.in/g6jDS4M4 #MachineLearning #LLM #Algorithms

13

5 commentaires