← All editions

Planning, memory, and the cost of doing the work

For the first edition, a tour of what it takes to make intelligent systems dependable after the demo: planning through world models, gathering and evaluating robot experience, serving a policy on-device, and measuring whether language agents remember and repeat what matters. A few older research pieces are here because their mechanisms illuminate the newer engineering reports.

Research and editorial drafts prepared with Codex; reviewed and published by Tinkerer's Hall.

01 / Research
Berkeley AI Research· Physical AI

Gradient-based Planning for World Models at Longer Horizons (opens in a new tab)

THE EDITOR’S NOTE

A world model can predict future states yet remain hard to plan through. GRASP makes long-horizon optimization less brittle by relaxing trajectories and avoiding unreliable state gradients. Read the Push-T comparison for the gain and its simulation-bound limit.

In brief: Gradient-based Planning for World Models at Longer Horizons

A world model can predict what follows an action without making a long sequence of actions easy to plan. This research traces the difficulty to unstable gradients, local traps, and imagined states that exploit weaknesses in the learned model. GRASP optimizes intermediate states alongside actions, adds noise to explore alternatives, and avoids the most brittle gradient paths. In the simulated Push-T task it generally finds successful longer plans more often and faster than the compared methods. Success still falls as the horizon grows. The result is a promising planning method, with closed-loop deployment and broader validation left as further work.

In this edition

11 more reads
02 / Research
Physical Intelligence· Charles Xu et al.· Physical AI

Precise Manipulation with Efficient Online RL (opens in a new tab)

THE EDITOR’S NOTE

Physical Intelligence compresses a VLA representation into an RL token so small actor and critic networks can refine precise manipulation through online practice. The Ethernet-insertion result is striking; read the four-task evaluation before generalizing it to other hands or jobs.

In brief: Precise Manipulation with Efficient Online RL

A general-purpose robot policy may handle most of a task yet struggle at its precise final movement. Physical Intelligence addresses that gap by compressing a large vision-language-action model's internal representation into an RL token. Small actor and critic networks use that representation to refine behavior through practice, without repeatedly retraining the whole model. The team reports improvements on four manipulation tasks, including Ethernet insertion and fastening a zip tie. The Ethernet experiment used fifteen minutes of robot experience within two hours of training and resets. These are targeted gains on difficult task stages, not evidence that every robot skill can improve equally quickly.

03 / Implementation
Hugging Face· Physical AI

Grabette: an open system to record robot-manipulation data (opens in a new tab)

THE EDITOR’S NOTE

Robot learning needs demonstrations before clever policies. Grabette describes a buildable handheld gripper, synchronized capture, SLAM processing, and LeRobot export. Read the end-to-end cup-grasp example, while keeping the proposed large shared dataset separate from what is demonstrated today.

In brief: Grabette: an open system to record robot-manipulation data

Grabette makes it possible to record manipulation demonstrations with a handheld gripper before owning or teleoperating a robot. Separate cameras capture the scene and support motion tracking, while synchronized measurements preserve the relationship between hand movement and gripper state. A processing pipeline checks trajectories and exports demonstrations in LeRobot format. The authors show a cup-grasping example trained from two hundred demonstrations and executed with a matching robotic gripper. The central contribution is the open recording system and its workflow. The proposed large community dataset remains an ambition, and transferring recorded behavior still requires suitable robot hardware and training.

04 / Implementation
NVIDIA Physical AI· Tanya Lenz· Physical AI

How to Train a Cross-Embodiment Robot Navigation Policy with AI Agents (opens in a new tab)

THE EDITOR’S NOTE

A practical navigation workflow across robot embodiments: register the scene, verify maps and clearance, run a one-environment smoke test, then train and evaluate under matched conditions. Read for its explicit evidence gates, especially before moving from synthetic scenes to a target robot.

In brief: How to Train a Cross-Embodiment Robot Navigation Policy with AI Agents

NVIDIA's COMPASS workflow adapts an existing navigation policy to a particular robot and environment instead of learning navigation anew. Coding agents help prepare scenes, validate dependencies, run small tests, train residual policies, and compare checkpoints under matched conditions. Human approval remains part of scene acceptance and promotion of a trained candidate. The reference uses a Spot quadruped and includes built-in, generated, and reconstructed environments. Its practical value is the sequence of evidence checks around training. The coding agent is a development assistant; the exported policy controls the robot at runtime, and a successful simulation run does not establish safety in every physical setting.

05 / Implementation
NVIDIA Physical AI· Michelle Horton· Physical AI

Post-Train NVIDIA Cosmos 3 Edge for On-Device Robot Control (opens in a new tab)

THE EDITOR’S NOTE

On-device control is a tradeoff, not a slogan. This tutorial shows a 4B policy producing action chunks on Jetson Thor, alongside 22.9% success on a 120-task simulated suite and substantial post-training compute. Read the receding-horizon loop and the limits behind its real-time claim.

In brief: Post-Train NVIDIA Cosmos 3 Edge for On-Device Robot Control

This tutorial turns a compact world foundation model into a manipulation policy that fits on Jetson Thor. Rather than choosing an action after every observation, it predicts chunks of movement and replans while the preceding chunk executes. NVIDIA reports roughly 1.53 seconds to generate a chunk covering about 2.13 seconds of motion, allowing continuous operation in its setup. The training data and deployment workflow are provided, alongside a 22.9 percent success rate across 120 simulated tasks. The interesting result is the combination of local inference and an explicit control loop; continuous motion and useful general-purpose task reliability remain different measures.

06 / Implementation
Hugging Face· Physical AI

LeRobot v0.6.0: Imagine, Evaluate, Improve (opens in a new tab)

THE EDITOR’S NOTE

LeRobot v0.6 links world-model policies, reward models, simulation benchmarks, richer datasets, and a rollout CLI. Read it as a map of the practical robot-learning loop: imagine, measure success, collect corrections, and try again. Follow the linked docs for the individual methods.

In brief: LeRobot v0.6.0: Imagine, Evaluate, Improve

LeRobot v0.6 organizes a robot-learning workflow around proposing behavior, measuring whether it works, and collecting corrections. The release adds policies that use world-model learning, reward models for assessing success, and a shared interface for several simulation benchmarks. A rollout command supports deployment and human corrections that can become further training data. Dataset improvements include depth information, annotation tools, and loading changes. This is a useful map of an expanding open robotics toolkit, rather than one controlled experiment proving every component works together equally well. Each policy and benchmark still has its own hardware requirements, evaluation assumptions, and limits.

07 / Research
Berkeley AI Research· LLMs & agents

Teaching LLMs to Update Beliefs for Efficient Long-Horizon Interaction (opens in a new tab)

THE EDITOR’S NOTE

ABBEL treats a long-running agent summary as a belief state and trains it to preserve useful observations. Its coding benchmark narrows, but does not erase, the gap to full context. Read for a measured answer to what an agent should remember while working over many steps.

In brief: Teaching LLMs to Update Beliefs for Efficient Long-Horizon Interaction

Long-running language-model agents cannot keep every interaction in context indefinitely, but repeated summarization can discard information needed later. ABBEL treats a compact natural-language summary as a belief state and trains the model to update it while preserving useful evidence. A separate grading signal rewards summaries that support reconstruction of recent observations. In collaborative coding experiments, this recovers about half the performance gap to a full-context baseline while using fewer context tokens and training steps. Results also cover a guessing game and question answering. The method makes memory quality a training objective; it does not show that compressed context universally matches a complete history.

08 / Implementation
Hugging Face· LLMs & agents

tokenizers v1: encode, decode and scaling, measured (opens in a new tab)

THE EDITOR’S NOTE

Tokenization becomes visible when training and serving scale. This measured Rust redesign changes splitting, caching, and the merge loop while preserving token IDs. Read the benchmark method and workload assumptions before carrying its speedups into your own inference stack.

In brief: tokenizers v1: encode, decode and scaling, measured

As model serving and training accelerate, CPU tokenization can become a bottleneck despite being cheap relative to the model itself. This account describes the upcoming tokenizers v1 redesign, which aims to preserve token IDs and supported tokenizer families while reducing work in splitting, caching, and byte-pair merging. The authors compare throughput, latency, memory, languages, and scaling across threads, and provide a benchmark harness for reproduction. Its lesson is that substantial gains can come from data representation and workload-aware implementation without changing output semantics. The reported improvements depend on tokenizer family, hardware, and input distribution, so they need checking against a reader's own workload.

09 / Research
Hugging Face· LLMs & agents

Your Agent Aced the Task. Will It Do It Again? (opens in a new tab)

THE EDITOR’S NOTE

Average task success can hide whether an agent will succeed again. IBM resamples decision points from a recorded trace and generates guidelines for unstable choices. Read the Pass^5 evaluation, then ask how far its AppWorld result carries to your own agent environment.

In brief: Your Agent Aced the Task. Will It Do It Again?

An agent's average success rate can conceal whether it completes the same task reliably on repeated attempts. IBM contrasts that average with Pass^5, which counts tasks successful on all five runs. Its analyzer resamples decisions from an existing trace to locate unstable choices, then turns those findings into reusable instructions. On the reported AppWorld setup, these instructions improve repeated-run success while preserving average performance. The diagnostic does not require replaying every external action, which makes the approach appealing for costly workflows. The evidence is still tied to the tested agents and environment, and consistent decisions can remain consistently wrong.

10 / Implementation
GitHub Engineering· Erik Kristensen· LLMs & agents

How we make AI coding more cost efficient without sacrificing task quality (opens in a new tab)

THE EDITOR’S NOTE

GitHub shows why shorter tool output can cost more if it forces extra agent turns. Its harness changes were tested offline and online; one prompt compression initially caused agents to run sequentially. Read for the measurement loop and the regression, not only the token savings.

In brief: How we make AI coding more cost efficient without sacrificing task quality

GitHub evaluates coding-agent efficiency across a completed task rather than one tool response. Removing text can increase total cost when the model has to reopen output or repeat commands to recover missing context. The team describes selective compression of repetitive logs, removal of unnecessary formatting, shorter instructions, and delivery of completed background work with fewer round trips. Changes were tested with offline benchmarks and controlled online experiments. One prompt change initially altered useful parallel behavior, illustrating how a small saving can hide a regression. The findings concern GitHub's harness and workloads; the general lesson is to measure task quality and total work together.

11 / Implementation
Alex Kladov· Other engineering

Finding Bugs (opens in a new tab)

THE EDITOR’S NOTE

A small differential fuzzer for Rust regex finds one known bug and another unexpected one. Read how the author builds an oracle and varies tiny inputs; it is a concrete lesson in making generative tests reveal a class of failures.

In brief: Finding Bugs

Alex Kladov builds a small randomized test to find a known bug in an older Rust regex implementation and discovers another bug along the way. The important ingredient is an oracle: a simpler implementation whose answers can be compared with the implementation under test. He then designs generators that emphasize small, awkward combinations of features instead of merely producing enormous random inputs. The post argues that a bug missed by a fuzzer is evidence to improve the fuzzer itself. Kladov is explicit about the experiment's limits: he knew the target bug beforehand and found no failures in the current version.

12 / Migration
GitHub Engineering· Josh Black· Other engineering

Improving site performance by shipping more CSS (opens in a new tab)

THE EDITOR’S NOTE

GitHub's move from CSS-in-JS to CSS Modules is a rollout and measurement story. Read for the compatibility wrappers, feature flags, visual regression checks, and server-rendering gains that let a widely used design system change in stages.

In brief: Improving site performance by shipping more CSS

GitHub's Primer team moved from runtime CSS-in-JS styling to CSS Modules to reduce the cost of rendering and initializing large component trees. The difficult part was changing a widely used design system without breaking its consumers. Components gained equivalent stylesheet implementations behind feature flags, supported by visual regression tests and gradual rollout. Compatibility work allowed teams to move away from dynamic styling APIs over time. The article reports substantial rendering improvements in that environment. It is most useful as an account of measurement and migration at scale, rather than proof that one styling approach will always be faster in every application.

Illustrations assisted by AI, reviewed by the editor.

THE CONNECTING THREAD

Ideas travel between disciplines.

GRASP and ABBEL both make long horizons tractable by choosing what state to carry forward. Grabette and LeRobot expose the data and evaluation loops behind robot policies. The tokenizer, Copilot, fuzzing, and CSS stories show the same engineering instinct elsewhere: measure the bottleneck, preserve correctness, and iterate against evidence.