Research, explained

The researchers built an AI-driven lab setup that can run its own experiments and then rewrite its own tools based on what it measures. They tested it on a tricky problem: making the colors shown in smart glasses (RayNeo X3 AR glasses, controlled from an iPad) match target colors, using a precision light-measuring instrument to check the real output. The AI updated the glasses' software to hold colors steady on screen while the instrument measured them, then used those measurements to fix its own color predictions. One target color's error dropped from 19.756 to 1.211 (on a standard scale where about 1 is barely noticeable to the human eye), and all five target colors improved. What sets this apart is that the AI doesn't just run experiments on fixed equipment; it changes the hardware interface, software, and methods itself when the physical evidence shows something is lacking.

When researchers train many AI agents together (like a swarm of drones or a network of cell towers), the AI's decisions can be sped up using graphics chips, but the simulated world they live in still gets updated one piece at a time on the regular processor, which becomes the bottleneck. The team built SEER, a program that breaks each simulation step into a stream of small, time-stamped events and runs the independent ones at the same time on many processor threads, while still giving exactly the same results as running them one by one. It also includes a tool that quickly tests and picks the best number of threads for each job. In tests, SEER cut delay by 16.2% on a drone-swarm control task, and on a wireless-network task it ran 46.9%, 19.5%, and 64.9% faster than three existing simulation engines (ROSS-T, NBSE, and ROOT-Sim).

Most humanoid robots are trained to act alone, so they can't smoothly move together with a person the way two people naturally do when they hug, hand something over, or dance. The researchers built a system called Social Humanoid that watches a person's movements and makes a Unitree G1 robot (29 joints) respond in real time, even guessing where the person's body is going when the robot can't see them. To teach it, they created a way to convert human-to-human interaction recordings into robot-sized versions that keep touches and reach realistic, producing a new benchmark of 260 hours of human-humanoid interactions from five existing motion-capture datasets. The system worked in both simulation and on a real robot across several kinds of interactions, something earlier solo-trained humanoids couldn't do.

Researchers built GPUMAP, a tool that takes huge piles of complicated data, like millions of images or sensor readings, and squashes them into a 2D map that people can look at, so similar items end up close together. Normally this squashing takes a long time and you have to wait for it to finish before seeing anything. GPUMAP instead shows a rough map right away and keeps sharpening it as it works, using the graphics chip (GPU) in an ordinary computer to run many calculations at once. This lets people explore datasets with millions of points interactively on regular consumer hardware. The abstract doesn't give speed numbers, but the team also studied how the map changes over time and what happens when the incoming data is lopsided or biased, which affects how trustworthy the early rough maps are.

The researchers tested a new way to help people steer underwater robots (called ROVs) through dangerous water. They put a soft, vibrating touchpad in the operator's hands that 'told' them about invisible side currents pushing the robot off course, then ran real tests in a water tank with controlled currents. Without the touchpad, hitting a hidden current made pilots feel more physically stressed and rushed; with it, those feelings dropped and pilots rated their own performance higher. The twist is that the touch feedback also made the task feel mentally harder and more frustrating, yet pilots still drove significantly faster, which suggests they trusted what they were feeling. The paper does not give exact numbers in its abstract, so the key finding is the pattern: more brain effort, but more confident driving. Earlier work mostly relied on screens and cameras, whereas this study shows that touch alone can warn pilots about hazards they cannot see.

Researchers built ProtoGestalt, an AI system that looks at photos of faces to help spot rare genetic disorders, which are often missed because their signs overlap and are hard to tell apart. Unlike many AI tools that give an answer without explaining it, ProtoGestalt is built to compare a face against learned 'prototypes' tied to specific areas of the face (like the eyes or jaw), so it can show which facial regions pushed it toward a diagnosis. The team tested whether it could tell faces with a genetic syndrome from unaffected faces, even when most of the images were healthy, and whether it could tell different syndromes apart. It separated syndromic from healthy faces well and kept working as the share of healthy faces went up, but the abstract doesn't give specific accuracy numbers, and the authors admit that existing specialized models for this task are already reasonably accurate.

Researchers built a robot-arm controller called the Harmonic-Passive Motion Paradigm (H-PMP) that is designed to make robots touch and push on things the way a person does: firm when it needs to be, gentle when it needs to be, and never dangerously forceful. They tested it on a Kinova Gen3 robot arm in three tasks: following a path, pressing against a wall (including what happens when the wall suddenly disappears), and learning a movement by being shown it. Compared with older versions of their controller, the new one switched smoothly between being stiff and being yielding without needing extra computing power. The abstract doesn't give specific numbers, so the main result is this smooth switching, and the team also released free open-source software for ROS2, the MuJoCo simulator, and real robot hardware so others can use it.

Researchers built USB Gym, a virtual practice arena where a computer program learns to move an ultrasound probe until its picture matches a target view, using simulated ultrasound images made from real patient CT scans. Until now, the pieces of such a system (one that identifies organs, one that steers the probe, and one that scores how close the view is) were each tested in separate simulators, so nobody knew if they worked well together. The team snapped together 20 published methods and kept a swap only when it was clearly better, which ended up being just one: scoring with image similarity (SSIM). Even then, the probe started about 16 mm from the target and finished at 13.7 mm, recovering only 16% of the distance that a cheating 'oracle' (which knows the exact probe position, something only possible in simulation) covered by getting to within 1.5 mm.

The researchers built Fluidic Body, a system that lets a person steer a group of small robots by moving their hand, as if the robots were a blob of liquid attached to it. Opening your hand makes the group soft and runny so it can flow around obstacles, and closing your hand makes it firm and tight so it can push objects. In computer simulations, this worked better than an existing method that acts the same way for every job, and in a virtual-reality study, 17 people finished a combined dodge-and-push task faster and more reliably, while feeling less mental strain and more control over the robots. The team also showed it working with real robots in a demonstration with 88 participants, which is different from earlier systems because you change how the swarm behaves instead of telling it where to go.

Researchers built a system where an AI agent doesn't just run experiments, it also rewrites its own tools when the physical results show something isn't working. They tested this on a tricky problem: making smart glasses show an exact color that matches a target, which is hard because see-through glasses mix their display with the real world. Using an iPad, a pair of RayNeo X3 glasses, and a lab-grade color-measuring device, the AI updated the glasses' software so colors stayed on screen while being measured, then used the readings to correct itself. In one test, the color error dropped from 19.756 to 1.211 (a number where smaller means a closer match, and about 1 is roughly the smallest difference people can see), and all five target colors improved. Unlike earlier lab-automation AI that only changes settings inside fixed equipment, this one revises the hardware interface and software itself.

Companies often study how their work gets done by analyzing logs of what happened in their software, a technique called process mining, but the results usually show up as flat diagrams in separate tools. The researchers took a virtual and augmented reality platform called MM-AR, which lets people build and view business models in 2D and 3D, and added process mining to it by connecting a separate Python program built on a free tool called PM4Py, without changing the platform itself. They tested it with three different mining methods and four public datasets, and in all 16 test setups the models drawn inside the platform had exactly the same number of parts as the ones PM4Py made on its own. The connection added about 8 to 53 seconds per run, and that extra time depended on how complicated the discovered model was, not on how much data went in.

When you have a giant spreadsheet with hundreds of columns, a technique called UMAP squashes it down into a 2D picture where similar items land near each other, but on big datasets it can take so long that you can't explore the data interactively. The researchers built GPUMAP, a version that shows a rough picture almost immediately and keeps sharpening it as it works, while using a graphics card (GPU) to do the heavy math in parallel. They split UMAP into three basic building-block steps and rearranged them so results can stream in piece by piece, which lets people explore datasets with millions of points on an ordinary consumer GPU instead of waiting for a full run to finish. They also used the tool to study how these evolving pictures converge toward the final answer, and how the picture gets distorted when data arrives in a lopsided order (like all one category first). The abstract does not give specific speedup numbers, so the exact gains over earlier methods aren't stated here.

Robots that plan their moves ahead of time need a 'safe zone' they can always retreat to so they never get stuck in a dangerous situation, but for complicated robots, finding a perfect safe zone is nearly impossible to calculate, and the approximate versions lose their safety promise. The researchers came up with new kinds of safe zones that are easier to work with, and new planning rules that check safety at several points along the robot's planned path instead of only at the very end. They also added a backup plan: if the robot can't find a good next move, it can safely abort and stop instead of crashing into something. In tests on a 6-joint robot arm, their approach broke fewer safety rules than the best existing methods while tracking its target just as well and running just as fast, and they confirmed it works on a real robot arm too. The abstract doesn't give exact violation counts, so the size of the improvement is not specified here.

Researchers tested a new way to help people steer underwater robots (called ROVs) by letting them 'feel' hidden water currents through a soft, vibrating touchpad. In an actual in-water experiment, operators faced sideways currents they couldn't see, which made the job feel much more physically demanding and rushed. When the touchpad was added to signal the currents, those feelings of strain and time pressure dropped and people rated their own performance higher. The catch is that the touchpad also made the task feel mentally harder and more frustrating, yet operators still drove the robot significantly faster, a sign they trusted what they were feeling. The paper doesn't report exact figures in its abstract, so we can't say how large the speed gain was.

The researchers built a system called Fluidic Body that lets a person control a swarm of small robots by moving their hand, as if the robots were a blob of fluid attached to it. When you open your hand, the swarm turns soft and runny so it can flow around obstacles; when you close your hand, it becomes firm and tight so it can push objects. In simulations, this controller did better at both dodging obstacles and moving objects than an older method that acts the same way no matter the task. In a VR study with 17 people, participants finished a combined dodge-and-push task faster and more reliably, said it felt less mentally demanding, and felt more in control; the idea also worked with real robots in a demo with 88 participants.

The researchers built a system where an AI agent doesn't just run experiments but also rewrites its own tools when the real-world measurements tell it something isn't working. They tested it on a color-matching puzzle: smart glasses (RayNeo X3) show a color, and a lab-grade light-measuring instrument checks what actually reaches your eye. When they added a fix to the glasses app that keeps the color steady on screen while the instrument measures, plus a feedback loop that used the readings to adjust the color, the gap between the target color and the displayed color dropped from 19.756 to 1.211 (a number where under about 2 is hard for people to see), and all five test colors improved. It's different from earlier lab automation because the AI is allowed to change its own hardware controls and software, not just tweak settings inside a fixed setup, though it was only demonstrated on one equipment configuration.

Imagine one person remotely driving a robot into a tunnel or collapsed building where radio signals don't work, with a line of helper robots strung out behind it like a daisy chain, each one keeping the one ahead in sight so the operator never loses contact with base. The researchers built a control system where each helper robot follows two rules at once: a strict rule that guarantees the chain never breaks (each robot must stay inside the field of view of its neighbors), and a gentler rule that nudges it to stay well inside a smaller, safer zone so it doesn't just freeze when the leader pushes toward the edge. In simulations with both simple robots and software-simulated Crazyflie drones in tight and cluttered spaces, this approach kept the links much closer to fully connected than a baseline tuned to reach the goal in similar time, while the helper robots moved less. The paper does not report exact figures in its abstract, but it does include mathematical proofs that the connection guarantee holds and that each robot's calculations always have a valid answer.

Companies often study how their work gets done by analyzing logs of what happened in their computer systems, a technique called process mining, but the resulting diagrams usually sit in separate flat charts away from the tools used to design and edit business models. The researchers connected a virtual reality modeling platform called MM-AR to a separate Python program built on a free process mining tool called PM4Py, so users can automatically generate process diagrams (Petri nets and BPMN models) from event data files and see them inside the platform, without rewriting the platform itself. They tested three discovery methods on four public datasets (16 combinations), and the diagrams built inside the platform had exactly the same number of elements as the ones PM4Py made on its own every time. The connection added only about 8 to 53 seconds per run, and that delay depended on how complex the resulting diagram was, not on how big the dataset was.

The researchers built SEAM, a social app that works like a shared memory for a group of people who live or work near each other. Members post anything from their day, and the system figures out how those posts connect, learns facts about the group, and replies with relevant memories, including introducing people to others or topics they didn't know about. Members can also post special messages that act as instructions, so they can program the system to track routines or run games without writing code. They tested it with 46 people for two weeks of open use, then held a follow-up workshop with 14 of them, and found people shared their days, questioned the memory, and made it do new jobs. What makes it different from a normal group chat or social feed is that it doesn't just store posts, it actively connects them and pushes useful knowledge toward the people who need it.

The researchers ran the exact same swarm-control code on three very different groups of robots: small tabletop robots, flying drones, and human-sized mobile robots with arms. They used all three in live art performances and surveyed the audiences afterward. The code worked reliably on every platform, but each robot's body changed how the motion looked, stretching the apparent timing by more than three times and bending the shape of the paths. Audiences also reacted very differently depending on the robot type: how much they thought the robots had a purpose and how comfortable or threatened they felt did not rise and fall together, so a swarm that works perfectly in engineering terms can still come across as confusing or scary.

As AI agents start making real changes to engineering files and simulations (not just answering questions), the researchers built a rulebook that checks whether a job actually did what it was supposed to do. Their key idea is to keep three things separate that usually get blurred together: a tool saying 'success' versus the design truly changing, having all the evidence versus the evidence passing, and a result being old versus still being valid today. In tests with CAD and fluid-simulation software (OpenFOAM), the system caught cases that looked finished but weren't, such as a simulation with complete data that still failed its engineering check, and a finished job that had to be re-approved because its permission expired. They reported 0 out of 29 risky changes slipping through, but they stress this only shows their rules were followed in a fixed set of test cases, not that the system is proven safe in general.

Ultrasound videos are blurry and covered in grainy 'speckle' noise, and fixing them with AI normally requires pairs of bad and good images that almost never exist. The researchers built UltraDiff, which borrows an already-trained image-generating AI (a diffusion model) without changing it, and nudges its starting 'random seed' for each video frame until the generated picture matches the noisy ultrasound while following a noise model designed for speckle. Each frame also starts from the previous frame's answer, which keeps the video smooth. On heart ultrasound videos with simulated noise it beat the best competing method by 1.24 dB in image quality, and on real clinical heart scans it cut the average error in estimating how much blood the heart pumps (ejection fraction) from 7.31 to 6.37 points.

The researchers built DruMR, a system that lets you practice drumming in mixed reality without owning a real drum set. It pairs Aerodrums hardware (which tracks your drumsticks in the air) with the Meta Quest 3 headset, so you see virtual drums sitting in your actual room and play them by swinging sticks at nothing. Unlike earlier VR drumming games, which mostly focus on fun, DruMR is built to teach: it gives you numbers on how well you played, with plans to add AI-written tips and more detailed visual feedback. The paper describes the system as it stands today and lays out a planned study comparing learning on physical drums versus virtual ones, so there are no results yet showing whether it actually teaches better.

The researchers built TaoMate-HD, an AI system that creates a talking digital person in real time, producing both the video and the voice while new text keeps arriving. Instead of drawing every video frame in full detail right away, it first sketches a rough low-resolution version in two quick steps, then sharpens it to high quality in a final step. This made generation 1.6 times faster than going straight to high resolution, and running the steps in parallel made it about 1.9 times faster again. They also taught it to remember what it already said, so it stops repeating or cutting off its speech when the text changes, which cut speech errors by 11.18 percentage points, and it can keep going for an hour of video.

AI agents in factories and engineering offices are starting to do more than answer questions: they actually change real files and designs, like CAD models and physics simulations. The researchers built a rulebook-style framework with eight areas of responsibility (who is allowed to act, what was planned, what the tools did, what really changed, what evidence exists, and how to recover from mistakes) to make sure the agent's work can be trusted. The big idea is that 'the tool said it worked' is not the same as 'the right change actually happened,' and 'we ran all the checks' is not the same as 'the result is good.' In their tests, a fluid-flow simulation had every required check completed but still correctly got a FAIL verdict, an expired job had to be re-approved even though the computation finished, and the system caught missing checks and lost failure records, with 0 of 29 risky changes getting through in their test set (a measure of following the rules, not a promise of real-world safety).

Doctors often have two very different pictures of a kidney cancer patient: a microscope image of the tumor tissue and a CT scan of the whole kidney. The researchers built an AI that lets these two views 'talk' to each other, using a technique called cross-attention, so that 16 summary patterns from the tissue slides can look at up to 32 pieces of the CT scan and vice versa. Tested on 210 patients, it predicted who would die from their cancer better than AI models using only one image type or other ways of combining them, scoring 0.76 on a ranking accuracy scale where 0.5 is a coin flip and 1.0 is perfect. When tested on a separate group of 180 patients from another hospital network, the score dropped to 0.629, and that test had to run without the CT scans, so the result is promising but not yet proven.

Most studies of how people work with AI advice use students or volunteers doing simple tasks in a lab. These researchers instead surveyed 12 and interviewed 10 doctors and nurses who use AI decision-support tools in their real jobs, across two different medical groups. They found that clinicians use the AI differently as they get more experienced, lean on its predictions more when a case is tricky, talk over decisions with colleagues instead of just trusting the computer, and make different choices depending on how well the tool fits into their daily routine. As one clinician put it, it 'feels weird to just rely on AI.' The sample is small, so these are early patterns rather than hard numbers.

Robots that learn from human demonstrations often build an internal picture of the world, and then use that same picture to decide what to do. The problem is that most of what's in the picture (like the color of the wall or a moving shadow) has nothing to do with the right action, but the robot can accidentally mix those distractions into its decisions. The researchers built CWAM (Causal WAM), which adds a filter to an existing robot model so its action decisions can only draw on the few pieces of information that actually cause the demonstrated actions, while the rest of the model keeps predicting the whole scene as before. They mathematically proved this filter works under a sparsity constraint, even when the important and unimportant parts of the scene are linked together, and showed on synthetic data and real robots that it improved closed-loop success (the paper's abstract does not state specific numbers).

Doctors often guide needles through the skin to reach tumors or take tissue samples, and robots can help, but a robot's built-in math about its own shape is never perfectly right, so it ends up missing its target by a few millimeters. The researchers built a method to fix the robot's math by measuring where its tip actually goes and adjusting 19 numbers that describe its body, such as arm lengths and joint angles. The key twist is that they forced each number to stay within a realistic range, so the computer can't 'cheat' by picking weird values that fit the test data but don't match a real machine. In simulation this cut the robot's average error from 3.4 mm to 0.69 mm, and on a real tabletop robot it reached under 1 mm of error (0.865 mm on a moving path and 0.610 mm on a grid of test points).

Researchers built a steering brain for small self-driving boats that have to share narrow city canals, like those in Amsterdam, with other boats whose plans they can't know. Instead of just planning its own path, the boat also guesses where the other boats will go, so it can see how everyone's moves affect each other, kind of like predicting how drivers will react in a tight parking lot. It also follows boating traffic rules, which are hard to turn into math, using a trial-and-error method that tries out huge numbers of possible paths and picks the best one. In 780 randomized computer tests on real Amsterdam canal maps, with two to four boats, it reached every goal with no crashes and no standoffs where boats get stuck, beating both an older planner built for the same job and a version of itself that ignored other boats' reactions. It also worked on two small real boats outdoors, running on the boats themselves and updating 10 times per second, safely handling head-on and crossing meetings without breaking any rules.

Doctors can look at kidney cancer in two very different ways: microscope slides of the tumor tissue, and CT scans of the whole kidney. The researchers built an AI system that lets these two kinds of images 'talk' to each other. Tiny summaries of the slide (16 of them) and up to 32 chunks of the CT scan pass information back and forth, using existing pre-trained AI models without retraining them. In 210 patients, it predicted who would die of kidney cancer better than systems using just one image type or simpler ways of combining both (a score of 0.76, where 0.5 is a coin flip and 1.0 is perfect). However, when tested on a separate group of 180 patients without the CT scans, the score dropped to 0.63, and the authors note the model sometimes latched onto quirks of how images were taken rather than real disease signs.

Some new robots use an internal 'mental picture' of the world to decide what to do, and these researchers asked: if you mess with that picture, when does the robot actually act wrong? They found that changing the picture a lot doesn't reliably make the robot fail, because what matters is whether the change reaches the part of the robot's brain that picks actions. They built a quick test called Tail-AV to find the weak spots, then a method called PASA-KV that aims attacks at those spots, and it caused strong failures in multiple robot systems, including a real physical robot. The abstract doesn't give specific numbers, but it reports that different robot systems varied a lot in how well they resisted.

Researchers built an AI system called SDFA-Net that outlines thyroid nodules (small lumps in the neck) on ultrasound images, which are notoriously grainy and have fuzzy edges. Earlier AI tools struggled to do two things at once: understand the big picture of what's in the image and trace the exact border of an oddly shaped lump. SDFA-Net splits those jobs apart, using one part to filter out background clutter and spot the overall context, and another to line up fine edge details so the final outline is sharp. They tested it on three public thyroid ultrasound collections (TN3K, TUCC, and DDTI) and report it beat the current best methods, though the abstract doesn't give specific accuracy numbers.

Most studies on how people work with AI advice use students or everyday volunteers doing simple, one-time tasks. These researchers instead went to real doctors and nurses who use AI decision-support tools in their daily jobs, surveying 12 of them and interviewing 10 in depth, across two different medical settings. They found that clinicians use the AI differently as they get more experienced with it, lean on its predictions more for tricky cases, often talk over decisions with coworkers instead of just trusting the machine, and rely on it more or less depending on how smoothly it fits into their workflow. It's a small study, so it's a set of real-world clues rather than hard numbers, but it shows that trust in AI depends on the whole work environment, not just how accurate the software is.

Robots can learn a new task by watching a few example demonstrations right before they try it, but long videos of those examples take up so much of the robot's 'memory' that only a handful fit. The researchers built a system called JEDI that squeezes each demonstration into a small set of compact summaries, and they trained it with one clever goal: the summary has to be good enough to predict what the robot should see at the next stage of a similar task. This forces the summary to keep the details that actually matter for doing the task, instead of just copying the robot's movements. On the LIBERO robot benchmark and with real robots, this let the system handle many demonstrations at once and follow them better than methods that compress based on actions alone. The abstract doesn't give specific numbers, so the exact size of the improvement isn't stated here.

This is a policy paper, not a lab experiment, so there are no new robots or test results to report. A group of leading robotics researchers argues that the U.S. should treat robots as their own supply chain, with their own weak spots, instead of an add-on to artificial intelligence spending. They point to four gaps: no good way to check whether parts of unknown origin are safe and genuine, too little money for robot hardware compared with software, too few facilities where researchers can test robots at large scale, and too few trained people to build and maintain it all. They say fixing these gaps will take about ten years of steady federal funding, not a single budget cycle, and the abstract gives no dollar figures.

This paper is a review, not a new gadget: the authors explain how networks of tiny oscillators, things that tick back and forth like pendulums, can do useful computing just by falling into step with each other. They show that the way these oscillators sync up follows a physics recipe called the Ising model, which lets the pattern of who syncs with whom act as the answer to a problem. They lay out three jobs this can do: hunting for solutions to very hard scheduling-style puzzles, storing and recalling information like a memory, and matching keys to queries the way the 'attention' step in modern AI does. The big difference from regular computers is that the answer emerges naturally from the physics of the system instead of being calculated step by step, which could use far less energy. The paper gives no new speed or energy numbers, since it surveys the ideas rather than testing a specific machine.

Devices that connect solar panels and batteries to the power grid use electronic circuits called inverters, and these need filters (coils and capacitors) to clean up their electricity. The researchers found that the controller's settings put a hard limit on how small and cheap those filters can be: past a certain point, the control system fights itself and becomes unstable, and the filter ends up with a natural 'ringing' speed it can't safely go beyond (about one-third of how fast the controller samples). By adding a simple adjustment to one part of the control signal, they fixed the conflict without changing the rest of the design. On a 3-kilovolt-ampere test unit, this let them shrink the filter's size-determining coil-times-capacitor value by 83.3%, and in a separate test the same small filter ran stably at 2.68 times the response speed that was possible without the adjustment.

Doctors can look at kidney cancer in two ways: tiny tissue slides under a microscope and 3D X-ray-style CT scans. The researchers built an AI system that lets these two kinds of images 'talk' to each other, boiling each slide down to 16 key patterns and matching them against up to 32 chunks of the CT scan around the kidney. Tested on 210 patients, it predicted who would die from their cancer better than AI using either image type alone or other ways of combining them, scoring 0.76 on a standard accuracy measure (0.5 is a coin flip, 1.0 is perfect). When they tried it on a separate group of 180 patients without CT scans, accuracy dropped to 0.63, showing it needs more testing before real-world use.

Some new robots use an AI 'world model' that first imagines what it sees and then decides how to move, and the researchers wanted to know how easily that imagining step can be tricked. They found that messing with the robot's internal picture the most doesn't always make it fail the most; what matters is whether the tampered information flows into the part that picks actions, much like a typo in a recipe's ingredient list ruins dinner while a typo in the page footer doesn't. Using this idea, they built a tool called PASA-KV that first finds the 'action-facing' pathways, using a quick test called Tail-AV, and then trains a single attack that works across many tasks. It caused strong failures in multiple robot systems and on a real physical robot, and some systems turned out to be far more resistant than others. The abstract doesn't give specific success-rate numbers, so the exact size of the effect isn't stated here.

Researchers built an AI system called SDFA-Net that outlines thyroid nodules (lumps in the neck gland) in ultrasound images, which are notoriously grainy and have fuzzy edges. Earlier methods struggled because they had to understand the big picture (is this a nodule?) and trace the exact edge at the same time. SDFA-Net splits those jobs: one part learns what a nodule looks like overall, while another lines up fine details at several zoom levels to get the outline precise down to a fraction of a pixel. The team says it beat other leading methods on three public thyroid ultrasound datasets (TN3K, TUCC, and DDTI), but the abstract gives no specific scores, so the size of the improvement isn't clear from the summary alone.

Most studies of how people work with AI helpers test students or random volunteers on simple, one-time tasks. These researchers instead asked real doctors and nurses who use computer decision-support tools every day at their jobs, through an online survey of 12 clinicians and in-depth interviews with 10 of them across two different medical groups. They found that people use the AI differently as they gain experience, lean on its predictions more for tricky cases, often talk through decisions with coworkers instead of deciding alone, and are heavily influenced by how well the tool fits into their normal routine. The study is small, so it shows patterns rather than proving them, but it captures how this actually works in real hospitals instead of in a lab.

Robots can learn a new task by watching a few example demonstrations, but each demonstration is a long stream of video, sensor readings, and movements, so only a handful fit in the robot's 'working memory' at once. The researchers built JEDI, a system that squeezes each demonstration into a small set of compact summaries, and trained those summaries to do one specific job: predict what the scene should look like at the next key moment of a new task attempt. Because the summaries must help foresee the future, they keep the details that matter for actually doing the task rather than just copying actions. In tests on the LIBERO robot benchmark and on real robots, this let the robot use many more demonstrations at once and gave better success rates and closer demonstration-following than compressing based on actions alone. The abstract doesn't give exact numbers, so the size of the gains isn't specified here. The system can also learn from videos of human hands, by converting hand motion into keypoints a robot can use.

This is a policy paper, not a lab experiment, so the researchers didn't build a gadget or report test numbers. Instead, a group of leading robotics experts mapped out what it would take for the U.S. to make sure robots can be built from parts and software it can trust. They argue that robots have their own 'supply chain' (the chain of parts, materials, software, and people needed to make them) and that it has weak spots that AI funding alone won't fix. They point to four main problems: no good ways to check parts when no one is sure where they came from, too little money for robot hardware research compared to software, not enough big test facilities, and too few trained workers. They say fixing this needs steady government funding over roughly ten years, not a one-year budget boost.

This paper is a review, not a new gadget: the authors explain how networks of tiny electronic or physical 'oscillators' (things that tick back and forth, like pendulums or heartbeats) can do computing just by falling into step with each other. When oscillators nudge their neighbors, they settle into patterns of who's in sync with whom, and those patterns can be read as answers. The authors show this one idea can handle three jobs: solving very hard puzzle-like problems (the kind where checking every option would take forever), acting as a memory that recalls a stored pattern from a messy or partial clue, and doing the 'attention' step that modern AI chatbots rely on. The twist compared with regular computers is that the physics does the work directly instead of a processor crunching numbers step by step, which could use far less energy. The paper doesn't report new benchmark numbers; its contribution is tying these three tasks together under one mathematical framework.

Solar panels, batteries, and other clean power sources use devices called inverters, and some of them must behave like a small power plant that helps keep the electric grid steady. These inverters include a filter made of a coil and a capacitor that smooths out electrical noise, and smaller filters are cheaper but make the control system more likely to start shaking out of control. The researchers worked out exactly how far you can push this trade-off, finding that the filter's natural 'ringing' frequency can't safely go above about one-third of the controller's sampling speed, and then added a simple tweak to the control math that widens the stable range without changing the rest of the design. In a 3-kVA lab prototype (about the size of a large appliance), this let them shrink the filter's size-and-cost measure by 83.3%, and a separate test ran stably at 2.68 times the speed that would otherwise have been possible.

Doctors use two very different pictures to understand kidney cancer: microscope images of tissue slides and 3D CT scans of the body. The researchers built an AI system that lets these two kinds of images 'talk' to each other, so the tissue slide highlights what to look for in the scan and the scan points back to important parts of the slide. They tested it on 210 patients to predict who would survive longer, and it scored 0.76 on a standard ranking accuracy measure (where 0.5 is a coin flip and 1.0 is perfect), beating simpler approaches that used only one image type or combined them less cleverly. When tested on a separate group of 180 patients from another hospital database without CT scans, it dropped to 0.63, showing the approach is promising but not yet proven.

Newer robot brains, called world action models, work by first building an internal picture of what they see and then using that picture to decide what to do. The researchers found that you can't tell how easy it is to trick one of these robots just by seeing how much you can scramble its internal picture; what matters is whether the scrambled part feeds into the step where the robot picks its actions. Inside the model, some pieces act like a pointer that decides where the robot looks and others act like the content it reads, and messing with the right ones causes far more damage than messing with others, even when the changes look smaller. They built a quick test called Tail-AV to find the most dangerous spots, then used it in an attack called PASA-KV, which they showed breaks several robot systems in simulation and on a real robot, while also revealing that some systems resist these attacks much better than others. This paper doesn't report exact attack success numbers in its abstract, so the key result is the pattern, not a single figure.

Researchers built an AI system called SDFA-Net that outlines thyroid nodules (lumps in the neck) in ultrasound images, which are notoriously grainy and have fuzzy edges. Earlier methods struggled to do two things at once: understand the big picture (is this a nodule or just background?) and trace its exact edge. SDFA-Net splits these jobs apart, using one part to understand the overall image, another to ignore distracting background, and a third to line up fine edge details with pixel-level precision. The team says it beat the best existing methods on three public thyroid ultrasound datasets (TN3K, TUCC, and DDTI), especially on oddly shaped nodules, but the abstract doesn't give the specific accuracy numbers.

Most studies of how people work with AI recommendations use students or random volunteers doing simple, one-off tasks. These researchers instead surveyed 12 clinicians and interviewed 10 who already use decision-support software in real hospitals and clinics, in two different medical specialties. They found that doctors don't blindly follow the AI: they trust it differently as they get more experience, lean on it more in tricky cases, talk over decisions with colleagues, and are strongly affected by how well the tool fits into their daily routine. In short, relying on AI turns out to be less about the AI's accuracy and more about the people, the workplace, and the tool's design around it.

Robots can learn a new task by watching a few examples at the moment they're asked to do it, but video-and-movement recordings are so long that only a handful fit in the robot's 'working memory.' The researchers built JEDI, which squeezes each demonstration into a small set of compact summaries, and trained those summaries to answer one question: given this demo, what should the robot's camera see at the next key step of the task? Because the summaries are forced to predict what comes next, they keep the details that actually matter for doing the task, rather than just copying the movements. In tests on a standard robot benchmark called LIBERO and on real robots, this let the system use many demonstrations at once and gave better success rates and better demo-following than compressing based on actions alone (the abstract doesn't give exact figures), and it can even learn from videos of a human hand.

This is a policy paper, not a lab experiment, so there is no new robot, test, or set of numbers behind it. A group of leading robotics researchers argues that robots depend on their own supply chain of parts, chips, software, test facilities, and trained people, and that a weak link anywhere can cause failures, just like with cars or phones. They say the biggest weak spots today are: no good way to check and certify parts when you can't be sure where they came from, too little funding for basic hardware research compared to software, too few places to test robots at large scale, and not enough trained workers. They conclude that robotics should get its own long-term government funding plan, lasting about ten years, instead of being treated as a side benefit of money spent on artificial intelligence.

This paper is a review, not a new device or experiment, so it has no benchmark numbers to report. The authors explain how networks of tiny oscillators (things that swing back and forth in a steady rhythm, like pendulums or electrical circuits) can do computing just by syncing up with each other. When the oscillators influence their neighbors, the way they fall into step encodes an answer, and the authors show this can be used for three jobs: solving hard scheduling-style puzzles, storing and recalling memories as patterns of timing, and doing the 'attention' step that powers modern AI chatbots. What makes it different from regular computers is that the physics of the system does the calculating directly, which could use far less energy than running the same math in digital chips.

Devices called grid-forming inverters turn DC power from batteries or solar panels into the steady AC electricity that powers a grid, and they rely on a filter made of coils and capacitors to smooth the output. The researchers found that the control settings used to keep these inverters stable put a hard cap on how small and cheap that filter can be, because the controller's built-in delay starts fighting its own stabilizing tricks at higher frequencies. They fixed this with a simple reshaping of one part of the control signal, without adding extra hardware or changing the rest of the design. On a 3-kVA prototype, this let them shrink the filter's size-determining coil-times-capacitor product by 83.3% while keeping the same performance, and the same filter ran stably with a control response 2.68 times faster than before.

Doctors can look at kidney cancer in two ways: under a microscope at tissue samples (slides) and on CT scans of the whole kidney. The researchers built an AI system that lets these two views 'talk' to each other, using a technique called cross-attention to link small, representative patterns from the slides with chunks of the CT scan, all built on top of pre-trained AI models that were not retrained. On 210 patients, it predicted survival better than models using only one type of image or other ways of combining them, scoring 0.76 on a standard accuracy measure (where 0.5 is a coin flip and 1.0 is perfect). However, when tested on a separate group of 180 patients from another hospital network with the CT scans left out, the score dropped to 0.63, and the team also found that the AI sometimes keyed in on scanner quirks rather than actual disease.

Researchers built an AI system called SDFA-Net that outlines thyroid nodules (lumps in the neck) in ultrasound images, which are notoriously fuzzy, grainy, and hard to read. Older methods struggle because they have to balance two jobs at once: understanding the big picture (what's a nodule versus normal tissue) and tracing the exact edge of an oddly shaped lump. SDFA-Net splits those jobs apart: one part handles the big picture, a second part filters out distracting background noise, and a third lines up fine-detail information with the big picture so the outlines come out sharper. The team says it beat other leading methods on three public thyroid ultrasound datasets (TN3K, TUCC, and DDTI), but the abstract doesn't report specific accuracy numbers, so the size of the improvement isn't clear yet.

When you wear a mixed reality headset, you tend to get lost in your own digital world and ignore the people in the room with you. The researchers built a system called Atmos Messages that lets people leave short-lived messages floating in physical space, created with hand gestures, voice (turned into text), or ready-made phrases, and shown on a public floor map that anyone nearby can see. Fifteen people made 236 messages across two sessions (48 of them spoken), and they described the experience as playful and good for staying aware of others. People mostly gathered around the shared display, which was also where they put on their headsets, so that spot became the social hub of the room.

Doctors can look at a kidney cancer patient in two ways: a microscope image of the tumor tissue, and a CT scan of the whole kidney. The researchers built an AI that lets these two views 'talk' to each other, using 16 summary patterns from the tissue slides and up to 32 chunks of the CT scan, all processed by pre-trained AI models that were not retrained. On 210 patients from a public cancer database, it predicted survival better than models using only one type of image or simpler ways of combining them (a score of 0.76, where 0.5 is a coin flip and 1.0 is perfect). It did worse on a second group of 180 patients (0.629), but that test had no CT scans available, and the team also showed which image regions drove each prediction, which exposed some scanner-related quirks the AI was picking up on.

Researchers built an AI system called SDFA-Net that outlines thyroid nodules (small lumps in the neck) on ultrasound images, which are notoriously grainy and have fuzzy edges. Earlier programs struggled to understand the big picture of the image while also tracing exact borders, so the team split those jobs: one part figures out what is nodule versus background, another part handles the fine edge details, and a third part lines the two up with extreme precision. They tested it on three public thyroid ultrasound collections (TN3K, TUCC, and DDTI) and report that it beat the best existing methods, though the abstract does not give exact score numbers.

When people wear mixed reality headsets (the kind that blend digital images into the real room), they tend to get lost in their own world and ignore the people around them. The researchers built a prototype called Atmos Messages, where people use hand gestures, their voice, or quick preset phrases to leave short, disappearing messages pinned to spots in a real room, with a public floor-plan screen showing what's happening so people without headsets can follow along. Fifteen participants created 236 messages over two sessions, 48 of them spoken aloud, and described the experience as playful and socially aware, often tying their messages to the building itself. One catch: people clustered around the public display, which was also where they put on their headsets, so the setup of the space shaped how people behaved.

Researchers built an AI system called SDFA-Net that outlines thyroid nodules (lumps in the neck gland) in ultrasound images, a hard job because the pictures are grainy and the edges of nodules are often blurry. Earlier methods struggled to do two things at once: understand the big picture of what a nodule looks like and trace its exact border. SDFA-Net splits these into separate learning tasks, using one part to ignore distracting background and another to line up fine details across different image resolutions down to a fraction of a pixel. The team reports it beat other leading methods on three public thyroid ultrasound datasets (TN3K, TUCC, and DDTI), especially on oddly shaped nodules, though the abstract does not give the specific accuracy numbers.

Robots driven by AI controllers can be fast and clever, but nobody can prove those controllers won't crash the robot. The usual fix is a safety backup: a simple, provably safe controller that takes over when things look risky. The catch is that the backup is usually checked against one fixed, worst-case safe zone, so it steps in far too early and wastes the AI's abilities. These researchers built a system that works out a bigger safe zone on the fly based on what the robot is actually doing, and can also pick between several backup controllers depending on the situation. They tested it on a path-following robot in simulation and on real hardware, where it stayed safe even when faults were deliberately injected, successfully reined in an AI controller trained by copying human demonstrations, and made its safety decisions in just 0.028 milliseconds on average (4.13 ms at worst), using less than 10% of the robot's control cycle.

Imagine a big truck trying to get through a street full of boxes, barrels, and other junk that can be shoved aside. The researchers built a planning system called PushAround that lets a team of robots figure out which objects to push, in which direction, and how hard, so a wide path opens up for the big vehicle. Older methods treated obstacles like simple game pieces that slide anywhere, ignoring how heavy things are, how big the robots are, and how pushing really works, so their plans often wouldn't work in the real world. PushAround checks its ideas with quick physics simulations, and it kept working with up to four robots, in more crowded clutter, and even when the simulated objects weighed or slid differently than the robots expected (the abstract doesn't give exact success numbers).

Most drone research for inspecting industrial pipes assumes the pipes sit perfectly still, but in real factories they shake and vibrate. The researchers built a system called VisGeo-PipeTrack that lets a drone follow a moving pipe by spotting labels on it with a camera (using a common object-detection AI called YOLOv5) and using simple geometry to work out exactly where the pipe is. They also created a smarter steering controller that constantly re-learns how the drone behaves and adjusts its own settings on the fly, instead of using fixed settings like a standard controller. In simulation it settled on target in 3.26 seconds with 3.52% average error, beating four other controller types, and on a real Tello drone it cut tracking error by 55.52%, 26.72%, and 26.52% across three test dimensions compared with a standard controller.

A researcher built her own 16-sensor brain-wave headset circuit board and used it to record people's brain activity while they were focused versus distracted. She then trained an AI model called EEGBiFormer that can tell, in under 100 milliseconds, whether someone is paying attention, getting about 91% of short brain-signal snippets right and 88% of full recording sessions right. Instead of guessing which sounds help people concentrate, she used the AI to rank sounds by how strongly they put the brain in a focused state, then tested the top-ranked 'sound recipes' on 37 people. The group using the brain-guided sounds scored 20% higher on attention tests than when they worked in silence, which is different from older study-aid tools that play the same sounds for everyone without checking the brain.

The researchers built a smarter controller for a camera-style pointing platform (a gimbal) that has to keep aiming at a target even though friction, motor wobble, and delays keep pushing it off course. Their system learns to guess how big those pushes will be and subtracts the likely amount, and it also measures how unsure it is so it can hold back some motor power in reserve instead of maxing out. On a real two-axis gimbal run 7 times per setup, it aimed within about 3.94 milliradians (roughly 0.2 degrees) of error and never once hit its motor power limits. Unlike older approaches that either ignore these disturbances or add heavy extra math, this one adjusts its power reserve on the fly without making the control calculations any bigger.

The researchers built MATE-BT, a software system that lets a team of different kinds of robots keep working on a shared mission even when something goes wrong, like a robot breaking down or new targets appearing. One robot acts as the team leader and hands out jobs, but if the leader fails, another robot that is able to lead takes over, so the mission doesn't stop. Instead of redoing the whole plan every time something changes, the system only updates the part that is affected, which kept its reaction time to about 130 milliseconds (roughly one eighth of a second) even with 30 robots and 120 targets. It ran entirely on small, cheap onboard computers (Jetson Orin Nano and Raspberry Pi 5) in both simulations and real-robot tests, so it didn't need a central computer or outside connection.

The researchers built a system called Present Drawing, where you put on a VR headset and watch a cartoon-like avatar draw, while a hidden pen-plotting machine on the table draws the exact same picture on real paper at the same time. Because the machine's moving parts are hidden from view, it looks like the avatar is actually making the marks you can later hold in your hands. They described four things an event organizer can change (when it happens, where, who or what controls the avatar, and what the avatar looks like) and made five example setups, such as live drawing, replays, mascot characters, and drawing across multiple locations. They tested one setup, a replayed autograph session, and found that the basic experience works and that people can feel the avatar is the one doing the drawing, though the paper does not report a headline number and the test was only an initial one. What's different from earlier work is that the drawing doesn't stay inside a screen; it leaves a real, physical drawing behind.

Researchers built a single 'brain' for swarms of flying robots that can handle six different kinds of missions without being retrained each time the job changes. Instead of writing separate software for each task, they broke swarm behavior into basic reusable rules, like staying close together, avoiding crashes, and heading toward a goal, and then blended those rules together using a lightweight switching system. The same controller worked with 10 to 100 drones, on two different types of hardware, and in real cluttered indoor spaces and GPS-free woodlands the drones had never seen before. In large simulations it succeeded 96 to 100 percent of the time, with each drone making its decisions in just 1 to 10 milliseconds.

Researchers taught a robot to slide a bracelet onto a hand, which is surprisingly hard because the opening is tight and fingers can snag the edge. Instead of tracking every wiggle of the floppy bracelet, they gave the robot's learning system just the key geometry: where the hand sits relative to the bracelet's opening. They trained it in two ways, first with a step-by-step curriculum (line up roughly, then insert, then settle into place) and second with a "gate" that gives running feedback on how far each finger has gone through and discourages pushing in too early. In tests, the full method succeeded 84.7% of the time on the floppy bracelet in simulation, the gate gave the biggest boost, and a real robot put the bracelet on a mannequin hand in 15 of 20 tries.

Robots are often trained inside computer simulations, but they tend to stumble when moved into the messy real world because the simulation never matches reality perfectly. The researchers built a new training method called Soft MellowMax Actor-Critic (SMM-AC), which gently discourages the robot's AI from becoming overconfident in any single way of doing a task, so it learns flexible habits instead of brittle ones. On standard computer benchmarks it performed about as well as popular methods like Soft Actor-Critic, but on real robots it earned higher scores and kept working better when sensor readings were noisy, the surroundings changed, or the robot's physics differed from what it practiced on. The abstract doesn't give exact percentage gains, but the key difference from earlier work is that most real-world robot teams still default to a less cautious method called PPO, and this paper makes a clear practical case that the more careful, regularised approach transfers better.

The researchers built a system called WarpWeaver that lets a team of robots plan their own paths at the same time without a central computer telling them what to do. The robots negotiate with each other over who gets to use which bit of shared space, a bit like bidding on rent, and keep improving their plans until they settle on a deal that is provably close to the best possible. In simulations, the robots finished their jobs up to 22% faster than robots planned by a big central computer working in advance, and up to 37% faster than other robots that also plan on their own in real time. They also tested it on six real robots that did all their thinking onboard.

Researchers built VTRL-Med, a system that can sort huge piles of medical images (like X-rays and scans) into meaningful groups without anyone first labeling them. It starts with Segment Anything Model, an AI that's good at spotting the outlines and regions of objects, then makes educated guesses about which images belong together and keeps only the guesses it's most sure about. It also adds a second check that looks at an image's overall shape, such as whether a structure is connected or has holes in it, to settle cases where images look confusingly similar. Tested on 13 medical image collections, it beat earlier methods by an average of 4.48% in accuracy, and the shape-checking step alone added another 1.3 to 4.3% on the three datasets where it was studied.

Researchers built GigaBench, the first test suite for checking how well 'learnable representations' (AI models that learn to store an image inside their own settings, rather than as a grid of pixels) can shrink and sharpen gigapixel-sized pictures, which are images with billions of pixels, like huge satellite photos or museum scans. They collected images from many fields, including real photos and computer-rendered scenes, and reworked several different kinds of these methods so they could run on ordinary consumer computers instead of giant servers. They then compared the methods on picture quality, file size, and how long they take to compress and reconstruct an image, and found consistent patterns across methods. The abstract does not give specific headline numbers, but the key difference from earlier work is that these methods had mostly been tested on small images, not gigapixel ones.

Researchers built a single control system for swarms of flying robots that can handle six different types of missions without being retrained each time. Instead of writing separate programs for each job, they described basic swarm behaviors (like staying together, avoiding obstacles, or spreading out) as 'energy' scores, where the robots naturally settle into whatever arrangement scores best, and then mixed these behaviors together like building blocks using a simple switching mechanism. The same controller worked with swarms of 10 to 100 drones, on two different types of hardware, and in real tests indoors with clutter and in a GPS-free forest. In large simulations it succeeded 96% to 100% of the time, with each drone making decisions in just 1 to 10 milliseconds.

Today, you can tell websites not to track or sell your data, but those controls were designed for humans clicking around, not AI agents that browse, shop, and book things on your behalf. The researchers built a catalog (a 'taxonomy') of the kinds of privacy preferences people should be able to set for AI agents, drawing on privacy laws, studies of existing privacy tools, and a check of 30 leading AI assistants and agent platforms. They then built eight free, open-source demo apps that mimic real agent uses, showing how those privacy preferences can be built directly into the communication rules that agents use to talk to tools and to each other (the Model Context Protocol and Agent2Agent protocol, which the abstract calls the 'Model Control Protocol'). The key difference from earlier work is that privacy choices become something an agent system can actually enforce, rather than a pop-up a human might click.

The researchers wanted to know whether a robot's "brain" could learn useful basics before ever seeing a real robot. They built three computer programs that automatically generate endless fake practice data based on the math behind how machines are controlled, then trained an AI model (a Transformer) only on that fake data. When tested on real robot tasks it had never seen, the model could still predict what actions a robot would take next, because it picked up on patterns from the examples it was shown on the spot. Their control-focused fake data worked noticeably better than generic fake data, and a model trained on real robot data beat it only on the exact datasets it was trained on. The paper doesn't give a headline number in its abstract, so the key result is the pattern: fake math-based data gave real, if modest, transfer to physical robots.

The researchers built a system called WarpWeaver that lets a team of robots work out how to move around together without a boss computer telling them what to do. Each robot builds its own set of possible paths, and the robots then 'negotiate' by putting a kind of price on the shared space between them, which nudges each robot toward choices that work well for the whole group. Before this, planners that found really good team solutions needed a central computer and lots of calculation time beforehand, while the ones that ran live on the robots mostly just avoided crashes without aiming for the best overall result. In simulations, WarpWeaver cut total travel time by up to 22% compared to the central offline planners and by up to 37% compared to a live decentralized method, and in tests with six real robots, each doing its own planning onboard, it worked in practice.

Gigapixel images (pictures with a billion or more pixels, like detailed maps, scans of artwork, or microscope slides) are huge and hard to store. Researchers built GigaBench, the first standardized test for 'learnable representations': tiny neural networks that memorize an image and can recreate it later, kind of like a super-smart zip file. They adapted several different types of these methods so they could handle gigapixel-sized images on regular consumer computers, then tested them on real, photographed, and computer-generated images for shrinking files (compression) and sharpening blurry images (super-resolution). The abstract doesn't give specific scores, but they compared the methods on image quality, file size, and speed, and found consistent patterns across them that point to which approaches are most promising for future work.

Researchers built a single control system for drone swarms that can switch between very different jobs, like flying in formation, exploring, or navigating clutter, without being reprogrammed or retrained. Instead of writing separate rules for every mission, they broke swarm behavior into simple reusable building blocks (such as 'stay close to neighbors' or 'avoid obstacles') and described each as an energy, where the swarm naturally settles into the lowest-energy, best-behaved arrangement. Each drone learns these behaviors on its own, then a lightweight 'gating' step blends them together for whatever mission is needed. In tests, the same controller handled six mission types with 10 to 100 drones on two different drone platforms, succeeded 96-100% of the time in large simulations, made decisions in just 1-10 milliseconds per drone, and worked on real drones indoors in clutter and outdoors in woodland without GPS.

Brain scans called diffusion MRI track how water moves through tissue, but getting a full picture takes so many measurements that scanners can't practically collect them all. The researchers trained a small neural network to act like a smooth, continuous 'map' of the whole signal, so it can fill in the measurements that were never taken and sharpen the images. They tested it on 10 people from the Human Connectome Project and 26 Parkinson's patients scanned with a very different protocol, and it rebuilt the data accurately while using much less memory than storing the raw scans. They also pre-trained the network on an average 'template' brain, which lets it adapt to each new person faster, even when the scan settings are quite different.

Today, tools like 'Do Not Track' and cookie-consent banners let you tell websites what you want done with your personal information, but they were built for humans clicking around, not for AI agents that browse, shop, and book things on your behalf. The researchers built a list (a taxonomy) of the kinds of privacy preferences people should be able to set for these AI agents, drawing on privacy laws, studies of existing privacy tools, and a check of 30 leading AI assistants and agent platforms. To show it could actually work, they built eight open-source prototypes that mimic real agent apps and plug privacy controls directly into the communication rules agents use to talk to tools and to each other (the Model Context Protocol and Agent2Agent protocol). The paper doesn't report a single headline number; its contribution is the first structured blueprint for making privacy preferences something agents can follow automatically instead of an afterthought.

Collecting data from real robots is slow and expensive, so the researchers asked whether an AI could learn useful 'robot instincts' from computer-generated math puzzles that have nothing to do with robots. They built three automatic generators that create fake control problems (think of simulated systems that need steering, with no arms, wheels, or bodies involved) and used them to train a Transformer, the same kind of AI behind chatbots, to predict what a robot should do next. Without ever seeing a real robot, this model made better-than-chance predictions on real robot tasks it had never encountered, by picking up patterns from the examples it was shown at the moment of the task. Their math-based training data also beat more generic synthetic data, though a model trained on real robot data still won, but only on the specific datasets it had been trained on. The abstract does not report specific numeric scores.

The researchers built WarpWeaver, a system that lets a team of robots plan their own paths at the same time without a central computer telling them what to do. Each robot works out possible routes on its own, then the robots 'negotiate' over who gets to use which shared space, almost like bidding for parking spots, until they settle on a plan that is provably close to the best one the whole team could find. Earlier approaches either needed a central computer and lots of planning time ahead of the mission, or they let robots avoid crashes quickly but didn't try to make the whole team efficient. In simulations, WarpWeaver cut total travel time by up to 22% compared to centralized planners and up to 37% compared to other real-time decentralized methods, and it was tested on six real robots that did all their planning onboard.

Gigapixel images, the kind with billions of pixels used for things like mapping, art scanning, and microscope slides, are enormous and hard to store or zoom into. The researchers built GigaBench, the first test suite that checks how well 'learnable representations' (small neural networks trained to memorize an image so the network itself becomes the file) handle these giant pictures. They took a mix of methods, from fully neural ones to hybrid and more traditional-style ones, and reworked them so they run on ordinary consumer computers instead of supercomputers. They then compared them on image quality, file size, and speed for squeezing images down and sharpening low-resolution ones. The abstract doesn't give headline numbers, but they report consistent patterns across methods and practical advice for choosing between them.

Researchers built one control system for groups of flying robots that can handle six different kinds of missions without being retrained or reprogrammed for each one. Instead of writing a separate program per task, they broke swarm behavior into basic building-block rules (like 'stay spread out' or 'move toward a goal') and taught the robots to blend these rules together on the fly, like mixing ingredients to make different recipes. The same controller worked with 10 to 100 drones, on two different types of hardware, and in real tests indoors with obstacles and in a woodland area with no GPS. In large simulations it succeeded 96 to 100 percent of the time, with each drone making decisions in just 1 to 10 milliseconds.

Brain scans called diffusion MRI track how water moves through tissue, but they produce huge files and can't practically capture every measurement angle because scans would take too long. The researchers built a neural network that learns the whole scan as one smooth mathematical function, so it can fill in measurements that were never taken and sharpen the image, while storing the data in far less memory than the raw scan images. They also gave the network a head start by pretraining it on an average 'template' brain, which let it learn each new person's scan faster, and it worked well on scans from 10 Human Connectome Project subjects and 26 Parkinson's patients even though the two datasets were collected in very different ways. The study doesn't give exact compression or speed numbers in its summary, but it reports high-quality reconstructions and the tests were done on real patient data.

Today, tools like 'Do Not Track' settings and cookie banners let you tell websites how your personal information can be used, but they were built for a world where you click every link yourself. Now AI agents are starting to browse, shop, and book things for you on their own, and nobody has figured out how your privacy wishes should follow them around. The researchers studied privacy laws, earlier studies of privacy tools, and 30 popular AI assistants and agent platforms, then used what they learned to build a taxonomy, essentially an organized list, of the kinds of privacy preferences that an AI agent could actually be made to follow. To show it can work in practice, they also built eight open-source prototypes that mimic real agent apps and plug these privacy controls into the standard 'languages' that agents use to talk to tools and to each other (the Model Control Protocol and Agent2Agent protocol).

Collecting data from real robots is slow and expensive, so the researchers asked whether an AI could learn the basics of robot movement without ever seeing a robot. They wrote three computer programs that automatically generate endless made-up examples based on the math of how things get controlled, like a thermostat adjusting heat or a system steering toward a goal, and used them to train an AI model that predicts what a robot will do next. Even though this AI had never seen a real robot, it made decent predictions on real robot tasks it had never encountered, by picking up on patterns from the examples it was shown on the fly. The special control-based practice data worked better than generic made-up data, and a model trained on real robot data beat it only on the kinds of robots and tasks it had already studied. The abstract doesn't give specific accuracy numbers, so the main finding is that the made-up math-based practice gave a real head start.

Researchers built a system called WarpWeaver that lets a team of robots plan their own movements together, with each robot thinking on its own computer instead of waiting for one big central computer to tell everyone what to do. The robots work out a deal by 'bidding' on who gets to use shared space, kind of like negotiating over parking spots, and they keep improving their plan until time runs out, and they can even say how close to perfect their plan is. In simulations, this cut total travel time by up to 22% compared to planners that use one central computer and take lots of time to prepare ahead, and by up to 37% compared to other robot-by-robot planners that work in real time. It also nearly doubled the success rate of a specialized planner on a graph connectivity task, and it worked on six real robots that did all their own thinking onboard.

Some of the best robot controllers work like a chess player, planning many moves ahead on every tick of the clock, but that takes so much computing power that cheap, small chips struggle to run them. The researchers taught a neural network to copy one of these planners, and, unlike earlier attempts, they designed the planner ahead of time to tolerate the copy's small mistakes, so the network keeps the planner's safety and stability promises before it is ever switched on. This is different from older methods that either check the network's safety after training or bolt on a separate safety monitor while it runs. In simulation, the neural network behaved just like the original planner while needing far less computing at run time, though the abstract doesn't give exact speedup figures.

Doctors now use AI to read huge microscope images of tissue (called whole-slide images) to spot diseases like cancer, but these AIs usually just highlight 'important' spots without saying what the tissue actually looks like. The researchers built ProtoGTX, a system that links neighboring tissue patches together and then labels what it sees using a fixed 'vocabulary' of tissue patterns, like a visual dictionary of cell shapes and arrangements. In tests on two cancer datasets (CPTAC and BRACS), it beat other leading methods, especially on BRACS, and its pattern maps lined up with regions that pathologists had marked by hand. The key difference is that the dictionary is kept separate from the prediction model, so it can be built automatically or supplied by experts, and the explanations show tissue regions rather than scattered dots. The paper doesn't report exact accuracy numbers in the abstract, so the size of the improvement isn't stated here.

Brain scans called diffusion MRI track how water moves through tissue, but getting a complete picture takes so long and produces so much data that scanners can only collect part of it. The researchers trained a neural network to act like a compact 'recipe' for the whole scan, so it can fill in the missing pieces and sharpen the images instead of storing every raw measurement. Tested on 10 people from the Human Connectome Project and 26 Parkinson's disease patients scanned with very different settings, it recreated the scans with high accuracy while using far less memory than the original images. They also taught the network on an average 'template' brain first, so it learns each new person's scan faster.

Today, people can tell websites not to track or sell their data, but those controls were built for humans clicking around, not for AI agents that browse, shop, and make decisions on someone's behalf. The researchers made a detailed list (a taxonomy) of the kinds of privacy preferences people should be able to set for AI agents, drawing on privacy laws, studies of existing privacy tools, and a check of 30 leading AI assistants and agent platforms. They then built eight open-source prototypes that mimic real agent apps and show how these preferences can be built directly into the rules agents use to talk to tools and to each other (the Model Context Protocol and Agent2Agent protocol). The paper offers a blueprint rather than test results, but it is different because it moves privacy controls from a website setting into the core plumbing of how agents operate.

The researchers built a 5.5 kVA electric car charger prototype that can pull power from the grid, push power back into it, and even run household tools straight from the car's battery. Unlike most chargers, which need two separate conversion stages, theirs does the job in a single stage using special gallium nitride (GaN) transistors that can switch current in both directions. They developed a new control method that lets each phase of the power connection be managed independently, so it keeps working smoothly with lopsided three-phase power or ordinary single-phase household outlets without throttling back its output. In tests, the charger handled every mode they tried, including running a woodworking power tool on unevenly loaded phases and a powerful vacuum cleaner whose startup surge briefly overloaded the unit.

The researchers taught a robot arm with seven joints to dodge obstacles by giving its AI brain a kind of 'distance map' that shows, for every point in space, how far away the nearest object is. Because the robot always knows how close it is to danger, the team could use a much simpler scoring system to train it, and it worked with or without extra help from an older obstacle-avoiding technique called Artificial Potential Fields. They trained the AI only in a computer simulation using randomly placed, motionless objects, yet it worked on a real robot the first time with no extra tuning. It also handled new real-world environments it had never seen and dodged moving obstacles in real time. The abstract doesn't report specific success rates, so the headline result is the successful simulation-to-reality jump rather than a number.

Researchers built ProtoGTX, an AI system that reads huge microscope images of tissue (whole-slide images used to diagnose cancer) and, unlike most AI tools, explains what it sees instead of just highlighting 'important' spots. It first looks at how neighboring bits of tissue connect to each other, then matches them against a fixed 'dictionary' of tissue patterns, such as particular cell shapes or arrangements, so its reasoning can be read in pathology terms. On two cancer datasets (CPTAC and BRACS) it beat the competing methods tested, especially on BRACS, and its pattern maps lined up with areas that human pathologists had marked. A key difference from earlier work is that the pattern dictionary stays frozen and separate from the prediction model, so experts can supply their own, and tissue regions appear as coherent areas instead of scattered dots. The researchers did not report exact accuracy numbers in the abstract.

Huge libraries of human motion-capture data could teach humanoid robots how to move, but converting a human's movements to fit a robot's different body is slow and often needs a person to fix errors by hand. The researchers built a system called FRDV that does this conversion up to 136 times faster than existing tools, processing up to 9,156 animation frames per second, while using the robot's own physical limits to avoid glitches like feet sinking into the floor or limbs hitting each other. A second step then checks whether a motion is actually physically possible for the robot and cleans up problems like feet floating or sliding. They showed the converted motions work well for training robot control programs, including on a real Unitree G1 humanoid.

Diffusion MRI scans track how water moves through tissue like the brain, but a full scan takes a long time and produces huge files, so doctors usually capture only part of the picture. The researchers built a neural network that learns the whole scan as one smooth, continuous function, so it can fill in the missing measurements and produce sharper images from the data it has. They tested it on 10 people from the Human Connectome Project and 26 Parkinson's disease patients from their own lab, and it rebuilt the scans accurately while needing far less computer memory than the raw images. They also taught the network on a group 'template' brain first, which let it learn each new person's scan faster, even when the scans were taken with very different settings.

Teaching a robot to drive fast usually takes tons of trial and error, which is expensive and dangerous when the robot is a real race car that can crash. The researchers built a system called Prior-Informed Adaptation (PIA) that first lets the car's 'brain' practice on both quick-and-rough and slow-and-realistic driving simulators, treating those simulations as helpful but imperfect hints instead of the truth. Then, when the car moves to the real world, it fixes its own mistaken assumptions while staying cautious about things it's unsure of. In tests, PIA adapted to new tracks and road surfaces faster than other top methods, with quicker lap times and fewer crashes, and on a real full-size autonomous race car it learned reliably from less than one hour of actual driving.

Researchers built a 5.5 kVA electric-car charger that handles power in a single stage instead of the usual two, using tiny, fast GaN chips that can block voltage in both directions. They designed a new control method that lets each of the three power lines be steered independently, so the charger works on three-phase or single-phase outlets without losing power, can send energy back to the grid, and can even supply reactive power. In lab tests the prototype handled every charging and discharging mode, then ran real appliances straight from a car battery, including a woodworking power tool on unevenly loaded phases and a powerful vacuum cleaner whose startup surge briefly overloaded the charger. It kept running through the surge, which shows the design is tougher than a lab-only demo.

Researchers built a way for a tiny drone to keep flying accurately when the wind changes, without having to relearn how to fly from scratch. They gave the drone a fixed 'basic flight model' learned ahead of time in simulation and fine-tuned with a little real-world data, then added a small, fast-learning add-on that only figures out how the wind is pushing the drone around. A computer plans the drone's next moves using this combined model, and in tests with a palm-sized quadrotor in steady wind and in the swirling, uneven air behind an obstacle, it predicted its motion better and followed its path more closely as the wind got more disruptive. It does all this fast enough to run live during flight. The abstract does not give specific numbers, so we can't say exactly how big the improvement was.

When you control a robot from far away using a virtual copy of it on your screen (a 'digital twin'), the copy can fall behind the real robot because of network lag. Until now, people measured this only by how old the data was, in milliseconds, which misses the fact that old data matters far more when the robot is moving fast than when it's nearly still. The researchers invented a new score called Kinematic Age of Information (K-AoI) that multiplies data staleness by the robot's speed, so it tells you roughly how many centimeters off the virtual copy is from reality. They tested it on a real six-joint robot arm paired with a Unity-based virtual twin across seven simulated network conditions, and found K-AoI behaves quite differently from the old time-only score (correlation of 0.65 or lower, dropping to just 0.22 on a satellite-style connection), meaning it catches problems the old measure cannot see.

Some robot AI systems learn by predicting what the camera will see next while also deciding what actions to take, but they get easily confused when things that shouldn't matter change, like lighting, background clutter, or the color of the table. The researchers built a training method called PICA-WAM that teaches the robot's brain to give the same 'what should I do' answer whether it sees a normal scene or a messed-up version of it. It works by having a slowly-updating 'teacher' copy of the model look at the normal image while the 'student' model looks at the distorted one and tries to match the teacher's internal thinking. The abstract says it improved robustness across four existing models and several tests (RoboTwin 2.0, LIBERO-Plus, EBench, and a real robot), kept normal-conditions performance intact in simulation, and raised real-robot success rates, though the abstract doesn't give exact numbers.

The researchers built CoopUQ, a system that lets a team of robots share what they see so they can predict where people will be walking a few seconds from now, and just as importantly, how confident they are in that guess. Each robot uses the shared forecast to steer clear of spots that are likely to be crowded or that the team simply can't predict well, which is especially useful when a robot's view is blocked or when something unusual happens, like people suddenly rushing. Earlier approaches mostly treated each robot as a solo navigator, so they often missed hidden dangers. In tests across several simulated environments (including crowded and unfamiliar ones) and on real robots, CoopUQ predicted crowd movement better and had fewer safety problems than the comparison methods. The abstract does not give exact numbers, so the size of the improvement is not stated here.

Doctors now use AI to scan huge microscope images of tissue (called whole-slide images) to spot diseases like cancer, but the AI usually just says 'look here' without explaining what kind of tissue pattern it found. The researchers built a system called ProtoGTX that breaks a slide into small tiles, lets neighboring tiles share information so the AI sees the 'big picture,' and then labels regions using a vocabulary of recognizable tissue patterns (called prototypes), like a set of visual flashcards. It beat the other AI methods they tested on two cancer datasets (CPTAC and BRACS), especially on BRACS, and its pattern maps lined up with regions that human pathologists had marked. Unlike earlier approaches, the flashcard vocabulary is kept separate from the AI that makes predictions, so experts can define or swap it without retraining the whole system. The paper doesn't give exact accuracy numbers in the abstract, so the size of the improvement is described only as 'particularly pronounced' on BRACS.

Diffusion MRI is a type of brain scan that tracks how water moves through tissue, but getting a complete picture takes a very long time and produces huge files. The researchers built a small neural network that learns to represent the entire scan as one smooth mathematical function, so it can fill in measurements that were never taken and produce sharper images. They tested it on 10 people from the Human Connectome Project and 26 Parkinson's disease patients from their own data, and found it recreated the scans with high accuracy while needing much less storage than the raw images. They also trained the network ahead of time on an average brain template, which let it adapt faster to each new person and work even when the scans were collected with very different settings.

Teaching a robot to drive a race car usually takes a huge amount of real-world practice, which is expensive and risky because crashes are dangerous. These researchers built a method called Prior-Informed Adaptation (PIA) that first lets the car's AI "practice" in both rough and highly realistic computer simulations, treating those simulations as helpful but imperfect hints rather than the truth. Then the AI quickly corrects its mistaken assumptions using only a small amount of real driving, while staying cautious about things it's unsure of. In simulation, it adjusted to new tracks and road surfaces faster than other top methods, with quicker lap times and fewer crashes, and on a real full-size autonomous race car it learned reliably from less than one hour of actual driving.

Researchers worked with members of the Ohlone Native American community to build the Thámien Ohlone AR Tour, a phone-based augmented reality walking tour at Mission Santa Clara and Santa Clara University that overlays Ohlone stories onto the places visitors are standing. They surveyed 57 people before and after the tour, including Ohlone community members, university students and staff, and Mission visitors, and then analyzed the responses together as a group. They found that people felt a jarring mismatch, which the authors call 'spatial dissonance,' when the stories clashed with what the place looked like, such as learning that a pretty rose garden sits on a burial ground. Different groups read the same tour in different ways, and most people liked it and wanted permanent signs or markers on the land. What sets this apart is that the community wrote the stories, and the study measured how the real place and the digital story rubbed against each other, rather than just testing whether the tech worked.

Spacecraft that steer themselves using AI are hard to trust, because nobody can be sure the AI will behave in real space the way it did on a computer. The researchers built a step-by-step safety plan to close that trust gap: first test the AI in simulations, then on the actual computer chip, then on real spacecraft hardware, then on robots that mimic spaceflight, and finally in orbit. While the spacecraft is flying, a 'watchdog' AI monitors how well the controller is doing, and a 'guardrail' system steps in to block any dangerous commands. They showed the plan working on a learned (reinforcement learning) system that controls which way a spacecraft points, though the abstract doesn't report specific performance numbers. What's new is that they combined proven testing methods into one organized pipeline that tests the AI while it's actually running the show, instead of checking its pieces separately.

Scientists usually teach AI models to imitate physics by showing them thousands of examples, which is slow and can fail when conditions change. These researchers did something different: since the math for a wave equation (the Korteweg-de Vries equation, which describes things like shallow-water waves) was already known, they built the equations directly into the structure of a neural network called a PolyNet, so it needs no training at all. They tested it against traditional physics solvers and three trained AI models on traveling waves with known exact answers, running up to a million time steps and up to 10,000 simulations at once. PolyNet matched the accuracy of the traditional solvers, stayed accurate on wave sizes where the trained AI models broke down, and ran quickly on graphics chips with speed that barely changed as the grid got finer.

Chunyi Shen, a PhD student, built an interactive art installation called 'The Body in Algorithmic Colonialism.' It uses a camera to track a viewer's face and mimics how commercial emotion-detecting software turns facial movements into emotion labels and then into verdicts like 'compliant' or 'non-compliant.' The goal is to let people feel what it's like to be misjudged by these systems, instead of just reading technical explanations of how they work. There are no results or numbers yet: this is a first-year prototype, and the paper doesn't analyze any audience reactions or user data.

The researchers built a team of 15 small AI controllers for an office building, one for each zone (area) of the building, that learn how their own room heats and cools and plan ahead, without ever talking to each other. Each one can only see its own zone, so it guesses at the hidden effects of its neighbours, like the shared fan and cooling coil, using a 'hidden disturbance' estimate and the power readings from the other floors. In computer tests on five unseen, noisy weather years, the team cut the building's highest power draw to 88.3 kW, which is 3 to 17% lower than six other controllers (including rule-based ones and a popular AI method), and it spread out each floor's peak so they didn't all spike at once. It also trimmed the part of the electric bill based on monthly peaks by about 4% with similar comfort, and the whole 15-controller system runs on a single cheap Raspberry Pi 5 that responds in under half a second, far faster than the 15 minutes it has to decide.

Researchers took sharp, cell-level pictures of living human retinas using a much simpler camera setup than usual. Normally, doctors need expensive, bulky hardware with moving mirrors that physically bend light to cancel out blur from the eye's imperfections and constant tiny movements. This team instead recorded raw light-interference data, then used software to track how the eye was moving in several directions and to mathematically undo the blur afterward. The abstract doesn't give specific resolution or speed numbers, but it reports the first living-human retina images of this kind (reflection matrix imaging) without any physical correction hardware, reaching the best sharpness that optics allows (the diffraction limit) in 3D.

Researchers built a physical, hand-sized model of a city neighborhood to show how heat from the sun builds up in different parts of town. Instead of looking at a chart on a screen, people can touch the model, which uses stacked layers of material to show how much solar heat hits each spot. It also includes three swappable 'what if' versions (different ways a city could cool itself down) and a row of LED lights that mimic the sun moving across the sky, which users can switch on and off. When 16 people tried it out while thinking aloud, they responded very favorably, saying it felt new and made the heat information easier to understand than typical screen-based visuals. This was a small, early lab study that relied on people's impressions rather than measured learning gains, so it shows promise rather than proof.

Imagine a solar-powered robot boat that loops around the same route over and over, collecting data like water saltiness. Going faster uses a lot more energy, but going slower lets what the robot knows about each spot go stale. The researchers built a math framework that figures out exactly how fast the robot should travel at every point on its loop to keep its knowledge as fresh as possible without running out of power. Their rules show the robot should speed up or slow down depending on how important each spot is, and that with unlimited energy the benefit of going faster levels off at a hard ceiling. They tested the idea in a simulation of measuring salinity in the Chesapeake Bay, though this is a simulation and the abstract reports no real-world field test.

Researchers worked with members of the Ohlone Native American community to build the Thámien Ohlone AR Tour, a phone-based augmented reality walking tour at Mission Santa Clara and Santa Clara University that overlays Ohlone stories onto the places visitors are standing. They surveyed 57 people before and after the tour, including Ohlone community members, university students and staff, and Mission visitors, and then analyzed the responses together as a team. They found that people felt a jarring mismatch, which they call 'spatial dissonance,' when the stories clashed with how familiar places look, such as a pretty rose garden that is actually a burial ground. Participants appreciated the tour and wanted permanent physical markers on the land, and meeting present-day Ohlone people made it clear their culture is still alive. What sets this apart is that the community wrote the stories and the researchers studied how different groups experienced the same place differently, instead of treating all visitors as one audience.

The researchers built a step-by-step plan for proving that an AI-powered spacecraft pilot is safe before it flies, and for keeping it safe once it's up there. Before launch, the AI is tested in a series of increasingly realistic setups: first pure computer simulations, then on the actual onboard computer chip, then wired to real spacecraft hardware, then on robots that physically mimic how spacecraft move, and finally in real flight. During the flight, a 'watchdog' AI keeps an eye on how well the main AI is doing, and a set of safety guardrails automatically steps in if the AI tries something dangerous. They showed the whole process working on an AI that learned to control which way a spacecraft points, though the abstract doesn't report specific performance numbers. What's new is that instead of treating testing and in-flight safety as separate problems, they combined them into one practical pathway built entirely from technologies that already exist.

Scientists usually train AI models to imitate physics by showing them thousands of examples, which is slow and can fail when conditions change. These researchers took a different path: when you already know the physics equations, you can wire them directly into a neural network (which they call a PolyNet), so it needs no training at all. They tested it on a classic wave equation (the Korteweg-de Vries equation, which describes things like solitary water waves) and found it was about as accurate as traditional math-based solvers, even in situations where the trained AI models broke down. It also runs fast on graphics chips (GPUs) at nearly the same speed no matter how detailed the simulation is, and it handles thousands of simulations at once without slowing down much.

Chunyi Shen, a PhD student, built an interactive art installation called 'The Body in Algorithmic Colonialism.' It uses a camera to track a viewer's face and imitates how real emotion-detecting software turns facial movements into labels like 'happy' or 'angry' and then into a verdict of 'compliant' or 'non-compliant.' Instead of explaining how the software works with charts and code, the piece lets people feel what it is like to be misjudged by a machine's cutoff points. This is an early prototype from the first year of the project, so there are no results yet: no audience feedback, interviews, or measurements were collected, and no numbers are reported.

Researchers built a team of 15 small AI controllers, one for each zone of an office building, that keep rooms comfortable without ever talking to each other. Each one learns how its own room heats and cools, and it makes up for what it can't see (like how neighbors are using the shared fan and cooling system) by watching the power use of the other floors. In computer simulations of an office building, the team lowered the building's highest power spike to 88.3 kW, 3 to 17% better than standard rule-based and machine-learning controllers, and trimmed the peak-based part of the electric bill by about 4%. The trade-off is roughly 10% more energy use, but the whole system runs on one cheap Raspberry Pi 5 and responds in under half a second.

Normally, getting sharp, cell-level pictures of the back of the human eye requires bulky, expensive equipment with flexible mirrors that physically cancel out the eye's natural blurriness and shaking. These researchers built a much simpler camera setup with no such corrective hardware, then used software to fix the problems afterward. Their key trick was a program that tracks the tiny, involuntary movements of the eye in all directions using only the raw light measurements, which keeps the data lined up well enough to mathematically undo the blur. The result is the first time this 'matrix imaging' approach has worked on a living human retina, producing sharp 3D images of retinal tissue. The abstract does not give specific resolution numbers, only that the images reach the physical limit of what the optics allow.

Researchers built a physical, hand-touchable model of a city neighborhood that shows how sunlight heats the area. Heat data appears as stacked contour layers, like a topographic map made of cutouts, and the model comes with three swappable designs for cooling the area, such as different greenery or shading options. A row of LEDs mounted outside the model can be switched on and off to trace the sun's path across the sky. They tested it with 16 people, who thought aloud, were observed, and filled out questionnaires. Participants responded very favorably, saying the model was novel and made the climate information easier to understand than flat charts or screens usually do.

The researchers tackled a problem for solar- or wave-powered robots that patrol the same loop over and over, like a boat measuring water quality: how fast should the robot go at each point along the route? Going fast costs a lot more than proportionally more energy, but moving slowly lets the robot collect better data in a spot, while the knowledge of places it just left slowly fades. They worked out the math rules for the best speed at every point on the loop, showing that the robot should slow down at important spots and, if all spots matter equally, follow a steady pattern, and they found a limit on how good the information can get even with unlimited energy. They tested the idea in a simulation of tracking salt levels in the Chesapeake Bay, where it showed practical value. Unlike earlier work that mostly planned where robots go, this work focuses on how fast they travel along a fixed path to get the most useful information from limited harvested energy. The abstract doesn't report specific performance numbers, so the size of the improvement over simpler approaches isn't stated.

Researchers worked with members of the Ohlone Native American community to build the Thámien Ohlone AR Tour, a phone-based augmented reality walking tour at Mission Santa Clara and Santa Clara University that overlays Ohlone stories onto the real places people are standing. They surveyed 57 people before and after the tour, including Ohlone community members, university students and staff, and Mission visitors, and then analyzed the responses together. They found that people felt a jarring mismatch, which the authors call 'spatial dissonance,' when the stories clashed with what the place looked like, such as learning that a pretty rose garden is actually a burial ground. Different groups read the same tour differently, and most participants liked it and wanted permanent physical signs or markers acknowledging Ohlone history on site.

Engineers don't fully trust AI to fly spacecraft on its own, so this team built a step-by-step plan for earning that trust. First, the AI is tested in computer simulations, then on the actual onboard computer chips, then connected to real spacecraft hardware, then on robots that mimic space motion, and finally in real flight. While it flies, a second AI 'watchdog' keeps an eye on performance and a set of safety guardrails automatically blocks any move that would be dangerous. They showed the plan working on an AI that learned how to steer a spacecraft's pointing direction, but the abstract doesn't report specific performance numbers. What's new is that it combines testing on the ground and monitoring in flight into one connected process built from proven technologies.

Scientists usually train AI models to imitate physics, but here the researchers skipped the training entirely. They built a 'PolyNet,' a neural network whose wiring is set directly from the known math equations, so it behaves like a physics simulator but runs on the same fast chips used for AI. They tested it on the Korteweg-de Vries equation, which describes solitary water waves, and found it matched the accuracy of traditional simulation methods, even for wave sizes where trained AI models broke down. It also stayed just as fast no matter how detailed the simulation got and handled up to 10,000 simulations at once efficiently. The paper doesn't give exact speedup numbers in its abstract, so the main takeaway is that you get AI-style speed without AI-style training or accuracy risks.

The researcher built an interactive art installation called 'The Body in Algorithmic Colonialism.' It uses a camera to track your face and mimics how real-world emotion-detecting software turns your facial movements into labels like 'happy' or 'angry,' and then into a verdict of 'compliant' or 'non-compliant.' The idea is to let people feel what it's like to be misjudged by an algorithm instead of just reading an explanation of how it works. This is an early prototype from the first year of a PhD, and there are no results yet: the paper does not test it on any audience, so there are no numbers or findings about how people react.

Researchers built a way to take sharp, cell-level 3D pictures of the back of a living human eye using a much simpler camera setup than usual. Normally, doctors need expensive, bulky gear with moving mirrors that physically fix blurring caused by the eye's imperfect shape and its constant tiny twitches. Instead, this team recorded raw light-wave data and used software to track the eye's motion and cancel out the blur afterward, a technique called matrix imaging, which had never worked on a living person's retina before. The abstract describes the result as diffraction-limited (the sharpest image the physics allows), though it doesn't give specific numbers.

The researchers built a physical, hands-on model of a city neighborhood that shows how sunlight heats up the area. The heat data is shown as stacked, layered contours, like a topographic map, and the model comes with three swappable designs that show different ways to cool the neighborhood, such as adding trees or other changes. A row of LED lights mounted outside the model acts like the sun moving across the sky, and users can switch individual lights on and off to see how the sun's position changes things. In a lab study with 16 people, who were watched and asked to think out loud while using it, participants responded very favorably, finding the approach new and easier to understand than typical screen-based charts. Unlike flat graphs or computer maps, this lets people touch and rearrange the data themselves.

Imagine a solar-powered robot boat that loops the same route over and over, measuring something like water saltiness. The faster it goes, the more energy it burns (and the burn rate climbs much faster than the speed), but slowing down at a spot gives it more time to gather good data there. The researchers built a math framework that works out exactly how fast the robot should go at every point on its loop to get the most useful information from the energy it has. They proved that when every spot on the route matters equally, the best plan is different from when some spots matter more, and they showed that more energy gives better information only up to a limit. They tested the idea in a simulation of tracking salinity in the Chesapeake Bay, but the paper reports no real-world robot trials, and the abstract gives no specific performance numbers.

Researchers worked with members of the Ohlone Native American community to build the Thámien Ohlone AR Tour, a phone-based augmented reality walk that overlays Ohlone stories onto Mission Santa Clara and Santa Clara University. They surveyed 57 people before and after the tour, including Ohlone community members, university affiliates, and Mission visitors, and also analyzed the results together as a team. The big finding was something they call 'spatial dissonance': people felt a jarring tension when the stories clashed with how they were used to seeing a place, like learning a pretty rose garden is actually a burial ground, or when the real surroundings contradicted the history the tour affirmed. Different groups interpreted the same tour differently, but most people appreciated it and wanted permanent physical markers, like signs or plaques, acknowledging Ohlone history on site.

Spacecraft run by AI are hard to trust because no one can fully predict what a learning-based computer program will do once it's out in space, and you can't send a repair crew. The researchers laid out a step-by-step safety process: test the AI in computer simulations, then on the actual onboard chip, then with real spacecraft hardware, then on robots that mimic spacecraft motion, and only then in flight. While the spacecraft is operating, a 'watchdog' AI keeps an eye on the main AI's performance, and a 'guardrail' system can step in and override it if it tries to do something unsafe. They showed this works using a case study where an AI learned to control a spacecraft's pointing direction, and the paper's main point is that it's a practical way to combine existing tools, rather than a brand-new invention, with no headline performance numbers reported in the abstract.

Many scientists train AI models to imitate physics simulations, but these researchers asked: if we already know the physics equations, why train anything at all? They built 'PolyNets,' a type of neural network whose wiring is set directly from the known equations, so it needs zero training and does the same math a traditional simulator would. They tested it on the Korteweg-de Vries equation (which describes a certain kind of wave, called a soliton) and found it was about as accurate as standard numerical solvers over a million time steps, even when the waves were bigger or smaller than anything a trained AI had seen. Unlike the trained AI models, which got worse outside their training conditions, PolyNet stayed accurate, ran fast on graphics chips (GPUs) at roughly the same speed no matter how fine the grid, and handled up to 10,000 simulations at once efficiently.

The researcher built an interactive art installation called 'The Body in Algorithmic Colonialism' that uses a camera to track your face and then mimics how real emotion-reading software works: it turns your facial movements into emotion labels like 'angry' or 'happy' and then hands down a verdict of 'compliant' or 'non-compliant.' The point is to let people feel what it's like to be misread by a machine, rather than just reading an explanation of how these systems work. This is an early prototype from the first year of a PhD, and it doesn't include any numbers, accuracy results, or tests with real visitors yet, so there are no findings about how people react. What makes it different is that it treats 'explaining AI' as a physical, emotional experience instead of a technical diagram.

The researchers built a team of 15 small AI controllers for an office building, one for each zone (area) of the building, where each controller learns how its own room heats and cools while it works. The controllers never talk to each other, yet they avoid piling up power demand at the same time by watching how much electricity the other floors are using. In computer simulations of a real-style office building across five unseen, noisy weather years, the team cut the building's highest power draw to 88.3 kW, which is 3 to 17% lower than the other methods, while keeping people about as comfortable as a standard rule-based system. Compared with that reactive rule, it saved 33 kW (about 4%) on the monthly peak charges that utilities bill for, at the price of using about 10% more energy overall, and the whole system ran on one cheap Raspberry Pi 5 computer.

Researchers built a working prototype of a computer tool that helps hospital managers plan nurse shifts. It predicts how many nurses will be needed and suggests schedule changes, and the team designed it step by step with input from healthcare experts. They then tested it with expert users, tracking their eye movements, giving them questionnaires, and interviewing them. They found that when the tool showed how unsure its predictions were, people often misread that information and felt less confident in their decisions. Explanations of why the AI made a suggestion were liked, but they didn't change how confident people felt or how often they followed the advice. The abstract doesn't report specific numbers, and the study is notable for testing these transparency features with real domain experts rather than general participants.

A team of researchers put a small satellite about the size of a shoebox into orbit with an off-the-shelf NVIDIA Jetson TX2 NX graphics chip, the kind of hardware found in hobby and industrial robots, and used it to teach an AI model new things while flying in space. The AI looks at heat-sensing camera images and picks out which parts show the Moon, and the satellite then used that to steer itself and keep the Moon in view, all without waiting for instructions from Earth. Over about one year they ran 12 experiments, showing both that the satellite could train the AI itself in orbit and that it could use the AI to point itself in real time. Earlier space missions mostly ran AI models that were trained on the ground and then fixed in place, so training in orbit with ordinary commercial parts and free open-source software is a big step.

Taking a sharp picture of the back of your eye is hard because your eye never holds still and its imperfections blur the image. Until now, doctors needed expensive, bulky machines with moving mirrors that physically fix this blur as it happens. These researchers built a much simpler camera setup with no physical correcting parts and wrote software that figures out how the eye moved in every direction just from the raw light data, then undoes the blur afterward. This is the first time anyone has done this kind of computational 'matrix imaging' on a living human retina, producing sharp 3D images at the finest detail that light physics allows. The abstract does not give specific numbers for resolution or speed, so those details would have to come from the full paper.

Researchers built a mixed reality game where people use a headset to care for a virtual animal while driving a real TurtleBot robot around a room, as a friendly first introduction to robotics. Ten people tried it using three ways of steering the robot: a joystick, tapping waypoints for it to follow, and drawing a path for it to trace. After playing, people felt significantly more confident about robotics, but their interest went up only slightly, not enough to count as a real change. Eight of the ten preferred the joystick, which felt easier and less frustrating, while drawing a path was the hardest, yet none of the methods was clearly more fun or engaging than the others. With only 10 participants and the confidence result described as exploratory, these are early signals rather than firm proof.

Researchers built AutoSTEM, a workshop where teenagers play a video game and then control real hardware using a PID controller, which is the same feedback trick that keeps drones level and cruise control steady. They ran seven workshops in Sweden and Italy; in the six Swedish ones, teachers used methods designed to boost students' motivation, while the Italian one used the usual format. Students' confidence in their own technical skills jumped a lot in both groups, but their scores on an actual knowledge quiz improved only a little, and not by enough to count as proven. Surprisingly, the motivation-focused teaching made no measurable difference, and girls reported smaller confidence gains than boys in understanding PID control.

Researchers built a working prototype of a computer tool that helps hospital managers schedule nurses, predicting how many staff will be needed and suggesting schedule improvements. They worked with experts on the design, then tested it with experienced healthcare professionals using questionnaires, interviews, and eye tracking to see where people actually looked and how they made decisions. The surprising result was that when the AI showed how unsure it was about its predictions, users often misread that uncertainty and felt less confident in their choices, rather than making better ones. Explaining why the AI gave its advice was generally liked, but it didn't change how confident people felt or how often they followed the advice. Note that the abstract doesn't give specific numbers, so the key finding is about how people reacted, not a measured accuracy score.

The researchers built MEND, an AI planner that tells a team of drones and ground robots how to work together on big missions. Drones cover lots of ground fast but run out of battery quickly, while ground vehicles can act as mobile charging stations but are stuck on roads. MEND generates a whole plan by filling in actions in a smart order, starting with the ones it is most sure about, and it uses a built-in rulebook to throw out any move that breaks the rules, like a drone flying farther than its battery allows. Earlier methods either guessed the order poorly or needed rules written in a special math form; MEND handles plain logical rules, and the team tested it in simulation, on real-world maps, and with actual robots. The abstract does not give specific numbers, so the exact size of the improvement is not stated here.

Imagine a humanoid robot trying to reach into a cupboard while keeping a tray level and its feet planted — every move has to obey strict rules about its body, and finding a safe path is slow because most random moves the computer tries break those rules and have to be corrected. The researchers built a planner called PATACON that runs on a graphics card (GPU) to try thousands of paths at once, and instead of guessing moves in all directions and fixing them afterward, it only takes steps along the 'allowed' directions that already respect the rules. In tests with two arms holding an object together and with full humanoid body movements, PATACON got faster than the previous GPU-based planner the harder the problem got, reaching up to 11.25 times faster.

ByteDance engineers built ByteExpress, a software layer that lets the computers behind their AI systems pass data to each other directly from memory, skipping the slow, crowded route that standard internet-style networking (TCP) uses. Switching to faster networking hardware wasn't enough on its own, so they added tools to manage memory, share connections efficiently, stop too many messages from arriving at once, and recover quickly when services crash. In real production use, fetching AI model data got 35.7% faster on average (43.7% faster in the slowest cases) and used 10.69% less CPU. For training, the slowest data-sending delays dropped by up to 74%, with no network traffic jams, which is what makes this a field-tested recipe rather than just a lab experiment.

The researchers built STcubeOperator, an open-source software tool that lets analysts explore data about events happening in specific places and times, such as military operations or disaster reports, by stacking them into a 3D 'space-time cube' where two dimensions are the map and the third is time. Instead of using one fixed view, analysts combine simple building-block moves like filtering out events, chopping the cube into slices, and flattening it into a regular map or timeline, so they can look at the same data from many angles. They tested it on real data about strategic and military operations in the Russia-Ukrainian War, where it revealed patterns in where and when events clustered, and an expert user study with 8 analysts showed which operations people actually rely on. What makes it different is that earlier space-time cube tools mostly showed the data but didn't support the step-by-step, back-and-forth exploring that real investigations need.

Imagine trying to move a robot's arms and body through a crowded room while keeping them locked into specific poses, like two arms carrying one tray without tilting it. Computers usually find a path by guessing lots of random moves, then nudging each guess back into 'legal' positions, and that nudging is slow. The researchers built PATACON, a planner that runs on graphics chips (GPUs) and takes small steps along the 'legal' surface from the start, so far fewer guesses need fixing. On tasks with two linked arms and full humanoid bodies, it was up to 11.25 times faster than the previous GPU planner, and its advantage grew as the robot got more complicated.

When thousands of computers work together to run or train AI models, they constantly swap huge amounts of data, and the usual internet-style way of doing this (called TCP) is slow and wastes processor power. A faster technology called RDMA lets one computer write straight into another's memory, but ByteDance's engineers found that just switching to it wasn't enough, because real-world traffic is messy, connections pile up, and servers sometimes crash. So they built ByteExpress, a software layer on top of RDMA that manages memory, shares connections, controls traffic flow, and recovers from failures. In ByteDance's live AI systems it cut the average time to fetch model data by 35.7% (and the worst-case delays by 43.7%), used about 10.7% less total processor power, and slashed the worst-case delay for sending training updates by up to 74% compared with TCP, all without the network traffic jams that RDMA setups often suffer.

Researchers built STcubeOperator, an open-source software tool that helps people make sense of events that happen at specific places and times, like battles in a war or damage during a disaster. It stacks the data into a 3D block where two directions show the map and the third shows time, and analysts can slice, filter, and flatten that block step by step to look at the data from different angles. Older 3D time-and-place tools mostly just show the data and don't support the many-step exploring real analysts do. The team tested it on real data from military operations in the Russia-Ukraine War, where it revealed patterns across space and time, and eight expert analysts used it to solve tasks, which showed which operations they rely on most. The paper reports no performance numbers beyond that small user study.

Most efforts to make robots smarter involve building bigger AI models and collecting huge piles of new demonstrations, which is slow and expensive. These researchers found a cheaper trick called ARC: teach the robot to write out a short explanation before each move, saying what it's about to do, why that's the right move, and what should happen as a result. They created these explanations automatically from an existing public collection of robot demonstrations (DROID), so nobody had to film new robot data. After training two top robot AI models to use these explanations, the models set new records on two major robot test suites, gaining up to 50 percentage points on the hardest reasoning tasks. On real robots, one model's success rate on tasks it had never been specifically trained for jumped by 82.2 percentage points.

Researchers built LiteNWM, a system that helps a robot 'imagine' what will happen if it takes different paths before it actually moves. Older systems did this by generating full video-like pictures of each possible future, which is so slow that a robot can only check a few options. LiteNWM instead looks at the scene once and quickly predicts a compact summary of what each candidate path would lead to, then uses a trained scorer to pick the best one. It ran 128 times faster than the earlier approach on a high-end graphics card, made path errors about 17.6% smaller, and in real-world tests in unfamiliar indoor and outdoor places raised the robot's navigation success rate from 43.3% to 83.3%.

The researchers built Recursive Game Creator, a system where four AI helpers work in a loop to make video games that are actually fun, not just ones that run without crashing. A Designer plans the game, a Builder codes it, a Player AI tests it by running quick programmed strategies instead of slowly clicking through screens, and a Reviewer judges how it plays and sends advice back for the next round, keeping only the better version each time. It scored 77.89 on the GameCraft-Bench test, completed 53.2% of tasks fully on GameASG-Bench (34.1% better than the same AI model working alone), and passed 93.4% of automatic checks that the game runs correctly. In a user study, real people played the games longer and rated them higher.

Most efforts to make robot AI smarter mean building bigger models and collecting huge piles of new robot demonstrations, which is slow and expensive. These researchers built a method called ARC that teaches existing robot models to 'think out loud' before acting, by writing a short explanation of what the robot should do next, why that action makes sense, and what it should cause to happen. They generated these explanations automatically from an existing robot video dataset called DROID, so no new robot data had to be collected, and used them to retrain two leading robot models (π0.5 and Cosmos3-Nano-Policy). The result was a new state of the art on two major robot benchmarks, with gains of up to 50 percentage points on a reasoning-heavy test, and on real robots the π0.5 model's task success jumped by 82.2 percentage points.

Researchers built the math model for a robot leg that lets one machine both walk like a four-legged animal and fly like a drone with five propellers. The leg uses two linked loops of connected bars (called four-bar linkages) so that three motors can move the foot around, and the team worked out exactly where the leg's motion gets 'stuck' or becomes uncontrollable, known as singularities. They used this math to design several walking patterns in a MATLAB computer simulation and then tested them on a real single leg mounted on a test rig. The abstract doesn't give specific performance numbers, but it shows the same leg can handle both ground walking and reshaping itself mid-air, which most robots can't do.

Volunteer firefighters in Austria often get called out through scattered channels like radio, texts, and paper, so no one has a shared, up-to-date picture of what's happening. The researchers built FireOPS, a smartphone app and online system that sends alerts, gives directions, shows a live map of the emergency, displays which nearby fire stations are busy, and offers digital manuals, all in one place. It gets its information from two sources at once, the radio and the regional server, so if one fails, the other keeps the data flowing (though phones still need the internet to receive it). They tested it using real records from a major regional flood in 2024 and a public app release in 2025, and compared it with similar tools (DIVERA 24/7, blaulichtSMS, and LifeRescue), finding that its live shared map, decision-support tools, and two-source backup set it apart. The abstract doesn't give specific performance numbers, but the team traced problems seen during the flood to specific fixes, some already in use and some still being built.

Researchers built a virtual reality 'nature walk' that puts you in a calm outdoor setting with realistic scenery, soothing sounds, guided breathing exercises, and stops along the way that prompt you to pause and reflect. They designed it so people with different physical and sensory abilities, or people who can't easily get outside, can still use it. In a small test with 10 people, the experience seemed to help them relax and feel better emotionally. One clear finding was that people felt more 'in' the world when they could move smoothly and continuously instead of blinking from spot to spot with teleporting, though with only 10 participants the results are early signals, not proof.

Volunteer firefighters in Austria often get called out through scattered channels like radio, phone alerts, and paper maps, so nobody has one shared picture of what's happening. The researchers built FireOPS, a smartphone app and back-end system that sends alerts, gives navigation, shows a live map of the emergency, displays how busy each nearby fire station is, and pulls up the right manuals when needed. It gets its information from two sources at once, the radio and the regional server, so if one fails the other keeps working (though sending alerts to phones still needs the internet and mobile networks). They tested it using real logs from a major regional flood in 2024 and the app's public release in 2025, and found that, compared with similar apps (DIVERA 24/7, blaulichtSMS, LifeRescue), its standout features are the shared live map, decision support, and double-sourced data. The paper does not give headline performance numbers; instead it lists the problems seen during the flood and the fixes the team built or is building.

Researchers built SCRUB, a system that lets a robot dog with no arm (a Unitree Go1) press a tool mounted on its body against a wall or column and slide it along while pushing with steady force. To do that, the robot has to know which way the surface faces, and SCRUB figures this out purely by touch, without cameras or a pre-made map. It combines two clues: how the surface pushes back sideways, and which way the tool actually moves once the robot's walking wobble is averaged out over each step cycle. In hardware tests at normal speed and load, SCRUB completed every wall traverse and every column orbit, while versions with either clue removed, without the step-averaging, or with a fixed guess for the wall direction never completed a single orbit. Earlier methods needed to know the surface's friction or assumed the tool slides perfectly along the surface, which walking breaks.

Researchers built H^2MARL, a new way to teach humanoid robots to walk and move by treating every single joint as its own little 'student' that is told exactly what kind of joint it is (how strong, how heavy, how it moves), instead of lumping joints into big groups or treating them all the same. They also fixed a common problem where the part of the robot's brain that plans the next pose and the part that actually moves the joints get trained separately and then don't work well together, by training both at the same time on the same practice runs. In tests in two popular robot simulators (MuJoCo and Isaac Gym), the robots walked more steadily, moved their limbs more smoothly together, and looked more natural than with older approaches. The abstract doesn't give specific numbers, so the exact size of the improvement isn't stated.

Researchers showed that the same high-frequency wireless signals used for fast data links (like next-generation Wi-Fi and 5G) can also tell how fast a person is walking and which way they're going, with no camera, wearable, or radar needed. They bounced a 60.8-GHz signal off a wall and watched how a person walking through it made the received signal strength dip and wobble in a pattern, then measured how long the dip lasted (slower walkers cause longer dips) and how lopsided the wobbles were before versus after the dip (which reveals direction). In tests with three people making 144 walks, a simple statistical classifier correctly sorted walking speed into two groups 86.1% of the time and into three groups 79.2% of the time, and identified walking direction 77.1% of the time, even on people it had never seen before. What's new is that it works with ordinary, fixed communication beams, skipping the specialized radar hardware and heavy signal processing earlier approaches required.

The researchers built a soccer-playing humanoid robot system called soccerbot that learned to move, dribble, stop the ball (trapping), and kick all with one single 'brain' instead of separate programs for each skill. To get there, they first studied a large collection of motion-capture recordings of real people playing soccer and boiled it down into a kind of 'library of natural human movements.' The robot's learning was then kept inside that library, so its moves look like a person's and it can smoothly switch between skills when told to, rather than moving stiffly or oddly like many earlier robots. After practicing entirely in simulation, the system worked right away on a real Unitree G1 humanoid robot with no extra tuning, though the abstract does not report specific numbers such as success rates or speeds.

Researchers tackled a tricky problem: identifying people by the pattern of pressure their feet make on a sensor-covered floor, even when they've changed shoes since signing up. They built a new AI system called BiStepNet that looks at where pressure lands on the floor and how it changes over time as two separate pieces, instead of mashing them together. Trained on the StepUP-P150 dataset, it did better than compact 3D baseline models at recognizing people in shoe types it had never seen before, and without needing any retraining for new people or new footwear. The team also found that accuracy keeps improving as you add more shoe types and more variety to the training data, and that even outside gait datasets that only partly match the setup can give a further boost. The abstract doesn't report specific accuracy numbers, so the exact size of the improvement isn't stated here.

I can't write an accurate summary of this paper because the information provided contains only the title, journal, and issue date. The abstract, authors, and results weren't included, and I can't verify the paper's contents, so any specific numbers or findings I wrote would be fabricated. From the title alone, the researchers appear to have built a soft, bioinspired robot designed to move through the intestines, steer itself, and perform medical procedures, as an alternative to rigid endoscopes. If you share the full abstract or paper text, I can write a complete, specific summary.

This paper is a report on a competition where teams built AI models that automatically turn ordinary phone photos into sharper, better-looking ones, similar to what a professional photographer would do while editing. The catch was that the models had to run on the phone itself, on the graphics chips inside the latest Qualcomm Snapdragon 8 Elite Gen 5 and MediaTek Dimensity 9500 phones, instead of on powerful remote servers. Teams trained their models on thousands of pairs of photos taken with an old iPhone 3GS and a professional Canon 70D camera, learning to make the phone shots look like the pro ones. The best entries could enhance a full HD image (1920x1080 pixels) in under 300 milliseconds, less than a third of a second, on both chip families.

The researchers built WayTrace, a system that lets a walking-and-rolling robot follow the same turn-by-turn directions you'd get from a phone map app, even when GPS is shaky. An AI that understands pictures and text reads the directions, a satellite map, and the robot's camera view, then gives one simple command at a time, like 'cross the road to the left.' A second AI, trained on over one million automatically labelled street photos, draws the path for that command right on the camera image, and a movement controller follows the drawn line. In simulated long trips it stayed on crosswalks and sidewalks with about ten times fewer violations than robots that just chase GPS coordinates, and a real robot completed trips up to 1.37 km at about 1.1 m/s through a busy city center, rural trails, and a campus, handling crosswalks, staircases, and construction sites.

Researchers built a smarter 'brain' for a two-wheeled robot with legs, one that keeps it upright even when it gets surprise shoves from wind or a heavy load it didn't know it was carrying. The brain has two parts: one that continuously guesses what the robot's body is really doing from noisy sensors and figures out hidden pushes on it, and one that plans ahead while respecting the limits of the motors. In computer simulations, it tracked speed more accurately than a standard approach, with an error of 0.11 m/s versus 0.24 m/s. When carrying a surprise 2 kg load in a 10 N headwind, it drifted only 6 cm versus 81 cm for the standard method, and it stayed upright in 11 of 12 tough test combinations versus 9 of 12. All of this was done in simulation on flat ground, so it hasn't been tried on a real robot yet.

Researchers built DPAGait, a system that identifies people by the way they walk, even in messy real-life video where clothing, bags, camera angles, and weather change from day to day. Older methods mostly turn a walking person into a flat black-and-white cutout, which throws away a lot of useful detail. Instead, DPAGait adds information about which body parts are where (arms, legs, torso) to those cutouts, and it also fits a 3D digital human model to the video to track how the body moves in three dimensions. The abstract says the new body-part representation worked well across four tough real-world datasets and the full system performed competitively on three of them (SUSTech1K, CCPG, and Gait3D), but it does not give specific accuracy numbers.

The researchers built a math model of crowds walking in both directions through a looping set of hallways, where each hallway has two lanes and people drift toward whichever lane is less crowded. They then designed a gentle 'lane guidance' signal, like a staff member waving people over or a screen suggesting a lane, that nudges people to switch lanes without adding or removing anyone or turning them around. They proved that a balanced, steady crowd flow always exists and is unique, and that putting just two guidance zones in one well-chosen corridor is enough to make it theoretically possible to calm the whole system down as fast as you want. This is different from earlier work because it shows you don't need guidance everywhere; a tiny, cleverly placed amount of it can control the entire network. It's a mathematical proof backed by computer experiments, not a test with real crowds.

Robots that roll around hospitals, malls, and offices need to learn how to move politely around people, but most testing happens in computer simulations rather than real life. The researchers built RESONATE, a standardized real-world test course where the same robot, running the same software, tried eight different navigation methods across eight everyday situations (like passing someone in a hallway), with each test repeated five times for 320 real experiments in total. They measured both hard numbers (how fast and safe the robot was) and what human volunteers thought about how comfortable and natural the robot's behavior felt. No single method won everywhere, but one called DWA with Gaussian social costmaps was the most reliable, and another called SFM-MPPI gave the best mix of safety, speed, and being liked by people.

I can't write an accurate summary because the details you provided are missing: the authors field is blank and the abstract is only a journal citation (Science Robotics, Volume 11, Issue 119, October 2026), not the paper's actual findings. From the title alone, the researchers appear to have built a soft, bioinspired robot for moving through, steering within, and performing procedures in the intestines (an enteroscopic robot). Without the abstract or full text, I can't state what they built, what numbers they measured, or how it improves on earlier devices, and inventing those specifics would risk misleading your readers.

Scientists studying how running robots stay balanced found a clever way to make a hard math problem easy. Simple spring-and-weight models of running ignore the upper body, and when you add a torso, the equations get so tangled that people could only study them with computer trial-and-error. The team designed a rule for the hip motor, called the central pivot point, that always aims the push from the ground straight through the robot's center of mass, which keeps the torso's tilt from messing up the runner's bouncing motion. This let them write down actual formulas (the first of their kind for a runner with a torso) that predict where the runner will be after each stride, with average errors of only 1.6% for takeoff speed and 0.9% for the high point of its hop.

The researchers built a free software tool called TRAILS that automatically creates virtual indoor worlds, complete with hallways, open rooms, and obstacles, along with a path to travel through each one and a speed plan for how fast to move along it. It works a bit like a recipe generator: the building layouts come from a puzzle-piece-style method (inspired by an algorithm called Wave Function Collapse), the paths are smooth curves, and the speeds respect real-world limits on how quickly something can speed up or turn. Every generated trip lasts exactly the same amount of time but differs in shape, how close it passes to walls, and how its speed changes, so scientists can fairly compare them in virtual reality experiments. Unlike AI-based generators, it uses fixed, step-by-step rules and a 'seed' number, so anyone can reproduce the exact same scenarios, and the abstract does not report specific performance numbers.

The researchers built SNAP, a robot navigation brain that learned through trial and error (in simulation) how to walk or roll through busy city streets without bumping into people while also staying on sidewalks and off roads. Earlier systems usually handled just one of those jobs: either dodging crowds or following sidewalk-style rules, but not both together. SNAP looks at a simple top-down colored map showing what kind of ground is where (sidewalk, road, grass) and where moving obstacles are, rather than tracking and predicting each individual person's movements. The abstract reports that it beat the best existing crowd-avoidance and terrain-aware methods and worked on a four-legged robot in real-world crowds without any extra training, though it doesn't give specific performance numbers.

I can't write an accurate summary of this paper, because the details provided are limited to a title, a journal name, and an issue date; the abstract, authors, and results were left blank. From the title alone, it describes a soft, bioinspired robot designed to move through the intestines, steer itself, and carry out medical procedures along the way, presumably as a gentler alternative to rigid endoscopes. I won't invent specifics like the robot's size, speed, or test results, since doing so would risk publishing fabricated claims under a real journal's name.

Legged robots that carry an arm, like a robot dog that can also pick things up, usually walk using a pre-trained 'brain' that works well but can't be changed, which makes precise arm work hard because the robot's body wobbles in ways nobody can predict. The researchers added a second program that learns, while the robot is running, how the body actually moves when that frozen walking brain is in control. The tricky part is that the same situation can produce different motions because of hidden factors, so their method sorts out which responses are predictable and learns mostly from those, ignoring the noisy ones. With this, a robot's hand stayed within about 0.01 meters (1 centimeter) of its target, in both simulation and on real hardware, even when they swapped in different arms and tasks.

Some neurological conditions make walking hard, and rhythmic cues (like a steady beat) can help people keep a smoother pace. Instead of using sound, which blocks out conversation and traffic noise, the researchers tested small wearable devices that tap or buzz the body in rhythm. They tried these devices across six linked studies with 17 people who have walking difficulties and 3 physiotherapists, in care homes and in everyday community life. They found seven things that decide whether these devices work in real life, including whether the buzz can actually be felt, whether the device is easy to put on, how simple the controls are, and whether the rhythm can change for hills, tiredness, or slowing down. Many people said it made them feel more confident and more willing to walk, but the study did not prove it improves walking, and some people with weak sensation, memory or thinking difficulties, or very limited mobility could not use it well.

The researchers built SAFARI, a system that lets a four-legged robot explore unknown places on its own while hunting for dangerous objects and staying safely away from them. Older exploration robots mostly tried to cover as much ground as possible, but SAFARI treats "what is that object and how risky is it?" as part of the map itself, so the robot plans its route using both the shape of the space and what it has spotted. In 11 real-world missions across three outdoor test sites, the robot mapped 98.7% of the area it could reach, ran without a human stepping in for 97.6% of the time, and spotted objects as small as 15 cm across. Tests where they switched off features showed that knowing how big an object is and planning safer paths were both essential for the robot to search well.

The researchers built FOCUS, a method that teaches simulated robots to move like an expert just by watching videos of the expert's body positions, without being told what the expert's motors were doing or how the moves line up in time. Instead of trying to copy a whole movement at once, FOCUS compares short snippets of the robot's motion to several short pieces of the expert's motion and keeps the best matches, kind of like matching puzzle pieces. It also uses a physics simulator that can show the robot exactly how to adjust its movements, plus a 'scorekeeper' that estimates how well things will go beyond the short window it looks at, which keeps training from going off the rails. On tough walking and running tasks, including a humanoid with 152 simulated muscles, FOCUS learned faster and more reliably than earlier approaches, though the abstract doesn't give exact speedup numbers.

Researchers wanted to know whether fancy 'automatic curriculum' methods, which pick training challenges for a robot as it learns, actually work better than simply starting with easy ones. They built a single fair test where fourteen different training strategies each taught the same learning algorithm to walk across rough terrain, using five four-legged robots in simulation, including the Unitree Go1 and Go2, Boston Dynamics Spot, and Google's Barkour. The big finding is that no method won everywhere: strategies that simply fed the robot easy terrain often tied for the best results on familiar terrain, a simple success-driven curriculum from real legged-robot practice landed in the top group most often, and plain random terrain never did. On three of the five robots, the method that scored best on familiar terrain was not the best on terrain it had never seen, so a good score on one test doesn't guarantee a good score on the other.

Researchers taught a humanoid robot to play dodgeball: when a ball is thrown at it, the robot quickly twists, ducks, and sidesteps without falling over. They trained it using reinforcement learning (trial and error in a computer simulation), with rewards that grow as a ball gets closer, so the robot learns to react to the most dangerous throws first. To keep its moves from looking weird or breaking its own balance, they also showed it examples of human-style dodging in several directions and nudged it to copy that style. The paper says the system dodged much better across different ball speeds and throwing distances in simulation and worked on a real robot, though the abstract doesn't give exact numbers.

I can't responsibly write a specific summary of this paper, because the information provided includes only the title and journal citation, with no authors, abstract text, or results. The title tells us researchers built a soft, bioinspired robot designed to move through the intestines, steer itself, and perform medical interventions, which would set it apart from rigid, tethered endoscopes. But I don't have the actual numbers, test results, or design details (such as how far it traveled, in what kind of tissue, or how it compares to existing tools), and inventing them would mislead your readers.

Researchers designed a drone with four propellers and two wheels that can drive along a floor without tipping its body to move sideways, which is how most wheeled drones have to do it. The trick is that all four propellers are slightly angled and all spin the same direction (clockwise), instead of the usual pattern where neighbors spin in opposite directions. Because the wheels touch the ground, the angled propellers can push the drone forward along the surface while it stays perfectly level. Their design optimization showed this all-clockwise setup produces more push along the ground than the traditional alternating-spin layout, and computer simulations showed the drone both hovering in the air and rolling across a floor while staying level; this was demonstrated in simulation only, with no real-world hardware tests or specific performance numbers reported.

Researchers wanted to know whether fancy 'curriculum' methods, which automatically pick harder and harder practice terrain for a robot to learn on, actually work better than just starting easy. They built a fair test that ran fourteen different curriculum methods on five four-legged robots in simulation (including the Unitree Go1 and Go2, Boston Dynamics Spot, and Google's Barkour), using the same learning algorithm and the same training budget for every method. The result was messy: no single method won on every robot, and methods that simply trained on easy terrain often landed in the top group on typical test terrain. The curriculum used in real legged-robot practice, which makes terrain harder as the robot succeeds, placed in a top group most often, while plain random terrain never did. On three of the five robots, the best method on familiar terrain was not the best on new, unseen terrain.

Researchers built a training system called Humanoid Dodgeball that teaches a humanoid robot to dodge fast-moving balls thrown at it, much like a kid in a game of dodgeball. The robot learned through trial and error in simulation, earning rewards for avoiding balls that were actually on course to hit it, while example human-style dodging motions in different directions (left, right, ducking and so on) kept its movements stable and natural instead of wild or likely to make it fall. The abstract reports that the robot got much better at dodging across a range of ball speeds and throwing distances, in both simulation and on a real robot, but it does not give specific numbers, so exactly how big the improvement is can't be stated here. What makes it different from earlier work is that it handles fast, whole-body evasive moves while still keeping the robot balanced and moving in a physically realistic way.

I can't write an accurate summary of this paper: the details provided include only the title, journal, and issue (Science Robotics, Volume 11, Issue 119, October 2026), with no authors, abstract, methods, or results. From the title alone, the work appears to describe a soft, bioinspired robot designed to move through, steer within, and perform interventions inside the intestine. Without the paper's text, I can't state what the researchers built, what they measured, or how it compares to earlier endoscopes, and I won't invent specific numbers or findings.

The researchers designed a small four-propeller drone with two wheels that can both fly and roll along the ground. Normally, drones like this have to tilt their whole body to push sideways, which makes it hard to keep a camera or tool pointed steadily. Instead, the team tilted the propellers slightly and had the wheels touch the floor, so the push from the propellers drives the drone along the surface while its body stays perfectly level. They also found that spinning all four propellers the same direction (clockwise) produces more sideways force than the usual setup where they alternate directions, and their computer simulations showed the drone hovering in the air and then driving across a floor without tilting, though the work has not yet been tested on a physical robot.

Researchers wanted to know whether fancy 'automatic curriculum' methods, which build a training course that gets harder as a robot learns, really beat just starting training on easy terrain. They built a benchmark that tested fourteen of these methods under identical rules on five simulated four-legged robots (including Unitree Go1 and Go2, Boston Dynamics Spot, and Google's Barkour), using the same learning algorithm and the same training budget for each. The surprise: no method won on every robot, and methods that simply fed the robot easy training levels often tied for the top spot on typical test terrain. A practical, success-driven curriculum from real legged-robot practice placed in the top group most often, while training only on randomly mixed terrain never did and a popular method called PAIRED almost never did. On three of the five robots, the best method on familiar test terrain was not the best on new, unseen terrain.

Researchers taught a humanoid robot to play dodgeball, using trial-and-error learning (reinforcement learning) to dodge fast-flying balls with its whole body instead of just freezing or stumbling. They gave the robot extra reward for noticing an incoming ball as a threat, and they also showed it examples of human-like dodging in different directions (left, right, ducking and so on) so its moves look natural and keep it from falling over. In simulation and on a real humanoid, the robot got much better at avoiding projectiles across different ball speeds and throwing distances. The abstract does not give exact numbers, so the size of the improvement can't be stated here. What sets this apart from earlier work is that it combines fast reactions, balance, and natural-looking motion in one system, rather than trading one off against another.

I can't write an accurate summary of this paper from what was provided. The only details given are the title ('Bioinspired soft enteroscopic robot for intestinal locomotion, steering, and intervention') and a journal citation (Science Robotics, October 2026). The abstract, author list, and results were not included, and I can't verify the paper's content. Any specific numbers or findings I wrote would be fabricated, which would be misleading in a trade publication. From the title alone, I can only say the work concerns a soft, bio-inspired robot designed to move through, steer within, and perform procedures in the intestine.

The researchers designed a small drone with two wheels and four propellers that can both fly and drive along the ground without tipping its body over. Normal wheeled drones have to lean forward to move sideways, like a person leaning into a strong wind, which means a camera or tool mounted on them gets tilted too. This drone angles its propellers slightly and uses the floor pushing back against it to slide forward while staying perfectly flat. They also found that having all four propellers spin the same direction (clockwise) pushes harder along the ground than the usual setup where they alternate directions, and computer simulations showed the drone hovering in the air and rolling across a floor while staying level. The paper reports simulation results only, so no physical prototype has been built yet.

Walking robots that explore on their own often forget places they've already been, because the memory built into their AI brains fades over long trips. The researchers built a new kind of memory called Local Spatial Matrix Memory (LSMM), which works like a grid of sticky notes where each note is tied to a specific spot in the world, so the robot can jot down what it sees and look it up later. They tested it by having a robot explore mazes. It covered about the same amount of maze as the best older methods, but it was the only one that actually remembered the maze layout, making its map of the maze about three times more accurate.

I can't write an accurate summary of this paper because the information provided contains only the title and journal citation, with no abstract, author list, methods, or results. From the title alone, the researchers appear to have built a soft, bioinspired robot designed to move through the intestine, steer itself, and perform medical procedures, but I can't state what it is modeled on, how it moves, or what numbers or test results they achieved without making them up. Please share the abstract or full text and I will write a specific, accurate plain-language summary.

The researchers designed a one-legged hopping robot for the Moon, where gravity is only about one-sixth of Earth's, so jumps last longer and the robot pushes on the ground with less force. They used a computer search that tries out different leg lengths and, for each one, tests how well the robot can jump straight up using two different 'brains': a fast reactive controller and a slower method that plans the whole jump ahead of time. The two brains preferred different leg lengths, and the plan-ahead method used 17% less energy per distance traveled at its best design. They then taught the robot to jump in place and forward without tipping over, and to land safely using a separate balancing controller, though this was shown on a single leg design with both segments 0.3 meters long, in a simulation of a flat, two-dimensional world.

Researchers got two very old programs that write other programs running again: Herbert Simon's Heuristic Compiler from 1961 and an MIT assistant called KBEmacs from 1984. Both were built as theories of how people program, one treating programming as step-by-step problem solving and the other as combining familiar patterns, and the team showed they work by reproducing the exact code from Simon's 1963 paper and a 1984 test run called SQRT. They also found the two theories overlap more than expected, since both build new programs by adapting pieces that already exist. They used a modern AI coding tool, Claude Code, to do much of the revival work, and they point out that today's far more powerful AI coding assistants have no explicit, inspectable theory of programming built into them, which these old systems did.

When lots of AI training jobs run in a data center, their power use rises and falls in repeating waves, and if those waves line up they can shake the electrical grid like a crowd stomping in unison on a bridge. The researchers built a scheduling program that decides exactly when to start each new training job, delaying launches by just a couple of seconds (about 2.2 seconds on average) so the waves cancel each other out instead of stacking up. In simulations, this cut the troublesome power swings in the 0.2–2 Hz range by 74.39% and shrank overall power variation by 46.6%, while meeting every launch deadline and calculating each decision in under 0.4 seconds. Unlike earlier fixes, it needs no batteries or extra equipment and never pauses or interrupts jobs that are already running.

Researchers built MARL-Exo, a system that teaches a robotic hip-assist device to help people walk by training it in a computer simulation alongside a virtual human with 304 individual muscles. The goal was to make the device reduce the energy the body burns while walking, and the same trained controller was then put on eight real people without any custom tuning for each person. Compared with wearing the device switched off, it cut energy use by 18.3% on average, and compared with not wearing it at all, it cut energy use by 7.4% on average (up to 24.2% for the best responders), even after accounting for the extra effort of carrying the device. Earlier methods usually had to adjust the device live for each wearer, which takes a long time, so a single controller that works for new users right away is a big change.

Event cameras are special cameras that only notice things that change, like the edges of moving objects, which makes them fast and very low-power, perfect for tiny drones. Training a drone's AI brain with these cameras has been painfully slow because simulators first draw a full, realistic picture and then convert it to camera-style data. The researchers skipped the drawing step and built a simulator that calculates the moving edges directly from the shapes of objects and the drone's motion, making each frame about 400 times faster to produce (17 millionths of a second). Training that once took ages now takes under 30 minutes, and the resulting AI, shrunk to just 1.2 MB, flew a 56-gram Crazyflie drone through three real obstacle courses with an 82% average success rate, with no extra tuning, outside computer help, or positioning system.

Walking robots that learn from trial and error often forget things they saw earlier, like which parts of a maze they've already been through, because the built-in memory they use gets fuzzy over long stretches of time. The researchers built a new kind of memory called Local Spatial Matrix Memory (LSMM) that works like a map with labeled boxes: the robot saves each piece of information in a memory slot tied to the physical spot where it learned it. They tested it on a robot exploring mazes and found it covered just as much of the maze as the best existing memory systems, but it was the only one that actually remembered the maze's layout, with about three times less error when asked to redraw the maze from memory.

The researchers designed a one-legged hopping robot meant for the Moon, where gravity is only about one-sixth of Earth's, so jumps are slow and floaty and the robot's body shape and its 'brain' have to be planned together. They built a computer search that tries out many leg-length combinations, testing each one on a straight-up jump using two different control methods. The two methods picked different best leg lengths, and the more thorough planning method used 17% less energy per distance traveled than the simpler real-time controller. They then taught the robot to jump forward and in place while keeping its body balanced in the air, and added a second controller that cushions the landing and keeps it from tipping over, all shown on a robot with two 0.3 meter leg segments.

The researchers dug up two very old programs that wrote other programs, Herbert Simon's Heuristic Compiler from 1961 and an MIT assistant called KBEmacs from 1984, and got their original code running again on modern computers. The revived Heuristic Compiler reproduced the exact program code printed in Simon's 1963 paper, and KBEmacs reproduced its December 1984 self-test that builds a square-root program. These old programs were built on clear, written-down theories of how people program: Simon's treated it as step-by-step problem solving, while KBEmacs treated it as snapping together familiar patterns called 'cliches'. Today's AI coding helpers are far more powerful, but they work without any explicit theory like that, and the researchers used one of them (Claude Code) to help do the revival work.

When AI companies train big models, the computers they use draw power in rhythmic surges, and those pulses can make the electric grid wobble if many jobs surge at the same time. The researchers built a smart scheduler that delays the start of each new training job by a couple of seconds so that the jobs' power surges cancel each other out instead of piling up. In their simulations, this cut the troublesome power swings by about 74% and the overall variation in power use by about 47%, with an average delay of just 2.2 seconds and no running job ever interrupted. Unlike earlier fixes that need extra batteries or other hardware, this one works purely through software timing and finishes its calculations in under 0.4 seconds, fast enough to keep up in real time.

Researchers built a virtual human with 304 muscles and taught a robotic hip brace, entirely in a computer simulation, to help it walk using as little energy as possible. The two learned together, with the virtual person and the brace adjusting to each other, and the brace only got to 'feel' its own joint movements. They then put the trained brace on eight real people without retuning it for each person. Compared with walking in the brace while it was switched off, it cut energy use by about 18% for all eight people. Compared with walking without any device, the average saving was 7.4%, because wearing the heavy device costs extra energy, and six people ended up spending as much as 24% less energy than normal walking. Earlier approaches usually had to tune the device on each person for a long time, while this one produced a single ready-to-use controller.

Researchers built a fast shortcut for teaching tiny drones to dodge obstacles using 'event cameras,' special cameras that only notice moving edges instead of capturing full pictures. Normally, training a robot's AI means generating realistic video first and then converting it into camera data, which is painfully slow. Their new simulator skips the pretty pictures and calculates the camera data directly from where objects are and how the drone moves, producing each tiny 64x64 frame in 17 microseconds, over 400 times faster than before. This cut training time to under 30 minutes (about a thousand times faster than the old way), and the resulting AI flew a 56-gram Crazyflie drone through real obstacle courses with about 82% success, with no extra tuning, outside computers, or tracking systems.

The researchers built a new planning system that lets a four-legged robot dodge moving obstacles while using its full range of motion, including sidestepping and turning while it walks. Older planners made the math easier by pretending the robot could only move like a simple car, which wastes moves the robot can actually do, and they only checked for collisions at certain moments, so a moving obstacle could slip through between checks. Their system describes the robot's path with a special kind of curve (Bernstein polynomials) whose shape guarantees the whole path is safe, not just the checkpoints along it. They ran it in simulation against other methods and on a real quadruped weaving through unknown moving obstacles, where it used sideways and turning motion that simplified models rule out. The summary provided doesn't report specific numbers, so exact speed or success-rate figures aren't available here.

Teaching a walking robot with simulation is hard because the math for 'feet hitting the ground' is jumpy: a foot either touches the floor or it doesn't, so the computer gets no hint about how to improve a step that almost made contact. The researchers built a smoothed version of that math that gives the learning algorithm a helpful nudge toward touching, slipping, or sticking, while the simulator itself still plays out realistic, physically correct hard contact. Using just 100,000 simulated samples and under 2 minutes of training on a regular desktop PC, they trained a trotting policy that worked on a real four-legged robot with no extra tuning. The robot withstood shoves and walked over debris and slippery ground, and the new method also found tricky contact-heavy motions that older gradient approaches missed.

Robot computers slow themselves down when they get too hot, which is a big problem for robots working in places like deserts or factories where the air is 45-55°C. The researchers built a simple system called Thermal-Headroom Routing that uses a basic physics formula to predict how hot the robot's chip will get, then picks a lighter or heavier version of its object-detecting AI so the chip never overheats. In simulations with four YOLO11 detector sizes, it completely eliminated slowdowns from overheating, cut missed deadlines by 3.9-7.5 percentage points, and used about 12-13% less energy per useful frame than a router that only watches speed. However, the team found that a carefully hand-tuned temperature rule can do just as well in one fixed setting, so the new method's real edge is that it adapts when the weather or hardware changes.

Researchers built a brain-inspired computer program, called a spiking neural network, that reads electrical signals from the forearm muscles and works out how each finger is moving, continuously and all at once. They copied tricks from the spinal cord, like how it recruits small muscle fibers before big ones (called Henneman's size principle) and how it balances 'go' and 'stop' signals. They tested it on 23 people grabbing objects with their arms in different positions, and it beat six standard machine learning and deep learning methods on every accuracy measure. It worked best when the input signals fired at up to about 128 times per second and in a regular rhythm, and, unlike many AI models, its internal activity could be tied back to real physiology, so people can see why it makes its predictions.

The researchers built ZAP, a system that teaches an existing AI model (one that already understands pictures and language) to control a robot arm, using only practice in a computer simulation and no real-world robot data at all. First they let the model's built-in knowledge handle figuring out what a task is asking for, then they trained it in simple virtual tasks to learn how to actually move the arm. When they put it on a real robot, it succeeded 96.7% of the time, matching a much bigger commercial AI (GPT-6 Astra) while running 3x faster and 17x cheaper, and beating another robot-specific AI model (MolmoAct2) that only managed 33.3%. It even handled things it was never trained on, like seating a test tube in a rack, handing it between two arms, drawing an X on a tic-tac-toe board, and playing chess, and it worked on a different robot (a Franka arm) too.

The researchers started with completely blank images and changed just a handful of pixels, one at a time, keeping each change only if it made the AI's 'image brain' think the picture looked more like a chosen target, such as a particular dog breed or a caption. They did this against two popular kinds of vision AI (OpenCLIP, which links images and text, and DINOv3, which learns from images alone) without needing to see inside the models. The results were striking: the nearly blank, human-meaningless images often fooled the AI into treating them as a specific target, with strong top-1 and top-5 retrieval on OpenCLIP and near-top prototype rankings on DINOv3, tested on ImageNet and Flickr30k. The abstract doesn't give exact percentages, so the specific scores are in the full paper. What's different from earlier work is that it needs no model internals and works on both major families of vision AI, which points to a shared weakness rather than a one-off bug.

Researchers trained robot controllers to make a humanoid robot copy five movements taken from regular videos, then tested them in a second, independent simulator, the usual last check before trying a real robot. The controllers worked fine normally, but when they added just 40 milliseconds of lag between a command being sent and the robot acting on it, only about 15% of attempts succeeded, and the robots could only handle 20-30 ms of lag before falling. When the researchers randomly varied the lag (0-50 ms) during training, success at 40 ms jumped to 95% on average and the lag the robots could tolerate rose to 50-70 ms. The key difference from earlier work is that the commonly used 0-20 ms lag range turns out to be too small to help, so the benefit only comes from training with more lag than the robot already tolerates.

Researchers took an AI model that learned to control robot arms bolted to a table and got it running on a much harder machine: a four-legged robot dog (a Unitree Go2) carrying a robotic arm (an AgileX Piper). On the dog, the AI has to decide how to walk, how to hold its body, and how to move the arm all at once, instead of just moving an arm that stays put. They found that showing the robot a wider range of example demonstrations cut its aiming errors by 30%, and that teaching it extra tricks like pushing objects instead of grabbing them added new abilities without making its pick-and-place skills worse. They also tested it in real-world trials and showed that the mix of training examples largely determines whether the robot succeeds or fails.

The researchers built a two-part brain for a humanoid robot that helps it walk and climb over tricky terrain like stairs and gaps. The first part is a 'contact planner' that looks at what the robot senses and predicts where its feet and body will touch the ground in the near future, kind of like picking your next stepping stones. The second part is a 'tracker' that turns those planned touch points into smooth, natural whole-body movement, and it learned this by studying human motion data as a guide rather than copying it move for move. After that, the robot practiced further on its own in situations the motion data never covered, and in the end it works using only its onboard sensors, with no reference recordings needed. The abstract does not report specific numbers or benchmark results, so the exact performance gains are not stated here.

Researchers ran three experiments with over 300 people total to see how the layout of a virtual room changes the experience of watching a 360-degree movie together in social VR (where everyone appears as avatars in a shared space). They tested shared versus individual 'bubbles' of space, how big each person's personal space was, and whether the group members already knew each other. Sitting in a small shared space made people feel more connected to the others, but also made the experience more mentally tiring. Shrinking personal space had a similar effect, boosting the sense of being together while also causing more disorientation and frustration, and groups of friends focused better on the story but felt more physical and visual strain. The big takeaway is that most past studies treated immersive stories as a solo activity, while this one shows that simple choices like seating distance create clear trade-offs between feeling close and feeling comfortable.

The researchers built F2G-Pose, a system that lets a robot figure out how an object is positioned and oriented in 3D space, plus how big it is and what its hidden back side looks like, just by looking at one color-and-depth camera image. Older methods either made mistakes by chaining together several guesses or were slow because they generated lots of possible answers and then had to sort through them. F2G-Pose gets its answer in a single quick pass, running at 28 frames per second, while scoring at the top of the leaderboards on the SOPE and ROPE benchmarks. It was trained only on computer-generated images, yet it still worked on real-world objects and in real robot grasping tests.

Researchers built a software method that figures out how the bones on either side of a joint, like the thigh and shin around a knee, are rotating relative to each other, using small motion sensors strapped to the body. Past methods needed someone to carefully measure exactly where each sensor was placed, or only worked for simple joints or simple movements. Their approach works out the sensor positions and the joint rotation at the same time while the person is moving, with no setup step. When tested on real data from four people walking and doing more complicated tasks, it was off by only about 2.6 degrees on average, compared with 10.4 degrees for a similar method that used a separate calibration step and 7.4 degrees for one that used measurements from motion-capture markers.

The researchers built a system that teaches a humanoid robot to walk and climb over tricky terrain by first having it predict where its feet and body will touch the ground, then moving its whole body to match that plan. They used human motion recordings only as a training guide, so the robot picks up natural-looking movement without being locked into copying those exact motions. After that, they let the robot practice by trial and error in situations the recordings never covered, like unusual obstacles. The result is a single robot brain that uses only its own onboard sensors, with no pre-recorded motions needed when it's actually running. The abstract does not report specific numbers, so the exact performance gains are not stated here.

Researchers ran three experiments with over 300 people total to see how the way you're 'placed' in a shared virtual space changes the experience of watching a 360-degree movie with others in VR. They tested things like whether viewers sit in individual bubbles or one shared group area, how much personal space each person gets, and whether the group members already know each other. Smaller shared spaces and tighter personal bubbles made people feel more connected to the others, but also made them more mentally taxed, disoriented, and frustrated. Groups of friends paid closer attention to the story and felt more present in it, but also reported more physical and perceptual strain. Unlike most earlier work, which treats immersive stories as a solo activity, this study shows that simple layout choices create clear tradeoffs between feeling together and feeling comfortable.

The researchers built F2G-Pose, an AI system that looks at one color-plus-depth camera image of an object, like a mug or a camera, and figures out which way it's pointing, where it is, and how big it is, all in a single quick step. Unlike earlier methods that either made mistakes by passing guesses through several stages or took a long time by generating and sorting through many possible answers, this one runs at 28 frames per second while still beating other methods on two standard tests (SOPE and ROPE). It also fills in the hidden back side of the object as a 3D shape, which helps keep its size estimate realistic. Even though it was trained only on computer-generated images, it also worked on real-world objects and in real robot manipulation experiments.

When people wear small motion sensors on their legs to track how their joints move, the sensors usually have to be carefully calibrated first, with someone measuring exactly where each sensor sits on the body. The researchers built a smart math-based filter (an extended Kalman filter) that figures out both how the two sensors are tilted relative to each other and where they're located, all while the person is moving, so no setup measurements are needed. They tested it on real walking and complex movement data from four people and three leg joints, and it was off by only 2.61 degrees on average. Older methods that relied on setup calibration were off by 7.43 to 10.40 degrees, so the new approach was both easier to use and about three to four times more accurate.

The researchers built a system that teaches a humanoid robot to walk, climb, and move over tricky terrain by first having it plan where its feet and body will touch the ground, then carry out that plan with its whole body. They used human motion recordings only as practice material during training, so the robot picks up natural-looking movement without being locked into copying those exact motions. After that, the robot was trained further on its own to handle obstacles and terrain that weren't in the original recordings. Once trained, it works using only its own onboard sensors, with no pre-recorded motions needed. The abstract doesn't give specific numbers, so the main finding is that this 'plan the contacts first' approach combines the natural look of motion-capture methods with the adaptability of trial-and-error learning.

Watching movies with friends is usually a social experience, but most research on 360-degree VR stories treats viewing as something you do alone. The researchers ran three experiments with 109, 116, and 88 people to test how the shape and size of each person's virtual 'personal space' and how well the viewers know each other change the experience of watching a story together in social VR. Putting people in a small shared space made them feel more connected to each other but also made the experience more mentally tiring, and shrinking personal space did the same while also causing more confusion and frustration. Groups of friends paid closer attention to the story and felt more 'inside' it, but also reported more physical and mental effort, which shows that features that boost engagement often cost viewers extra effort.

Researchers built F2G-Pose, a system that lets a robot figure out exactly how an object is sitting in 3D space (which way it's turned and where it is) from a single color-plus-depth camera picture, even for objects it has never seen before, as long as they belong to a familiar category like mugs or bottles. Earlier methods either made a series of guesses where early mistakes snowballed into bigger ones, or used slow 'diffusion' AI that tries many possibilities and then has to sort through them. F2G-Pose skips all that by doing everything in one quick pass, running at 28 frames per second, while also predicting the object's real-world size and filling in the hidden parts of its shape. It was trained only on synthetic (computer-generated) data, yet it set new accuracy records on the SOPE and ROPE benchmarks and also worked on real objects in other datasets and in real robot manipulation tests.

Researchers built a computer program that figures out how the bones on either side of a joint, like a hip, knee, or ankle, are rotating by using small motion sensors strapped to the body. Older methods needed someone to measure exactly where each sensor sat on the body beforehand, or only worked for simple joints like a hinge, but this new program figures out the sensor positions and the joint rotation at the same time while the person moves. They tested it on real data from four people walking and doing more complicated movements, and it was off by only about 2.6 degrees on average, compared with about 7.4 to 10.4 degrees for the older approaches. It also uses a filter to smooth out the sudden jolts that happen when a foot hits the ground, which used to throw off the measurements.

Researchers built a method called the Probabilistic reach-avoid Value Function (PVF) that lets a robot figure out which starting situations will probably end with the job done and no crashes, even when random bumps and noise get in the way. Older methods assume the worst possible thing will always happen at every moment, like planning a road trip as if every light will be red and every road will flood, so they end up labeling lots of perfectly good situations as unsafe. PVF instead learns from the robot's own practice runs, without needing a written-down model of how the robot works, and works out the actual odds of success. They tested it on systems of growing difficulty, up to a hopping robot, and found that when the random disturbances aren't out to get the robot, PVF's safe zones were more accurate and less overly cautious than those from the older worst-case methods. The abstract doesn't give specific numbers.

Power grid equipment relies on tiny, precisely timed messages between machines, so adding security monitoring has traditionally risked slowing those messages down. The researchers built a system called OTSV that works like a silent observer: it listens to a copy of the network traffic through a special port, has no way to send anything back into the live network, and sends its findings out through a one-way path. They tested it on a lab power-monitoring setup using common industrial languages (Modbus TCP and IEC 61850 MMS) and collected nearly 33,000 timing measurements, finding that turning monitoring on added less than 0.12 milliseconds of delay. That is small enough to be hard to measure, which suggests you can watch for hackers without hurting the equipment's speed.

The researchers wanted to know if a robot that learned to walk on Earth in a computer simulation could also walk on the Moon, where gravity is much weaker and the ground is soft, dusty soil. They trained 12 different walking programs for a simulated Unitree G1 humanoid robot and tested them with different gravity levels, bumpy terrain, and soil types. Programs trained on Earth mostly stayed upright on the Moon (64 to 75 percent of the time on flat ground), but programs trained for the Moon fell over right away on Earth, and a publicly released all-purpose walking program managed only 10 percent or less on the Moon. The best result came from a program trained with random gravity levels on bumpy, sandy terrain, which stayed standing at least 84 percent of the time on Earth and 96 percent on the Moon, even on slopes up to 20 degrees (all results are simulations, not real Moon tests).

Researchers trained a four-legged robot to jump to a chosen spot in the low gravity of the Moon, where one big leap can carry a robot over cracks and boulders that wheeled rovers can't cross. They used a trial-and-error computer learning method to produce one single 'brain' that goes straight from sensor readings to leg motor commands, using only the kinds of sensors a real space mission could carry. In simulation, the robot landed closer to its target than the length of its own body, and it still handled glitches like its controller freezing for a full second in mid-air. On a real robot, the team showed a successful vertical jump with a setup that cancels out part of Earth's gravity to imitate the Moon's, and the measured motor strength and power use matched the simulation and stayed within what the robot's hardware can handle.

When a walking robot looks at the ground, it usually takes in a huge map of everything around it, even though only the spots where it's about to step really matter. The researchers built a small add-on called a foothold prediction model that guesses where the robot's feet will land next, based only on how the robot is moving and where it's been told to go. The robot then looks at tiny patches of terrain around those guessed spots instead of the whole map. This let the robot reach a given terrain difficulty in about a third of the training time, handle narrow corridors and unfamiliar ground better than robots using the full map, and match a much more expensive approach that costs several times more to train. The trained robot then walked over stairs, gaps, and step-downs on a real Unitree G1 humanoid without any extra tuning.

Researchers built a computer tool that automatically designs walking robots made from LEGO Technic bricks, which can walk in several different styles instead of just one. Older LEGO walkers copied a single motor-and-linkage design, so they were stuck with one fixed way of walking. The new approach gives each leg its own motor and uses a pair of special 3D-printed oval-shaped (non-circular) gears to shape how each foot moves, while a simple timing program coordinates the legs. The software also designs the robot's body and its walking pattern together to match the walking style and look the designer wants, and the team built and tested several real walkers to show it works. The abstract doesn't report specific performance numbers, so how fast or efficient these walkers are isn't stated.

Researchers built SAFTER, a safety filter that sits between a robot's learned decision-making and its motors, and checks not just 'is this move safe right now?' but 'will the robot still be able to avoid trouble a moment from now?' Think of a driver who doesn't just avoid hitting the wall this second, but also makes sure they can still brake in time for the next turn. They trained a four-legged robot to navigate with this filter built into the learning process, and it hit 90% success using about 30% fewer practice runs than standard training and about 34-35% fewer than older safety-filter methods. In new, unfamiliar environments it beat two leading methods by up to 42 and 61 percentage points, and it succeeded 73.3% and 76.7% of the time on two real-world maps. A key finding was that the robot has to 'see' how the filter changes its actions while learning: using a shortcut instead dropped success in the hardest test environment from 61.4% to 6.2%.

Researchers built a new way for a snake-shaped robot to move called S-rolling. The robot's body forms an S-shape, and its front half and back half spin at different speeds, a bit like rolling a rolling pin while also being able to turn. Earlier rolling methods kept the robot flat enough to squeeze under things but couldn't steer, while steerable methods made the snake wiggle up and down and need more headroom. In real-robot tests, S-rolling crept through a track only 10 cm tall and turned about 90 and 180 degrees underneath a large workpiece and a car chassis, something the older rolling method could not do at all.

Researchers designed a new way for snake robots to move by sidewinding (the sideways, looping crawl that desert snakes use) while also twisting their bodies. An earlier twisting method crammed almost all the twisting into two joints in the middle of the robot, which overworked those motors and made the robot stall on tough ground. The new method, called a linear twisting function, spreads the twisting evenly along the whole body so no single joint does too much. At the same turning speed and total power, this cut the peak power demand on a single twist joint by 42%. In real-robot tests, the new gaits crossed terrains the older twisting method couldn't handle, and moved up to 49% faster than regular sidewinding without twisting.

Robots that follow spoken instructions often fail at long jobs made of many steps, like opening a drawer, grabbing a bowl, and putting it away, because when one step goes wrong, the whole attempt gets blamed and the robot can't tell which step actually needs fixing. The researchers built AtomicRL, a training method that breaks long tasks into small 'atomic' steps, keeps a failure in one step from unfairly punishing the good steps around it, and spends extra practice time on whichever step the robot is currently worst at. It beat the standard training method (PPO) by 3.6 to 4.0 percentage points on the LIBERO-LONG benchmark across two robot AI models and by up to 9.5 points on CALVIN ABC-D. When paired with a pipeline that trains in simulation and transfers to real robots, it improved real-world task performance by an average of 21.3%.

The researchers built a four-legged robot that can both walk and fly, using propellers (thrusters) attached to its body. The tricky part is that walking and flying need very different kinds of control, so the team designed two separate 'rulebooks' ahead of time, one for walking and one for flying, and then used a real-time decision-maker that blends them on the fly, deciding how much work the legs versus the thrusters should do at any moment. They tested this blending in computer simulations and then ran real experiments showing the robot's hardware holds up and that it can trot with thruster help while staying stable. The paper doesn't report headline numbers like speed or payload, so the evidence is mostly that the design works and stays stable, but it's different from earlier robots because it uses one unified control system for both walking and flying instead of switching between two separate ones.

A researcher built a navigation system that lets a two-legged humanoid robot turn its body sideways to squeeze through tight spaces or politely make room for people walking by. The system measures how wide a path really is for the robot, counting both physical clearance and how comfortable nearby people would feel, and then smoothly shifts the robot from facing forward to stepping sideways as the path narrows. The robot's walking skills were also retrained using human motion data so it can switch between forward walking and sidestepping without stumbling. One important caveat: this paper only describes the method and a planned test on a Unitree G1 robot, so there are no measured results yet, though demo videos from simulation and a real robot are available.

Researchers built a method called the Probabilistic reach-avoid Value Function (PVF) that lets a robot figure out which starting situations are likely to end well, meaning it will reach its goal without hitting anything dangerous. Older methods assume the worst possible bad luck at every moment, like planning a road trip as if every light will be red and every road will flood, which makes them overly cautious and rules out many situations that are actually fine. PVF instead learns from simulated trials how likely success really is when the bumps and nudges are random, and it does this without needing a hand-written model of the robot or a pre-set limit on how big the disturbances can be. In tests on systems ranging from simple to a hopping robot, the new method drew safe-zone maps that were less overly cautious and more accurate than the worst-case approach when the disturbances were random rather than out to get the robot. The summary does not report specific numbers, so exact accuracy gains are unknown.

Power grid equipment relies on messages arriving at precisely the right moment, so adding security cameras to the network can accidentally slow things down and cause problems. The researchers built a system called OTSV that works like a silent observer: it receives a read-only copy of the network's traffic through a special port on a network switch, inspects it for suspicious activity, and can only send information out, never back in. In a lab test of a simulated power-monitoring setup, they checked about 33,000 round-trip message times and found that turning the monitoring on added less than 0.12 milliseconds of delay, which is too small to measurably affect the system. Unlike earlier approaches that sit in the middle of the data path and risk slowing it down, this one stays completely off to the side.

Researchers tested whether warehouse robots can learn to drive themselves by practicing in a computer-simulated copy of a real building, instead of engineers hand-tuning the robot's driving software for every new robot and site. They built a virtual twin of the Idealworks R&D center, trained NVIDIA's COMPASS navigation AI there, and used NVIDIA's Cosmos tool to make the simulated images look more like real camera footage. When they ran the robots in the real facility, the success rate jumped from 65.3% to 91.7% across four test scenarios, and travel time nearly halved compared with training only on generic simulations. That puts the learned driver within 8.3 percentage points of the company's current hand-engineered navigation software, and it runs entirely on the robot's own onboard computer.

Scientists used X-ray video to watch a desert lizard called the sandfish dive into dry sand and 'swim' through it. Once underground, it stops using its legs and instead sends a wave rippling down its body from head to tail, pushing against the sand to move forward. To predict how fast it would go, the team measured how hard sand pushes back on a small cylinder dragged through it at different angles, then added up those forces along the lizard's moving body. The predictions matched what the real lizard did, which shows that moving through sand works like swimming through a thick, grainy liquid where friction (not momentum, like in water) controls everything. Before this, no good theory existed for predicting movement in sand the way equations exist for water.

Robots often need to figure out how fast they're moving using only a motion sensor (like the one in your phone), but teaching a robot to do this normally requires expensive 'answer key' recordings of exactly where it went. These researchers found a way around that: they first use simple math to estimate speed changes over tiny slices of time (a 'myopic teacher' that only sees a moment at a time), and a learning model trained on those rough estimates somehow ends up predicting speed better than the math that taught it. They then polish the model by checking its guesses against a map of the whole path, with no answer key needed. Tested on six datasets covering walking people, drones, four-legged robots, and a humanoid, their models landed within 0.07 meters per second of average speed error of models trained the expensive way, with no position or speed labels at all.

AI models that predict video of moving machines can look accurate while still breaking the laws of physics, so the researchers built a test that checks three separate things: whether the machine's parts could actually fit together, how much motor effort the motion would need, and whether energy adds up. They ran it on 343 flat linkage-style mechanisms and 100 3D ones. One model cut its picture error by about 37% compared to just guessing 'nothing moves,' yet its predicted motion still wasn't a physically possible machine. When the researchers repaired the geometry using CAD and inverse-kinematics tools, the shapes became valid, but the forces and motor effort were still more than five times off the engineering targets. Training one model with a more precise math method (RK4) raised its physics score from 52.65 to 64.30, showing that better-looking video and better physics are different problems.

AI video generators now make clips that look real, but nobody had a good way to check whether the things in them actually obey physics, like objects falling at the right speed or not passing through each other. The researchers built PVBench, a test with 600 carefully written prompts (30% featuring robot arms, humanoids, and four-legged robots) that scores videos on 46 different qualities. Instead of just asking another AI 'does this look right?', it uses specialized vision tools to measure real things like object position and orientation, true size, and whether energy and momentum add up. They checked that these automatic scores line up with human judgments and used the test to compare popular open-source and closed-source video models, which showed where each one breaks the rules of physics. The abstract does not report specific scores or which models did best.

Researchers taught a humanoid robot (the Unitree G1) to mix and match arm skills, like opening a cabinet with one hand while the other does something else, without having to show it every possible combination. Their system, called HS-MoDP, works like a team of specialists: each arm picks the right skill for the job from a shared pool, and the robot alternates between using its arms and walking to a new spot. To collect good training examples, they built G1Exo, a wearable exoskeleton that copies a person's arm joints directly onto the robot, which worked better than the usual VR headset method. With exoskeleton demonstrations, the robot's success at a full cabinet task jumped from 35% to 65%.

Researchers built a two-legged robot called Harpy that gets help from small propeller-like thrusters, similar to how baby chukar partridges flap their wings to run up steep slopes. They wrote a control program that decides, 500 times every second, how hard the legs should push on the ground and which way the thrusters should point, and they tested it on the real robot rather than just in a computer simulation. The robot trotted in place and also walked forward at an average of 0.1 meters per second (about a slow shuffle), and its leg joints stayed within 1 degree of where they were supposed to be. The control math took only 0.18 milliseconds to solve, far below the 2 millisecond limit, which shows the approach is fast enough to run on the robot in real time.

The researchers built HAF-VLA, a system that helps humanoid robots follow spoken or written instructions by planning their movements in steps instead of all at once. Rather than deciding what every joint should do in one shot, the robot first picks where to walk and look, then adjusts its waist, and only then plans what its arms and hands should do, with each step building on the last. This matters because humanoids have so many moving parts that a small error in walking or waist motion can cause the upper body to overcorrect wildly. The team started from an existing AI model that already worked on wheeled and fixed-base robots, adapted it to humanoids, and tested it on six real-world tasks. The paper's abstract says it significantly beat existing models, though the exact numbers are not given in the abstract.

Robots that follow spoken directions like 'walk past the couch, then turn left at the kitchen' have to remember what they've already seen, but their memory gets cluttered and they often don't make good use of it. The researchers found that simply nudging a robot to look back over its saved observations could rescue it from mistakes, so they built ReInsVLN, a add-on that works without any retraining. It shrinks the robot's memory by throwing out repetitive images while keeping the useful ones, and it reminds the robot at scheduled moments to review what it saw earlier, a bit like how people study with spaced reminders. On a standard test with unfamiliar buildings, this raised success rates by 8.48 and 3.37 percentage points over two existing navigation systems (reaching about 64%), while cutting memory use by up to 32% and startup delay by up to 22%.

Robots that mix legs and wheels often get lost in long, featureless hallways, because the laser scanner they use to track their position sees the same flat walls over and over and can't tell whether the robot has moved forward. The researchers built a system that also listens to the wheels, but it doesn't trust them blindly: a small neural network learned from the robot's own recent motions when the wheels are probably slipping or bouncing off the ground, and it adjusts how much the robot believes the wheels in each direction. They also taught the system to ignore laser data in directions where it provides no useful information. In tests, this cut position errors by 66.2% compared to a popular existing method (FAST-LIO2), and in one very bland corridor the robot ended just 0.198 meters off target, versus 7.531 meters for the old method.

Researchers built RoboMMT, a control system that lets walking robots (a four-legged robot and two humanoids) move in expressive, lifelike ways, like gesturing, facing someone, or pointing, without falling over. The problem is that fancy, personality-filled movements can push a balancing robot past its limits if the 'style' of the motion is designed separately from the physics of staying upright. To fix this, they trained a tracking program on a huge range of expressive styles so it learns to shift its weight and take small corrective steps while still copying the commanded motion accurately. Robots trained without that wide coverage lost their balance, lost accuracy, or both, and the new system worked on a real quadruped even when it was shoved hard, with no extra tuning after training in simulation. The paper doesn't give specific numeric scores in its abstract.

Robots often have to work safely even when they don't know key facts about themselves, like how heavy a payload is or how strong their motors are. Older safety methods assume the robot will never learn anything new, so they plan overly cautious moves, like a driver who never trusts they'll see the road better as they get closer. The researchers built a planning method called A-SLS that predicts how much the robot is guaranteed to learn as it moves and uses that to draw tighter, still-safe boundaries around where the robot could end up. They also made it run fast on a graphics chip (GPU), so it works in real time on a quadruped robot with 61 states, 8 unknown parameters, and 12 control inputs, and on a real Crazyflie drone that figured out an unknown property of itself mid-flight and stabilized.

Researchers built a control system that lets a humanoid robot figure out, on the fly, how heavy a load it is holding and then adjust its balance and movements to match. Think of how you instinctively lean differently when someone hands you a heavy backpack: the robot does the same thing by constantly estimating the weight and where it sits, then planning its whole-body motion around that information instead of just reacting after it starts to wobble. They also added a virtual reality setup so a human can steer the robot's hands and arms to do a job while the robot handles staying upright by itself. They tested this in simulation and on a real humanoid robot. The abstract doesn't report specific performance numbers, so I can't cite measured improvements.

Power lines that carry electricity to neighborhoods are being asked to handle more unpredictable demand from things like electric cars and heat pumps. The researchers built a math tool that answers a practical question: how much can demand grow beyond the forecast before the system's automatic controls (like solar inverters and the connection to the main grid) run out of room and the voltage goes out of safe range? Unlike earlier approaches that measured flexibility without considering how the controls actually behave, theirs accounts for the specific control setup and for how much communication is available between devices, and it can be solved quickly and exactly. They tested it on a realistic 240-node neighborhood power network (called Iowa-240) and showed that both how much control power you have and how your devices are wired to talk to each other change how much extra demand the grid can safely take. The abstract does not report specific numerical margins, so the headline result is the method and the finding that communication design matters, not a single number.

Robots trained to pick up objects or move around obstacles often learn several valid ways to do the same job, like going left or right around a box. But today's AI robot controllers pick between those options by random chance, so you can't tell the robot which way to go. The researchers built MOSS, which hides a 'which way to go' signal in the random starting noise the robot's AI begins with, and automatically pulls the options together when the choices are similar and pushes them apart where paths truly split. In tests on 6 simulated and 3 real-robot tasks, MOSS steered the robot to the chosen behavior up to 100% of the time, brought back rare behaviors over 90% of the time even when they made up only 10% of the training data, and beat the standard approach of labeling each behavior by 43.3 percentage points on real robots.

Robots often have to act safely while they're still figuring out things they don't know, like how heavy a payload is or how their own motors behave. Older safety-focused controllers assume the robot will never learn anything new, so they plan for the worst case and end up overly cautious. The researchers built a controller called A-SLS that plans around the fact that the robot will keep learning as it moves, which lets it draw tighter and still-guaranteed safety boundaries around where the robot could end up. They also made it run fast on a graphics chip (GPU), so it works in real time even on a quadruped robot with 61 states, 8 uncertain parameters, and 12 control inputs, and they showed a real Crazyflie drone learning an unknown dynamics parameter while flying and stabilizing itself.

Researchers built a control system that lets a humanoid robot figure out, in real time, how heavy the thing it's carrying is and how that weight changes its balance. The robot constantly plans its movements a short time into the future, and a software 'estimator' keeps updating the plan with the true weight and weight distribution of whatever it's holding, like a heavy tool or box. This matters because older approaches often ignored the extra weight and counted on the robot's reflexes to fix mistakes, which breaks down when the load is a big fraction of the robot's own weight. They also added a virtual reality setup so a person can steer the robot's arms and hands naturally while the robot handles staying upright on its own, and they tested it in both simulation and on a real humanoid. The abstract does not report specific performance numbers, so the exact size of the improvement isn't stated here.

The researchers built a math tool that answers a practical question for a neighborhood power grid: how much can people's electricity use grow or swing unpredictably before the grid's controls run out of room to keep voltages safe? They treat the grid's batteries, solar inverters, and connection to the main grid as a team that automatically shares the work of absorbing surprises, and they calculate the exact biggest surprise the team can handle. Unlike older methods that ignore how the controllers actually behave or how well they can talk to each other, this one builds in both, and it can find the best way to split the work using fast, reliable computer calculations. They tested it on a realistic 240-node feeder (the Iowa-240 model) and showed that having more controllable equipment and better communication links directly increases how much uncertainty the grid can safely handle. The abstract does not report specific percentage gains, so the exact size of the improvement isn't stated here.

Modern robot brains can often learn several valid ways to do the same job, like grabbing a cup by the handle or by the rim, but today they just pick one at random each time, and you can't tell them which to use. The researchers built a method called MOSS that lets you choose. It works because these robots start from a blob of random noise and gradually turn it into an action, and MOSS sets up different starting zones in that noise for each style of doing the task, then adjusts how far apart those zones are depending on how different the choices really are at that moment. In 6 simulated and 3 real-robot tasks, MOSS steered the robot to the requested style up to 100% of the time while still completing the task. It even recovered a rare style that made up only 10% of the training data over 90% of the time, and it beat the standard approach of telling the robot which mode to use by 43.3 percentage points on real robots.

Researchers built a new robot control system called A-SLS that helps a robot stay safe while it's still figuring out things it doesn't know, like how heavy it is or how its motors behave. Older methods played it overly safe because they assumed the robot would never learn anything new during a task, but A-SLS plans around the fact that the robot will get smarter as it goes, which lets it use much tighter, more realistic safety margins. They sped up the math by running it on a graphics card (GPU), so it works in real time even on a four-legged robot with 61 states, 8 unknown parameters, and 12 motor inputs. They also tested it on a real Crazyflie drone, which learned an unknown physical property of itself mid-flight and used that knowledge to stabilize.

The researchers built a control system that lets a humanoid robot figure out, while it moves, how heavy the thing it's carrying or holding actually is and how that weight is distributed. It does this by pairing a 'planner' that constantly predicts the robot's future movements and balance with a 'tracker' that estimates the load's weight and center of mass in real time, then feeds those estimates back into the planner so the robot's muscle-like motor commands are accurate from the start instead of fixing mistakes after the fact. A human operator wearing a VR headset can direct the robot's arms and hands for a task without worrying about balance or payload, because the robot handles staying upright on its own. The abstract says the approach was tested in simulation and on a real humanoid robot, but it does not give specific numbers, so we can't say how large the improvement was.

The researchers built a math tool that answers a practical question about the electric grid in your neighborhood: how much can people's power demand grow or swing unpredictably before the system starts breaking its limits? Their method accounts for how the grid is actually controlled, including solar panels and batteries that adjust their output, the connection to the main grid, and local devices that steer voltage on their own, and for the fact that these parts can only coordinate over limited communication links. Instead of relying on slow trial-and-error simulations, they turned the problem into a type of math puzzle (a convex optimization) that computers can solve quickly and exactly, producing one number, a 'flexibility margin,' and the best way to share the work among the controllable devices. They tested it on a realistic 240-node grid model (Iowa-240) and showed that both how much control power the system has and how its devices are wired to communicate directly change how much uncertainty the grid can handle. The paper does not report a single headline number; its contribution is the method and the demonstration of these trade-offs.

Robots trained by watching demonstrations often learn several valid ways to do the same job, like grabbing a cup from the left or the right, but the robot picks one at random, so you can't tell it which to use. The researchers built MOSS, which hides a 'which way to do it' signal in the random starting noise the robot's AI begins from, so choosing the starting point lets you choose the behavior. To make this work, MOSS also estimates how different the possible behaviors are at each moment, pulling the options together when they look alike and pushing them apart at real decision points. Across 6 simulated and 3 real-world tasks it steered the robot to the requested behavior up to 100% of the time, brought back a rare behavior over 90% of the time even when only 10% of the training examples showed it, and beat the standard approach of simply telling the robot which mode to use by 43.3 points on real robots.

Some speakers don't have a cone — instead, a small motor called an exciter shakes a flat panel (like a sheet of wood or glass) so the whole panel makes sound. The researchers tested three different types of these exciters, measuring how evenly they play different pitches, and how much they add unwanted extra tones that muddy the sound (called distortion). They found that exciters of the exact same model, bought from the same maker, behaved very differently from one another, so manufacturing consistency is poor. The paper doesn't report one headline number, but the unit-to-unit variation showed up in every measurement they took. They also suggest a simple fix: run a quick electrical test on each exciter and pair up ones that behave alike when using several on one panel.

When a robot learns to navigate by copying human examples, it hits a problem: if a person could walk around an obstacle on either the left or the right, the robot learns the average of both and drives straight into it. The researchers built a two-level robot brain that avoids this by first working out the possible routes from what the robot sees (like 'go left of the box' or 'go right of the box'), then learning from the examples which route to pick and how to follow it. In simulation it reached its goal more than 95% of the time, even in layouts it had never seen, while four standard learning methods managed at most 43% on familiar layouts and 20% on new ones. The brain trained in simulation also worked on a real two-legged LimX Tron 1 robot.

The researchers built a math tool that answers a simple question about a neighborhood power line: how much can electricity demand grow or swing unpredictably before the system runs out of ways to keep the lights on and the voltage safe? Their method accounts for who is doing the controlling (batteries and solar inverters, local voltage-regulating gadgets, and power coming in from the main grid) and how much those devices can actually talk to each other. They turned a hard problem into one that computers can solve quickly and reliably, and tested it on a realistic 240-house model of an Iowa power feeder. The abstract doesn't give specific headline numbers, but the tests showed that both how much control hardware you install and how it is wired together by communication links change how much extra demand the grid can safely handle.

The researchers taught a simulated four-legged robot to spot trouble before it happens, instead of reacting only after it has already stumbled. They trained a group of 'safety predictors' that look at the robot's current state and guess whether it will keep walking safely over the next several moments, then paired them with a built-in correction that gently nudges the robot's moves toward safer ones, a bit like a driving instructor tapping the brake. Past approaches mostly judged safety one instant at a time, but real falls usually build up over several steps when the robot hits slippery ground, gets shoved, or has noisy motors. In simulation, this approach cut catastrophic failures under motor noise, pushes, and unfamiliar terrain while keeping walking performance competitive; the abstract does not give specific numbers, so exact gains are not stated here.

When you teach a robot by showing it how to do a task, even the 'good' demonstrations are messy, with hesitations, wrong turns, and fumbled attempts, and most training methods either copy all of it or throw out anything imperfect. These researchers built a method called GR-BC that maps out all the steps the robot has ever taken as a kind of road map, then works backward from the finished task to figure out which moves actually got the robot closer to success. Moves that helped get more weight during training, while detours and backward steps get less, even when they appear inside a successful run, and human corrections after a mistake become useful recovery paths. Tested on four precise manipulation tasks and three different AI robot models, the method improved on standard training and reached 91% success after a few rounds of retraining, without needing a separate scoring system to judge the robot's progress.

Robot dogs and humanoids trained in simulation often stumble in the real world when they hit slippery floors, rough ground, or carry extra weight. The researchers built TEMPO, a method that lets a robot keep teaching itself while it walks, without any new rewards, human help, or powerful computers. It works by having the robot's built-in 'judge' (which scores how well it's doing) avoid being overconfident, and by having the robot remember and practice the situations where it did worst. In simulated tests on three Unitree robots (Go1, Go2, G1), it improved performance by up to 80%, and it also helped a real Unitree Go2 carrying an extra weight on its leg, all computed on the robot itself.

Imagine you can only track a few dots on a squishy object, like a piece of cloth, a dog, or a soft toy, and you want to guess how the whole thing moves. The standard method just smoothly fills in the gaps, which works okay but misses details. Earlier AI fixes only worked on shapes similar to what they were trained on, partly because the size of the 'correction' needed varies hugely between object types (more than 10x) and shrinks as you track more dots, so the AI got confused. The researchers, Su, Ke, and Liu, built a model called Cepheid that separates the shape of the correction from its size, learns the shape once, and then estimates the size from what it can actually see. The result is one model that beat the standard smooth-fill method on every type of object they tested, including cloth and legged bodies it had never seen, with no skeletons or hand-matched points needed. The paper does not report specific numbers in its abstract.

The researchers built FlowAvatar, a system that lets someone wearing a Meta Quest Pro headset see a lifelike, full-body digital version of themselves that moves in real time, including their arms, hands, face, and eye direction. Normally a headset only knows where your head and hands are, so the system uses AI to guess how the rest of your body is moving, and it does this smoothly enough to beat other methods on a standard motion test (called AMASS) for how steady the movement looks over time. Earlier work tested either good body tracking or personalized looks separately, and always with expensive lab equipment, but this is the first to combine everything on a regular consumer headset. In two small studies with 12 and 10 people, better tracking made movement feel more natural, but people only felt truly 'embodied' in their avatar (like it was really them) when good tracking and a personalized look were combined.

Researchers built FreeBrush, a system that figures out which teeth you're brushing, and for how long, just by listening to the electric toothbrush's own motor. When the brush head presses against different parts of your mouth, it meets different resistance, which changes the electrical current the motor draws and how far the brush head moves. By reading those tiny changes, FreeBrush correctly identified which of 16 tooth surfaces was being brushed 92.8% of the time and estimated brushing time with 92.0% accuracy across 18 test users. Earlier tracking systems needed extra add-on sensors like cameras, motion trackers, or microphones, while FreeBrush works on an off-the-shelf toothbrush with no added hardware and can run on small, low-power devices.

Researchers built Robot-WATCHDOG, a system that tells when a robot has messed up a task, such as dropping an object or putting it in the wrong place, even though it was never shown examples of failures. Instead of watching raw camera images, it turns each scene into a simple map of objects and how they relate to each other over time, then checks whether what's happening still looks like the successful demonstrations it learned from. They tried two ways of scoring this, a simple math-based method called TPC and a neural network called GnnT, and both beat image-based failure detectors, especially at catching mistakes about meaning or interactions between objects. TPC was the strongest, with the best overall scores and very consistent results across ten random runs on six tasks. The paper doesn't give exact scores in its summary, so the strength of the win is described only as 'outperforming' and 'best in AUPR and MCC'.

Researchers built ATHLETE, a system that taught a humanoid robot to play tennis without needing expensive motion-capture recordings of tennis players. Instead, they mixed general walking and running data with motions pulled from ordinary tennis videos, then used a technique called Trajectory-Guided Motion Matching to stitch these into many realistic ways of moving to hit a ball. The robot practiced in simulation until it could react to where it and the ball were, with no pre-made motion script needed while playing. On a real robot it hit 90% of forehand shots and 86.67% of backhand shots, and it could keep up multi-shot rallies with human players.

Researchers built Robot-WATCHDOG, a system that spots when a robot is messing up a task, such as dropping an object or putting it in the wrong place, even though it was only ever shown examples of the task done correctly. Instead of staring at raw camera images, it turns each scene into a simple map of objects and how they relate to each other as they move over time. They tested two ways of scoring whether something looks wrong, one that compares the current motion to normal motion using simple math (called TPC) and one that uses a neural network to predict what should happen next (called GnnT). Both beat detectors that rely on images, especially at catching mistakes in meaning or interaction (like grabbing the wrong object), and the simple-math version (TPC) did best overall and gave steady results across ten different training runs. The paper's abstract doesn't give exact percentage gains, but it reports the lead on the AUPR and MCC scores across six tasks.

Researchers built a system called ATHLETE that taught a humanoid robot to play tennis without needing expensive motion-capture recordings of tennis players. Instead, they mixed everyday walking-and-running data with swings pulled from ordinary tennis videos, then used a method called Trajectory-Guided Motion Matching to stitch these pieces together into many different realistic movement plans for reaching and hitting balls. A computer-simulated robot learned from those plans and then practiced on its own, and the final version only needs to 'see' where the robot and ball are to decide what to do. On a real humanoid robot, it hit 90% of forehand shots and 86.67% of backhand shots, and it could keep up multi-shot rallies with human players.

Normally, a heat engine (like a car engine) needs a hot spot and a cold spot that stay put, and it only works where you've built them. These researchers flipped that idea: they made a robot that moves through a space where the temperature changes from warm to cool, carrying small gas-filled capsules that can snap between two stable shapes. As the robot hauls the capsules back and forth across the temperature gradient, the capsules heat up, snap quickly into a new energy state, cool down, and snap back, which means the robot itself acts as a moving heat engine that collects and stores energy. They also worked out the best paths for the robot to travel, balancing the energy it burns moving against the energy it gathers, like an animal deciding how far to roam for food. The abstract doesn't give specific performance numbers, so how much energy the system actually harvests is not stated here.

The researchers built ME-World, an AI that can generate realistic first-person videos for several people or robots acting in the same room at once, so that what one agent does shows up correctly in what the others see. Earlier systems mostly handled one agent at a time, or only understood rough commands like 'walk forward' or 'turn the camera.' ME-World handles detailed actions like picking something up or handing it over by generating all the agents' views together, telling each view where every agent is looking, and keeping a shared memory of the room. The team also created new scores to check whether the room, any changes to objects, and each person's appearance stay consistent across views, and the paper reports that ME-World beats existing methods on those scores, on following the actions given to it, and on video quality. The abstract doesn't give specific numbers, so exact margins aren't available here.

When a humanoid robot's brain tells its body to move, the body often doesn't do exactly what was asked, because balance, physics, and contact with objects get in the way. The researchers built a system called HWAM that doesn't just predict what the robot should do, but also predicts how the robot's body will actually end up moving, and it learns from both at the same time. Earlier systems tried to guess the future from camera views alone, so they struggled to connect an action to what really happened. On a real LimX OLI humanoid, HWAM beat the other methods on all three tasks, including picking up candy, where it succeeded 70.6% of the time compared with 43.3% for the previous best, Fast-WAM.

Researchers took two four-legged robots, ANYmal-D and Magnecko, to a moon-like test site called LUNA in 2025 and had them walk across loose, powdery fake moon soil and crater-shaped terrain while recording navigation data under harsh lighting. The robots could make it across, but their feet sank and slipped in the soil, kicked up dust, and their cameras got confused by blinding bright spots, deep shadows, and flat, featureless ground. The paper doesn't report a single headline number; instead it is a field report of what went wrong and why, which is different from earlier lab tests because it shows how these robots behave in a realistic, messy setting rather than a controlled one.

Researchers built VioLA, a system that teaches humanoid robots to follow spoken or written instructions by learning mostly from videos and recordings of people moving, instead of from scarce robot demonstrations. The key trick is that the AI doesn't try to control every robot joint directly; instead it picks a kind of 'motion idea' that is shared between humans and robots, and separate pre-trained controllers turn that idea into actual robot movement. Because human and robot motion can be translated into the same 'language,' 93.2% of their 140.6 million training frames came from humans. On a real robot, VioLA followed walking and movement instructions it had never been specifically trained on with 100% success, while competing systems GR00T N1.7 and Ψ0 managed only 16.7% and 0%, and it also hit 88.6% success on hand-and-arm tasks without extra task-specific training.

Researchers found that when you train robots in simulation using over a million virtual practice runs at once, most of that practice is wasted because the robot either already knows how to do the task or isn't ready to attempt it yet. They built a simple tool called Success Guided Sampling (SGS) that watches where the robot is succeeding and steers practice toward the situations right at the edge of its ability, like a coach who skips the drills you've mastered and the ones that are impossible. With SGS, training across up to 1,048,576 (2^20) parallel simulations solved hard problems that earlier methods couldn't, including a four-legged robot walking across varied terrain and precise assembly tasks where parts must be fit together. The team then took the learned assembly skills, trained the robot to work from regular camera images, and ran them on real robot hardware without any extra real-world training.

Researchers wanted to know if four-legged robot dogs could one day do dangerous, tiring jobs on rooftops, like helping install roofing. They built a tilting test roof and put a store-bought robot dog, the Unitree Go2, through its paces at different slopes. The robot's round, ball-shaped feet turned out to be a poor match for roofs: the steeper the slope, the more the feet slid, and the sliding got worse much faster than the slope increased. The robot could only get up and lie down on very gentle slopes, and by 25 degrees (a pretty ordinary roof pitch) it was already having serious failures, like falling over. No one had tested walking robots on roofs this carefully before, so this gives future researchers a starting point to measure improvements against.

Normally, a heat engine (like a car engine) needs a hot spot and a cold spot that stay in place, and it only works where you set them up. These researchers flipped that idea around: they built a robot-and-capsule system where the robot moves gas-filled capsules back and forth across a temperature gradient, so the capsules do the 'engine cycle' by traveling between warm and cool areas. The capsules are special because they can snap between two stable energy states, and those quick snaps let the system capture and store energy as it moves. The abstract does not report specific performance numbers, but the team used a model to find the best paths for the robot to travel, balancing the energy it spends moving against the energy it harvests, much like an animal searching for food.

The researchers built ME-World, an AI system that can generate realistic first-person videos for several characters or robots at the same time, all acting in the same shared world. Earlier systems either handled just one agent or only understood simple commands like 'walk forward' or 'turn the camera,' so they struggled when two agents did something detailed together, like one handing an object to another. ME-World solves this by creating all the agents' views in a single combined process, telling each view where everyone else is looking, and giving the system a shared memory of the room so objects stay where they belong. The abstract says it beat existing methods at keeping the world consistent between views, following actions accurately, keeping each agent looking like the same agent, and producing good video quality, but it does not give specific numbers for these gains.

Some robot joints can be made squishier or stiffer on demand, like a muscle that can tense up or relax, by pulling on two springs against each other. Controlling them is hard because the math is tangled, the springs aren't perfectly known, and some of what the robot needs to know can't be measured directly. The researchers built a computer-simulated version of one such joint with a clever spring shape, then paired it with a three-layer control system: one layer guesses the hidden measurements, one untangles the math, and one corrects leftover errors. In simulation, the joint ended up within about 0.00003 radians (a tiny fraction of a degree) of its target angle, and its stiffness landed within 3.07 of a 50-unit target, with tests showing what each layer contributes when the springs' properties change.

The researchers designed a brain-inspired computer system that combines information from several sensors, like the cameras and radar on a self-driving car, using tiny electronic parts called memristors that work a bit like brain cells and can both learn and forget. Instead of always processing sensor data the same way, their system changes how much data it keeps depending on the driving situation, such as a simple highway versus a busy intersection. In computer simulations of ten driving scenarios from a real dataset called NuScenes, this approach threw away 61.5% of the sensor information it would normally keep, yet its answers matched the expected car responses more often (about 61.2% of the time versus roughly 55% for the fixed, maximum-detail setup). The key difference from earlier work is that adaptability is built into every step of the process, from squeezing the data to deciding which sensors to trust, rather than using one fixed setting for everything.

Most rehab robots move your arm along a pre-set path, but they don't check whether your muscles are actually working the way they should to help you recover. The researchers built an AI model (a type of transformer, similar to the tech behind chatbots) that reads electrical signals from a person's muscles and instantly decides how hard the rehab robot should push or resist to get those muscles firing as intended. They trained it on data from 16 healthy volunteers doing 15 different arm-force tasks, and it predicted the right force pattern with less than 8% error, even for new people and new tasks. In a first live test, participants hit their target muscle activation with only about 15% accumulated error, and the model can be tuned to a new person fast enough to use during a single therapy session.

The authors wrote a book that teaches engineers how to build flight controllers that can learn and adapt on their own, using artificial neural networks (computer systems loosely inspired by the brain). The first half covers controllers built on a known mathematical model of the vehicle, with proofs that they stay stable while learning. The second half covers controllers that learn by trial and error (reinforcement learning) without needing a model at all. They test these ideas in simulation on quadcopters, a fixed-wing research airplane, satellites, and hypersonic vehicles, including cases with broken actuators, limited control inputs, and wind gusts. As a book, it does not report one headline number, and its value is in putting stability-proven neural control and modern reinforcement learning together in one place for flight systems.

The researchers built a squishy, elephant-trunk-like robot shaped like a corkscrew (a trimmed helicoid) that bends and twists in extreme ways, which makes it very hard to control. They taught a computer to predict how the whole body of the robot moves by studying data from the real robot, then used that prediction to plan its movements a split second ahead. This method held the robot's shape about 10 times more accurately than standard simple methods, and it let a person guide the robot to shape itself section by section and balance a tennis ball on it for over 25 seconds. A different AI approach, which learned by trial and error on the real robot for 12 hours, couldn't balance the ball at all.

Researchers tested when a fancy 'sliding mode' controller (a way of keeping a camera image steady) actually beats simpler methods like a basic smoothing filter or a standard PID controller. They found it only wins when the shaking is faster than the motor can physically move, so the motor's speed limit becomes the bottleneck. They checked this on 12 handheld video clips and on a simulated motorized pan-tilt-zoom camera, where the simpler PID method actually beat the fancy one by 5.85 degrees in the worst-case pointing error when the motor wasn't maxed out. When they simulated slower motors so the limit kicked in, the fancy controller won in the worst case, and the common 100 degrees-per-second default setting turned out to sit right at the crossover point.

Small satellites need software that keeps them pointed the right way, but that software is usually written for one specific satellite, so changing a sensor, motor, or mission means rewriting lots of code. The researchers built a free, open-source Python toolkit that works like building blocks: you swap in different sensors, steering motors, and control methods just by editing a settings file. It includes a built-in space simulator with realistic noise, errors, and disturbances, and they tested it on three different CubeSat designs, including cases where parts fail. They also ran the same code on a Raspberry Pi, showed that adapting a published control method to a new motor setup took fewer than five lines of changes, and used the toolkit as the basis for flight software on a real Earth-observing CubeSat.

Researchers designed a robotic finger that moves its joints using cables (like tendons in your hand), with the motors tucked away in the palm and forearm so the hand stays human-sized. Usually engineers pick the cable paths first and then check if the finger is strong and fast enough, but fixing one often ruins the other. This team instead designed the cable routes, pulley sizes, and motors together, aiming to make the finger's weakest position as strong as possible. Their four-joint finger uses one more cable than it has joints, can deliver 88-100% of the force needed across eight different finger poses, and is predicted to flex and extend at least 5 times per second, though real-world tests came in up to 24.5% off the predictions because of friction and energy losses they didn't model.

Soft robots are bendy machines made of rubbery materials that move when air is pumped into them. The trouble is that computer programs can dream up great designs that nobody can actually build, while buildable designs usually limit where the air-powered parts go or need someone to glue pieces together by hand. These researchers built a software tool that designs a soft robotic arm, figures out where to put its air-powered muscles, and works out how to control it, all at once, so the arm can trace a chosen path with its tip. They then 3D printed the arms in a single go, with the air chambers already built in and no assembly, and the real arms moved the way the computer predicted. The paper says the arms reproduced simulated behaviour but gives no specific accuracy numbers in the summary, so the main result is that a design can go straight from computer to printer to working robot.

Pipelines that carry gasoline, diesel, and other fuels through one long pipe have to send them in separate back-to-back batches, and planning exactly when and how fast to pump each batch is a brutally hard puzzle. The researchers built an AI planner that learns by trial and error (a type of reinforcement learning) and gave it two separate 'brains': one decides how long to run each pumping step, and the other decides how fast to pump. Splitting the job this way keeps the two decisions from confusing each other during training, which was a problem for earlier single-brain approaches. Tested on a real pipeline in China, it produced delivery schedules close to the best possible answer from a standard math solver (Gurobi), while keeping flow rates steadier and finding solutions much faster. The abstract does not give exact figures for the speedup or accuracy gap.

Buildings are often heated by hot water flowing through radiators, and controlling them well is tricky because the math behind how heat moves and how water splits between rooms is curved and tangled, not a simple straight-line relationship. The researchers used a mathematical trick called Koopman theory to rewrite this messy system as a much simpler 'bilinear' model, one that behaves almost like a straight-line system but is still exact in theory. They plugged this model into a planning-ahead controller (called model predictive control) and tested it on a simulated five-story building with 20 rooms. It kept rooms comfortable and saved energy nearly as well as a full, hard-to-compute nonlinear controller, but solved faster, and it beat controllers that used simpler straight-line approximations of the building.

The researchers built KlaskTron, an open-source table-top robot that plays a two-player air-hockey-style game (like the tabletop game Klask), where each player uses a magnet-driven peg to knock a ball into the other's goal. They paired it with KlaskTron-IL, a big collection of examples for teaching robots by imitation: 80,000 moments of real human play recorded on the physical robot, 320,000 more made by mirroring that data, and up to 5 million moments from a computer-trained expert player. Testing common imitation methods on it revealed three ways they break down in fast, bumpy, head-to-head situations: copying humans (behavior cloning) stops improving no matter how much data you add, GAIL (a method where a 'judge' network learns to tell human play from the robot's play) learns a judge that makes sense (it correctly ranks how close the peg is to the ball) but gives such faint feedback (a score spread under 0.1) that it barely helps learning, and mixing human-copying with reward signals gives uneven results. Because the simulator is matched to the real robot, the best copy-the-human policy ran on the physical robot with no retraining, as long as its speed commands stayed within ±0.2 m/s.

Researchers built a safety filter that sits between a self-driving race car's planner and its steering and throttle, stepping in only when the car is about to crash. Older versions of this idea needed engineers to hand-write the car's physics, the 'safe zone' rules, and a backup driver. This team taught a computer to learn all three from driving data. They also taught it that a spot only counts as safe if the car could still dodge the obstacle using its real steering and braking limits, which matters more the faster you go. In tests on 200 new race layouts, it eliminated all 12 crashes without hurting the success rate, ran over 100 times per second on a single CPU core, and kept the car within its actuator limits on every run, versus 53.38% for a competing learned approach.

Regular brain-scanning MRI machines are extremely loud, which can make people anxious, make them move around, and even trigger the hearing parts of the brain so that the scan gets muddied. A quieter method called Looping Star already exists, but it collects its data in flat, stacked slices that overlap in the middle and leave gaps around the edges, so the pictures get blurry or streaky when you want fast scans. The researchers built a new version called Looping Kooshball (named for the spiky, ball-shaped toy) that sweeps through all three dimensions at once, so it fills in the picture more evenly. They tested it with computer simulations, sound measurements inside the scanner, scans of a test object, and early brain experiments where people did visual and movement tasks, aiming to show it cuts the streaky errors and spots brain activity better without losing the near-silent operation. The abstract describes what was tested but does not report specific numbers, so exact results on how much better it performs are not given here.

Neighborhood power grids now rely on small electronic boxes called inverters (the kind that connect solar panels to the grid) to keep each home's voltage from drifting too high or too low. The researchers built a math-based safety check that proves these voltage controllers will stay within safe limits even when hackers tamper with the sensors that measure voltage or with the signals that tell the inverters how much power to inject. Unlike earlier work that only checked whether the controller's own internal settings stayed stable, this method also guarantees that the actual power each inverter pushes out and the actual voltage each customer sees stay within their limits, even when attacks corrupt the output. They turned the whole test into a standard math problem a computer can solve and demonstrated it in simulation on a five-customer network based on a well-known European benchmark grid; the paper does not report real-world hardware tests.

Researchers built MUSBRIC, a kit of artificial muscles that snap onto ordinary LEGO pieces, so anyone can build a robot with muscles and bones the way you'd build a LEGO set. Each 'muscle brick' is a fabric-wrapped tube that stretches out when filled with air, and the team measured how these muscles behave and fed that into a computer simulator so they could test designs virtually first. They used the bricks to build an elbow joint, a hand that grips objects gently, and a four-legged walking robot, and they tested 15 different leg designs in both real life and simulation to see how small changes in where the muscles attach affect movement. Unlike earlier muscle-powered robots, which usually had to be custom-fabricated every time a design changed, these parts can be pulled apart and reassembled in new shapes.

Regular brain-scanning MRI machines (the kind used to watch which parts of your brain light up) are extremely loud because they flip their magnets on and off at top speed, and that racket can make people anxious, make them move, and even trigger the brain's hearing areas, which messes up the results. A quieter technique called Looping Star already exists, but it collects its data in flat 'slices' that all cross in the middle, so it captures plenty of detail about big, blurry features and gets sparse, patchy coverage of fine detail. The researchers built a new version called Looping Kooshball (named after the spiky rubber ball) that sweeps through all three dimensions in every pass, so the scanner gathers more evenly spread information. They tested it with computer simulations, sound measurements inside the scanner, scans of test objects, and early brain scans during a visual-motor task, aiming to show it cuts image-blurring errors and spots brain activity better while staying nearly silent. The abstract doesn't give specific numbers, so exact gains over the older method aren't stated.

The researchers designed a control system that lets a line of self-driving vehicles follow each other closely and safely, even when the vehicles have different engine power and braking strength. Each vehicle only needs to measure the distance to the car in front and that car's speed, with no heavy computing and no need to know exact details about its own weight or engine. The team proved mathematically that cars never crash, never ask for more power or braking than they have, and that each car's speed stays close to the speed of the car ahead, with errors that don't pile up no matter how long the line is. Simulations with 2 to 100 followers confirmed this, which is different from earlier methods where small slowdowns often grew into big problems down the line.

Researchers built a tiny conveyor belt that runs along the inside of a snake-like, bendy robot arm only 9 millimeters wide (about the width of a pencil). Instead of fixing tools or magnets in one spot, the belt can slide them to a new position along the arm while the robot is working, and up to three belts can fit inside one robot. As a test, they attached magnets to two belts so two robots could grab onto each other, then moved the grab points around to make the pair stiffer or floppier on demand. They found the stiffness follows a predictable math rule (it changes with the cube of the grab-point location) and gets higher when more magnets connect, and that the belts need the same or less pulling force than the robot's own steering cables.

Researchers built MUSBRIC, a kit of air-powered artificial muscles that snap onto ordinary LEGO pieces, so you can assemble a robot with muscles and a skeleton like an animal's, take it apart, and rebuild it in a new shape. Normally, testing a new muscle layout on this kind of robot means building a whole new one from scratch. Here, they paired the kit with a computer simulator, tested 15 different leg designs in both real hardware and simulation, and showed the two matched up well enough to explore designs on screen first. They also built a working elbow that bends under load, a hand that grips objects gently, and a four-legged robot made of four of those legs that actually walks.

Regular brain-scanning MRI machines are extremely loud, which can make patients anxious, make them move around, and even trigger brain activity that muddies the results. The researchers built on a nearly silent scanning method called Looping Star, which gathers data in flat, pancake-like slices that overlap in the middle, so it collects plenty of detail about big shapes but not enough about fine details at the edges. Their new method, Looping Kooshball, sweeps through all three dimensions in every pass, like the spikes of a fuzzy ball, so the scanner fills in its picture much more evenly. They tested it with computer simulations, in-scanner noise measurements, test objects, and early brain-activity experiments where people did visual and motor tasks. The abstract describes these comparisons but does not report specific numbers, so exactly how much better it performs isn't stated here.

The researchers designed a driving controller for convoys of self-driving vehicles (called platoons) where each car only needs to measure the distance and speed of the car directly ahead. Real vehicles can't brake or accelerate infinitely hard, and they usually brake harder than they speed up, so the controller keeps a safety gap based on stopping distance and lets the gap loosen temporarily when a car is maxed out on acceleration. They mathematically proved that no collisions happen, the cars never ask for more power or braking than they have, and each car's speed stays close to the one in front of it, with the error not growing as more cars join. Simulations with anywhere from 2 to 100 following vehicles backed this up, even with disturbances and weak actuators, and unlike earlier approaches it needs no heavy online calculations and no exact knowledge of each vehicle's specs.

Researchers built a tiny conveyor belt that runs along the inside of a snake-like bendy robot, about 9 mm wide (roughly the width of a pencil), so that tools or parts attached to the belt can slide to any spot along the robot's body while it's working. Normally, anything mounted on a robot like this is stuck in one place. To show it off, they attached small magnets to two belts so two of these robots could link up with each other, and could change where and how many times they connected mid-operation. They found that moving the magnets changes how stiff the linked robots feel in a predictable way (stiffness drops sharply as the connection moves farther out, following an inverse-cubic pattern), and that adding more connection points makes the pair stiffer. The belts also take about the same or less pulling force to run than the wires that bend the robot, so they don't need extra-powerful motors.

Researchers built MUSBRIC, a kit of artificial muscles that snap onto ordinary LEGO pieces, so anyone can build a robot with muscles and bones like a human body instead of building each new design from scratch. Each muscle is a fiber-wrapped rubber tube that stretches when filled with air, fitted with LEGO-compatible ends that act like plug-and-play bricks. They used the bricks to build an elbow that bends and straightens under load, a robotic hand that grips objects gently, and a four-legged robot that walks. They also made a computer simulator that matches the real hardware, and they tested 15 different leg designs in both the simulator and real life to see which attachment angles and positions worked best. The team says the hardware designs and simulation code will be released for free soon.

Regular brain-scanning MRI machines for watching brain activity are extremely loud, which can make patients anxious, make them move around, and even trigger the hearing parts of the brain so the results get muddied. A quieter method called Looping Star already exists, but it collects its picture data in flat, pancake-like slices that all cross in the middle, so it captures the center of the image well but leaves gaps toward the edges. The researchers built a new version called Looping Kooshball, named for the spiky toy ball, where each scan pass sweeps through all three dimensions instead of one flat slice, which fills in those gaps more evenly while keeping the scanner nearly silent. They tested it with computer simulations, sound measurements inside the scanner, scans of a test object, and early brain scans of people doing a visual-motor task. The abstract describes what they compared but doesn't report exact numbers, so the size of the improvement can't be stated here.

The researchers designed a control system for convoys of self-driving vehicles, like a line of trucks, where each vehicle only watches the distance and speed of the one directly ahead of it. The tricky part is that real vehicles can't brake or speed up as hard as a computer might ask, and different vehicles have different limits. Their controller keeps a safe gap based on how far a vehicle needs to stop, and it loosens the gap requirement when a vehicle's engine is maxed out so it doesn't demand impossible acceleration. They proved mathematically that no vehicle crashes and that no vehicle exceeds its limits, and that speed errors don't pile up down the line, so the 100th vehicle is no worse off than the 2nd, which they checked in simulations with 2 to 100 followers.

Researchers built a tiny conveyor belt that runs inside a snake-like robot arm just 9 mm wide, letting them slide useful parts, like small magnets, up and down the robot's body while it is working. They fit up to three of these belts in one robot, and moving the belts took the same or less force than the wires that bend the robot. To show it off, they put magnets on two belts so two robots could stick together at spots they could change on the fly. They found that the pair gets stiffer or looser in a predictable way (stiffness drops with the cube of how far from the base the robots connect) and that adding more connection points makes the pair stiffer. Before this, parts like magnets or sensors were stuck in one place on the robot, so changing a job meant building a new robot.

The researchers built a software system that figures out exactly how a bendy, snake-like robot arm is positioned in space. The arm they studied has a regular rigid section attached to a flexible, cable-driven tip, the kind of design that could fold up small for launch and be gentler around fragile satellites. The system combines two imperfect sources of information, joint sensors on the rigid part and camera images of the flexible tip, and treats the problem like solving a puzzle where it looks for the most likely arm position given all the noisy clues. In computer simulations using realistic synthetic camera images, they report that the method tracked the arm accurately and ran fast enough to be practical, though the abstract gives no specific numbers and the work has not yet been tested on real hardware.

Big robot arms that lift heavy things, like 100-kilogram tools, are tricky to design because the arm's shape, the motors that move it, and the weight of those motors all affect each other: heavier motors need a stronger arm, which needs heavier motors, and so on. The researchers built a computer method that designs the arm shape and picks real motors, gearboxes, and screws together, repeating the process until the weights settle into a consistent answer, which took just three rounds for every design. It found eight good designs that all reached 12 required positions while carrying the 100-kg load. They also showed that the usual shortcut of picking motors in one pass can throw off hardware weight by up to 2.13%, cost by 10.2%, and energy use by 9.4%.

Most electric motors push and pull with magnets, but this team built one that spins using electric charge instead: metal plates around the edge of a wheel (the rotor) get charged up by nearby electrodes, and the wheel is dragged around by those charges. Earlier versions of this kind of motor used a single solid material for the spinning part, which limited how well they could be tuned. The researchers instead connected separate metal vanes with ordinary electronic parts (like resistors and capacitors), letting them copy a trick used in big magnetic motors called a 'deep bar' rotor that keeps the motor pulling hard at many different speeds, not just one. They designed, analyzed, and built a working desk-sized (macro-scale) version and showed it delivers better turning force across a wide range of speeds. The abstract does not report specific torque or efficiency numbers, so the exact size of the improvement is not stated.

Researchers built a small, cheap airplane-style drone that can chase down and hit other drones on its own, with no human steering it. Its "brain" is a neural network that was trained through trial and error in a computer simulation, then loaded onto a real aircraft. It looks at the target through a single camera and decides directly how to move its control surfaces and motor. In simulation it beat two traditional chase-and-aim programs in most situations, and in real flights it successfully intercepted maneuvering airplane targets. The abstract doesn't give specific numbers like hit rates, so the main result is that it worked both in simulation and in the real world. What's new is that fixed-wing interceptors, which can fly farther and higher than the quadcopters used so far, have until now been flown by hand, and this is a working step toward automating them.

Imagine a robot arm on a satellite where the last section is a bendy, tendon-driven tentacle instead of a stiff metal rod. The trouble is that a floppy tentacle is hard to track, because it doesn't have a fixed shape the way a rigid arm does. The researchers built software that figures out the arm's exact shape by combining two noisy clues: sensors at the joints and camera images of the tentacle. They put these clues together using a 'factor graph,' a kind of puzzle-solving map, and tested it in a computer simulation with realistic fake photos of space. Their method tracked the arm accurately and ran quickly enough to be practical, though it has so far only been tested in simulation and not on real hardware.

Heavy-duty robot arms, like the ones that lift 100-kilogram tools, are usually designed in a step-by-step way: engineers pick the arm's shape first, then choose motors and gears to fit, and hope it all works out. The problem is that heavier motors make the arm heavier, which then needs bigger motors, and so on. These researchers built a computer method that designs the arm's shape and its electric motors, gears, and screws together, repeating until the weights agree with each other (it took only three rounds every time). It produced eight working designs that all reached the 12 required positions while carrying 100 kilograms, and it showed that the old one-pass approach can miss the true hardware weight by up to about 2%, cost by about 10%, and energy use by about 9%.

Most electric motors use magnets and coils of wire, but this team built a different kind: a motor driven by electric fields, where fixed electrodes pull charge onto a spinning part called the rotor. Earlier versions made the rotor from a single solid material, which limited how well it could be tuned. Miller and Lang instead built the rotor from separate metal vanes connected by ordinary electronic components like resistors and capacitors, which lets them copy a trick used in big magnetic motors called the 'deep bar' rotor, where the rotor responds differently as it speeds up. They built and tested a working desktop-sized motor, and it produced better turning force across a wide range of speeds than the old single-material design. The abstract does not give specific torque or efficiency numbers, so the size of the improvement is not stated here.

Researchers built a small, cheap airplane-style drone that can hunt down and crash into other drones on its own, using only a single camera to see its target. Instead of being programmed with flight rules, its brain is a neural network that learned to fly by trying thousands of simulated interceptions and getting rewarded for hitting the target, a method called reinforcement learning. The team tested it against two traditional, hand-engineered guidance systems in simulation, where the learned system did better in most conditions, and then proved it works in the real world by successfully intercepting maneuvering fixed-wing target drones in flight. Until now, drones like this have been flown by human pilots, and the quadcopter interceptors used today can't stay in the air long enough to reach high-flying, long-range targets. The abstract doesn't give exact success rates, so the specific numbers are not reported here.

Researchers ran a large set of computer simulations of a drone (a quadrotor) flown by six different 'autopilot' programs, to test whether the usual way of ranking them is fair. They found the rankings flip depending on how much effort goes into fine-tuning each one: after giving every controller the same tuning budget of twelve tries, a controller called BL-SMC went from last place to first, and it stayed first on 50 new simulated runs and even when the budget grew to 48 tries. Giving the predictive controller a peek at the upcoming path cut its tracking error a lot, and when they replayed real-world computer delays, three of four standard predictive controllers crashed on a desktop and all four crashed on a Raspberry Pi 5, until they limited how long the math could run (100 steps), which fixed every missed deadline. In short, a single 'tracking error' number hides tuning effort, path information, backup plans, and computer timing, so the authors propose a checklist for reporting all of them.

The researchers used computer simulations of two model city water systems to see what happens when hackers shut off the pumps for 4 or 12 hours, while the system is also under hypothetical environmental stress. They ran 288 simulations, 192 of them with verified attacks, and tried four different ways of fighting back. In the smaller network, a 12-hour attack left about 405 cubic meters of water undelivered on average, while the larger network kept delivering all the water even though pressure was off. The surprising part is that water flowing again doesn't mean the system is healthy: in all 192 attacks service came back, but pressure stayed recovered in only 103, and 65 of those relapsed afterward. Earlier studies mostly asked whether water was delivered, not whether the pipes returned to normal pressure.

Drones that carry cameras on a motorized mount (called a gimbal) have a hard time keeping the camera pointed steadily, because the drone shakes in two different ways: a repeating buzz from the motors and propellers, and random jolts from wind or sudden moves. The researchers built a controller that treats these two kinds of shaking separately. It predicts the repeating vibration ahead of time and builds it into its planning, and it handles the random jolts afterward using a small neural network that guesses what's coming during the delay between giving a command and the motor acting on it. They tested it on a real two-axis gimbal mounted on a hovering drone, where it cut pointing errors to 0.770 degrees (side-to-side) and 0.350 degrees (up-and-down), which is 25.1% and 45.9% better than a popular existing method. Earlier approaches lumped all the shaking together, which made the controller overreact to its own guesses about random disturbances.

Drones like quadcopters steer by tilting their whole body so the propellers push in the right direction, but this creates a math problem: if you tell the drone to fall freely, there is no 'correct' tilt, and the control software breaks down. The researchers, Ian Willebeek-LeMair and Craig Woolsey, designed a new control method that works with propellers mounted on tilting mounts (gimbals) and that never gets stuck at this free-fall problem. Instead of demanding the exact perfect push, it steers the actual push to stay within a small 'close enough' zone around the target, which still keeps the drone's tracking error provably small. They showed this works for any starting position, building a drone path-following controller that they tested in computer simulation only (no real-world flights or specific numbers were reported).

The researcher built a control system that helps a four-propeller drone keep flying accurately even when its motors or sensors start to break down. The system has two parts: a math-based 'detective' that continuously figures out which motor or sensor is failing and by how much, and an AI pilot trained with trial-and-error learning (a method called DDPG) that uses that information to keep the drone on its flight path. The detective was shown to settle on the right answer quickly for steady faults and to stay close to the truth for faults that change slowly, even with random disturbances. The AI pilot was trained on only one type of movement (turning left and right) yet still improved tracking in computer simulations of several motor and sensor failure scenarios, though the results come from simulation only, not real flights.

When AI models learn to predict how objects move in video, they're usually graded on whether the next frame looks right, but looking right doesn't mean the physics is right. The researchers built a diagnostic toolkit that separately checks three things: how close the picture is, whether the shapes stay physically valid (like links in a machine staying connected properly), and whether the motion actually matches the forces pushed on it. They tested several top models on hundreds of simulated machine assemblies and found a big gap: one model cut picture error by about 37% compared to just copying the last frame, yet it still produced invalid geometry, and in 3D tests, fixing the shapes with CAD tools still left force-response errors more than five times above engineering targets. They also showed their scoring can reveal real improvements that simple pass/fail checks miss, such as a model whose physics score jumped from 52.65 to 64.30 even though its geometry pass rate never changed.

The researchers built a complete computer-simulated flight system for a 2-kilogram drone whose propellers can tilt, so it can slide sideways or forward without leaning its body like a normal quadcopter has to. They paired a simple, reliable controller with a small neural network that learned to correct the drone's position drift when wind pushes it around. This network was trained by copying a 'teacher' that secretly knew the true wind speed, yet the network itself never gets to see the wind. In simulation, this cut the drone's position error under wind by about half (from 11.7 cm to 6 cm in light wind, and from 32 cm to 16 cm in a wind nearly three times stronger than it was trained on), while a separate state estimator tracked the drone's position within about 23 cm and guessed the wind speed to within 0.15 meters per second.

The researcher built a safety system for quadcopter drones that keeps them flying accurately even when a motor loses power or a sensor starts giving bad readings. It works in two steps: a math-based 'detective' (called a PI observer) continuously figures out how badly each motor or sensor is failing, and then a trained AI controller (using a method called DDPG) uses that information to adjust the drone's commands and stay on its flight path. The detective is mathematically proven to get the fault estimate right, and to stay close to the truth when faults change slowly and there is some noise. The AI was trained using only one type of motion (turning left and right, or 'yaw') yet still improved tracking across several simulated motor and sensor failure scenarios. All results come from computer simulations, not real flights.

Some AI models can predict what a video of moving objects will look like next, but looking right doesn't mean the physics is right. The researchers built a testing toolkit that separately checks whether predicted videos look accurate, whether the objects stay in physically possible shapes, and whether they move the way the applied forces say they should. One model cut image errors by about 37% compared to just guessing 'nothing moves,' yet still never produced valid object geometry. In the 3D robot models, rebuilding the shapes from CAD and inverse-kinematics tools fixed the geometry, but the forces the robot actuators needed were still more than five times off the engineering targets.

The researchers built a computer simulation of a 2 kg drone whose four rotors can tilt, so it can slide sideways or forward without leaning over like a normal quadcopter. They gave it a simple standard controller plus a small neural network that learns to fight steady wind, and they added a state estimator that switches smartly between hovering and moving without glitching. The estimator tracked the drone's position to within about 0.23 meters sideways, and guessed the wind speed to within 0.15 meters per second. The learned add-on cut the drone's drift in wind by about half (for example, from 0.117 m to 0.060 m in 1.5 m/s wind), and it still worked in winds much stronger than it was trained on, even though the network never directly sensed the wind.

The researcher built a system that helps a quadcopter drone keep flying accurately even when its motors or sensors start to malfunction. It works in two steps: a mathematical 'fault detector' (called a PI observer) continuously estimates how badly a motor or sensor has gone wrong, and then an AI controller trained through trial and error (called DDPG) uses that information to correct the drone's flight path. The detector is mathematically proven to lock onto constant faults quickly and to stay close to the true value when faults change slowly, even with random disturbances like wind. Unlike many AI-only approaches, this one pairs the learning controller with a proven math-based fault estimator, and the AI was trained on just one axis of movement (yaw, or turning) and then reused for tracking. The results come from computer simulations only, and the abstract does not give specific performance numbers.

AI models that predict how a robot or object will move in video can look convincing while still breaking the basic rules of physics, so the researchers built a testing toolkit that checks three separate things: whether the picture looks right, whether the shapes and positions make geometric sense, and whether the motion matches the forces pushing on it. When they tested models on 343 flat (2D) assemblies of connected parts, one model (CON) cut image error by about 37% compared with simply guessing nothing would move, yet neither model produced physically valid shapes. In the 3D tests, repairing the geometry with CAD and inverse-kinematics tools fixed the shapes, but the force the robot's motors would need to produce the predicted motion was still more than five times off from what engineers would accept. They also showed that training with a more accurate math method (RK4 instead of Euler) didn't fix the shapes but did lower force and energy mistakes, lifting a quality score from 52.65 to 64.30, which means their toolkit can tell different kinds of failures apart instead of lumping them into one 'accuracy' number.

Researchers built a computer simulation of a 2-kilogram drone whose four propellers can tilt, so it can slide sideways or forward without leaning over like a normal drone has to. Because a drone like this behaves differently when it's hovering versus moving, they gave it a smart position-tracking system that switches between modes smoothly, and it kept the drone's position to within about 0.23 meters sideways and 0.03 meters up and down, while also figuring out the wind speed to within 0.15 meters per second. When wind pushed the drone off target, they added a small learned correction (a tiny neural network that never sees the wind directly) on top of the regular controller, which cut the drift roughly in half, from 0.117 to 0.060 meters in a 1.5 m/s breeze. It even worked at 3.9 m/s winds it had never trained on, which sets it apart from past tilt-rotor work that often handled modeling, tracking, and wind in separate pieces.

Imagine you have a limited number of heaters to place in a room and want to warm up certain spots as efficiently as possible. The researchers built a math method that figures out how to split a fixed 'power budget' among possible control inputs (like heaters, fans, or actuators) so you can steer chosen outputs of a smoothly varying system with the least energy. Because computers can only handle chopped-up approximations, they proved that as the grid gets finer, the computed answers reliably settle on the true answer for the real, continuous system, and they gave error bounds. Testing on a 2D heat-and-flow problem, they found that coarse grids can falsely suggest a system is easy to control because of numerical blurring (called numerical diffusion), a trap that finer grids expose; the paper reports no single headline number, and its contribution is the proof of convergence plus a practical solving method.

When you control a humanoid robot through its own 'eyes,' reaching something behind or beside the robot normally means physically turning your whole body, which is slow and awkward. The researchers built a system that stretches the camera view to show a wider panorama and secretly adjusts how your arm movements are translated, so a small turn of your arm can reach a much wider area. They tested two versions (one that zooms the whole view, one that keeps a sharp center with a squished surrounding view) against normal controls with 8 people over 72 trials. The full-view zoom got the most tasks done (23 of 24, versus 20 of 24 for normal controls and 21 of 24 for the other version), but 6 of the 8 people actually liked the other version better.

When you control a robot arm remotely with a 'leader' arm that you move by hand, the robot's wrist often uses two motors working together to tilt and twist. If one motor hits its power limit before the other, the wrist stops moving the way you intended, like a car where one wheel can't keep up so it veers off your steering. The researchers built a smarter control method that limits both motors together instead of separately, so the wrist keeps pointing in the direction the operator wanted even when it can't move as far. It also keeps track of what the robot is actually doing, so it recovers smoothly from overload or a brief connection drop instead of jerking. In real-robot tests, the wrist moved more smoothly and recovered more continuously than with the usual direct joint-copying approach (the abstract does not give specific numbers).

Imagine you have a limited amount of effort to split among several pushers or heaters acting on something that spreads out through space, like heat in a metal plate or smoke drifting in the air, and you want to know how to divide that effort so you can steer a chosen spot as cheaply as possible. The researchers created 'controllability allocation scores,' which are numbers that tell you the best way to split a fixed budget among possible actuators, found by solving two math problems that either maximize how much you can change the target or minimize the energy needed to change it. Because real systems have to be simulated on a grid of points, they proved that if the true continuous system can be controlled, then a fine enough grid gives the same answer, and the scores computed on the grid get closer and closer to the true ones as the grid is refined, with error bounds provided. In a 2D example with flowing and spreading material, they showed that a coarse grid can fool you into thinking something is controllable because of 'numerical diffusion' (artificial blurring from the computer grid), and that refining the grid exposes this.

Some AI systems learn to predict what a video of moving objects will look like next, and until now they were mostly graded on how sharp the predicted pictures were. The researchers built a test kit that also checks whether the predicted objects still make physical sense (parts stay connected, shapes stay valid) and whether the motion actually matches the pushes and forces applied. One model cut its picture error by about 37% compared to just guessing 'nothing moves,' yet it still couldn't produce physically valid shapes. Two robot-arm models could be fixed to get the geometry right, but their force-response errors stayed more than five times above the engineering targets. This shows that a good-looking prediction can still be physically wrong, so these models need to be judged on forces and geometry, not just how the pictures look.

Researchers built an AI shortcut that predicts how a bendy, snake-like robot arm (the kind pulled into shape by tiny cables, used for things like delicate surgery) will curve and twist, without running slow physics simulations each time. Unlike earlier AI models for this job, theirs can tell you when it is unsure, and its uncertainty gets bigger for robot designs that look very different from the ones it was trained on. It also keeps the robot's twisting motions geometrically valid instead of producing impossible orientations. In tests, it was 30-50% more accurate than earlier neural-network approaches while learning from about 5 times fewer example robot designs, and choosing training designs smartly cut errors by about 15% compared to picking them at random.

When people teach a two-armed robot by showing it a task, the demonstration captures not just what to do but also one specific timing, like the left arm always going first. Normal training lets the robot mistake that timing for a rule, so if one arm gets delayed or stuck, the other arm freezes up even when it didn't need to wait. The researchers built a method called CTR that takes recorded demonstrations and shifts the timing of each arm's movements, while keeping the true rules intact, such as one arm needing to hold a box steady before the other opens it. In real-robot tests, the worst-case success rate rose from 56% to 76%, and in one test a 4-second pause in one arm passed only 0.25 seconds of delay to the other arm instead of 2.56 seconds.

Researchers built a smart controller for a home that has an electric car, heating, and other power-hungry devices. Its job is to cut the electricity bill while making sure the car is charged by the time the owner leaves and the house stays comfortable, even when weather forecasts are wrong and driving habits are unpredictable. The controller learns by trial and error, and it prepares for worst-case surprises in when and how far the car gets driven, plus a safety layer that blocks any action that would leave the car undercharged or the house too cold or hot. In a full year of simulated tests in Wellington, New Zealand, it was the cheapest option that never missed an EV charging target, and compared with the only other controller that also succeeded (a simple rule-based one), it cut yearly energy costs by 8.6% and reduced uncomfortable hours by 69%.

When a mine collapses and the wired communication lines break, rescue teams drop small relay boxes to keep radio contact with the surface. The trouble is that radio signals in tunnels bounce around and cancel each other out, creating 'dead spots' only a few inches wide where the signal can drop by 19 to 26 decibels (a huge loss). The researchers built QuadBeam, a relay box with four separate Wi-Fi-band antennas (one on each side) that can each be moved up or down on their own, plus a backup antenna for voice calls. In tests in a real experimental mine, sliding a single antenna up or down by just 20 centimeters boosted the signal by as much as 22 decibels, and moving the antenna on one side didn't mess up the connection on the others.

Offshore drilling rigs float on the ocean, so waves push them up and down, and that motion travels down thousands of meters of steel pipe and the drilling fluid inside it. The researchers built a computer model that treats the pipe and fluid as one connected system and, unlike earlier models, tracks how rubbing between the pipe and the walls of the hole spreads out along the whole length of the pipe. They proved mathematically that the model behaves sensibly, then ran many simulations, including ones with realistic ocean wave conditions. The fluid's behavior was mostly set by pressure waves bouncing around, but the steel pipe's motion was much more affected by friction, and friction turned out to matter little for whether the model works at all but a lot for how close the system is to becoming unstable. The abstract does not give specific numerical results, only these qualitative findings.

When a mine collapses, rescuers have to drop temporary wireless relay boxes to keep in touch with the surface, but radio signals inside tunnels bounce around and create dead spots, much like spots where a car radio fades out. The researchers built QuadBeam, a small relay box with four separate Wi-Fi-style antennas on its four sides, each one able to slide up or down on its own, plus a backup antenna for voice calls. In a real test mine, signal strength swung by 19 to 26 dB (a huge difference) just from small changes in position, and moving one antenna up or down by about 20 cm boosted the signal by as much as 22 dB. Unlike earlier movable-antenna ideas that move everything at once and can help one connection while hurting another, QuadBeam lets each connection be adjusted independently, and moving neighboring antennas didn't disturb the active link.

When an offshore drilling ship bobs up and down on ocean waves, that motion travels down the long steel pipe (the drillstring) and the fluid pumped through it, which can shake or destabilize the whole operation. The researchers built a computer model that links the moving fluid and the flexing pipe together, and that also accounts for friction as the pipe rubs against the walls of the well along its entire length, instead of treating friction as a single point or ignoring it. They proved mathematically that the model behaves sensibly and found conditions that keep the system stable, then ran many simulations including realistic random sea conditions. They found that the fluid's behavior is mostly driven by pressure waves bouncing around, while the pipe's motion is much more sensitive to friction, and that friction barely changes whether the model has a valid solution but can noticeably shrink the safety margin for stability. The paper is a modeling and simulation study, so it reports no hardware tests or field data.

After a mine accident, rescuers often have to drop small wireless relay boxes in the tunnels to keep a link open to the surface, but radio signals inside tunnels bounce around and create dead spots where the signal nearly vanishes. The researchers built QuadBeam, a compact relay box with four separate 2.4 GHz flat antennas, one on each side, that can each be moved up and down on its own, plus a small 900 MHz antenna as a backup for voice calls. When they tested it in a real experimental mine, the signal strength swung by 19 to 26 decibels depending on where the antennas sat, but just sliding the receiving antenna about 20 centimeters (the length of a ruler) boosted the signal by as much as 22 decibels. Earlier movable-antenna ideas shifted all the antennas at once, which could fix one link while breaking another, whereas this design lets each link be adjusted without hurting the others, since the four antennas barely interfere with each other (coupling below -46 dB).

When a drilling ship bobs up and down on ocean waves, that motion travels down a drill pipe that can be miles long and through the fluid pumped inside it. The researchers built a computer model that treats the pipe, the drilling fluid, and the rubbing between the pipe and the walls of the hole as one connected system, and they proved mathematically that it behaves in a stable, predictable way. Then they ran many simulations, including realistic ocean wave conditions, and found that the fluid mostly just carries pressure waves up and down, while the pipe itself is much more affected by friction against the wellbore. Friction doesn't break the math of the model, but it can noticeably shrink the safety margin before the system becomes unstable, which earlier models that ignored friction along the pipe's length would have missed. Note that this is a simulation study, so the findings haven't been tested on a real drilling rig.

When a mine collapses, the cables that carry wireless signals can break, so rescuers have to drop small relay boxes in the tunnels to keep in touch with the surface. The trouble is that signals inside a tunnel bounce around and cancel each other out in certain spots, creating dead zones where the signal can drop by 19 to 26 decibels over just a few meters. The researchers built QuadBeam, a relay box with four separate antennas on its sides that can each be moved independently (plus a backup radio for voice calls), and tested it in a real experimental mine. Just sliding one antenna up or down about 20 centimeters boosted the received signal by as much as 22 decibels, and moving or changing the other antennas didn't disturb the link that was working, which fixes the problem of earlier designs where fixing one connection could break another.

Offshore drilling rigs float on ships that bob up and down with the ocean waves, and that bobbing travels down a drill pipe thousands of feet long and through the fluid pumped around it. The researchers built a computer model that treats the pipe and the fluid as connected systems, and includes how the pipe rubs against the sides of the hole as it moves. They proved mathematically that the model behaves sensibly, then ran many simulations, including ones with realistic ocean wave patterns. The fluid's behavior is mostly controlled by pressure waves bouncing around, but the pipe's motion is far more sensitive to rubbing, and that rubbing can noticeably shrink the safety margin before the system becomes unstable. The paper doesn't report experiments on a real rig, and earlier models tended to treat the fluid and the pipe separately or ignore friction along the hole, so this is a more complete picture.

Robots can learn new movements just by watching a person do them, like tracing handwriting, but there's no guarantee the robot will stay safe or actually reach its goal. The researchers built a 'referee' system that sits on top of the learned movement: a main controller follows what the robot learned, while the referee watches in the background and only steps in when the robot is about to break a safety rule or drift off course. What makes this different is that the referee's safety guarantees come from the robot's own physical properties instead of from the learned movement itself, so it works no matter how the robot learned the motion. They tested it in simulations and on a real robot using 2D and 3D datasets, including handwriting, and showed it could provide formal safety guarantees even in messy, changing environments. The abstract doesn't report specific numbers, so the exact performance margins aren't known.

Controlling a complicated robot, like a squishy soft robot made of nearly 10,000 moving parts, is too slow if the computer tracks every part, so engineers use a simplified stand-in model that tracks only a few. The catch is that simplified models can be wrong, and a robot following one might bump into things it was supposed to avoid. The researchers built a controller called CoRE-MPC that plans with the simple model but also keeps a running estimate of how far off that model could be, then leaves enough safety margin to guarantee the real robot never breaks its rules. In simulation, a two-number model kept all 1,628 points on a soft robot away from a wall while solving in under 1 millisecond, running 13 to 61 times faster than the full-detail approach with only 27 to 35% worse performance, and beating other safety-guaranteed methods that either failed outright or were at least twice as cautious.

Some new wireless systems use tiny antennas that slide along a long cable, called a waveguide, to stay close to your phone and dodge obstacles like people walking by. Earlier studies pretended these antennas could teleport instantly, but real motors take time to move and the signal has to pause while they do. The researcher built a planning method that accounts for this by picking the whole sequence of antenna positions ahead of time, like planning several chess moves instead of just the next one, because a blocker (say, a person walking toward you) shadows a bigger and bigger stretch of the cable as it gets closer. Across 20 random test runs, this planning delivered 17.7% better worst-case data speed than a move-by-move approach when obstacles were present, and performed just as well when nothing was in the way.

Tiny satellites called CubeSats can steer themselves using magnetorquers, which are small electromagnets that push against a planet's magnetic field, but they only work well if the satellite knows exactly what that field looks like and they lose steering power in certain directions. The researchers built a control system that plans the satellite's turns ahead of time using a computer model of the magnetic field that was first trained on rough, simplified data. As the satellite flies, it compares the model to what its sensors actually measure and quickly corrects just the final part of the model, so it learns the real field on the fly. In simulations of orbiting Earth and Uranus, this adaptive approach succeeded 5% more often at Earth and 61% more often at Uranus, where the magnetic field is strange and poorly known.

The researchers built a folding, flat "tidying plate" that fits on top of a regular robot vacuum and can push clutter out of the way. The clever part is that when the plate unfolds, its arms line up in a nearly straight line, so any weight pushing down on it barely turns the motor's gears backward. This means the plate stays locked in place without the motor needing to stay on, a bit like how a door stop or a locked-out knee holds firm. In tests, the locked plate held 50 newtons (about the weight of a 5 kg bag of rice) with the motor turned off, survived 100 deploy-and-fold cycles, and was compared against a commercial robot-vacuum-with-arm in 140 trials of pushing seven household objects around.

Instead of using a foot pedal and a chain of levers to change gears on a motorcycle, the researcher attached a small electric motor directly to the part inside the gearbox that selects the gears (the shift drum), using a worm gear that locks in place when the motor is off. He first measured 84 normal human gear changes on a large production motorcycle and found they average 80 milliseconds for upshifts and 92 milliseconds for downshifts. He then built a custom circuit board and a simple position-control program, and on a test rig the motor completed a gear change in under 80 milliseconds without overshooting, which is faster than the average human shift, though this was shown in only a single measurement. He also found a design trade-off: with the gear ratio of 30 that keeps the worm gear self-locking, about 93% of the motor's effort goes just to speeding up its own spinning parts, and a ratio of about 8 would halve the effort needed but would lose the self-locking.

Factory computers often run several AI programs at once, such as one that controls a motor's twisting force, one that inspects products with a camera, and one that predicts when machines will break. When the shared network gets overloaded, these programs don't crash; they quietly start giving wrong or outdated answers, which is hard to notice. The researchers built a system where each program gives itself a 'criticality score,' a number showing how important it is and how urgently it needs help, based on six factors like how much physical damage a mistake could cause and how fresh its data is. The programs share their scores with each other and decide on their own, without a boss computer, who should be protected, who should move to a healthier machine, and who should take over as leader if the current leader is struggling. The abstract does not report test numbers or measured results, so how well it works in practice isn't stated here.

Soft robots made of squishy, bendy material are really hard to control, especially when they're floppy enough that gravity pulls them over, like trying to balance a broom on your fingertip, except the broom is made of rubber and wobbles everywhere. The researchers built a controller that works like a fast-thinking chess player: it uses an accurate but simplified math model of the robot to predict what will happen next, then constantly picks the best move to keep the robot upright. They tested it on a soft inverted pendulum (a bendy rod balanced upside down) and other robots that mix soft and rigid parts, and it kept them balanced in harder positions than older controllers could manage. It also runs fast enough for real-time use, making 50 to 150 decisions every second, which earlier methods for this kind of problem struggled to do.

Underwater robots get shoved around by waves and currents, and their thrusters can only push so hard, which makes keeping them steady a real challenge. The researchers took a control method that works like a built-in guesser, constantly estimating the unknown forces pushing on the robot and cancelling them out, and added two simple safeguards: a hard cap on how strongly the controller can command the thrusters, and a smoothing filter that stops those commands from changing too abruptly. Earlier versions of this method only had mathematical proof of stability if you assumed the commands would stay small and smooth, which couldn't be guaranteed in the real ocean. By building those limits into the design, the team could actually prove the robot stays stable, and they backed this up with detailed simulations and tests on a real underwater robot under heavy disturbances. The abstract doesn't give specific performance numbers, so how much better it does than rival methods isn't stated.

Factories and water plants run on computer networks that almost never change, which gives hackers plenty of time to map everything out. One defense is to constantly shuffle the network addresses so attackers can't keep up, but past versions of this trick never checked whether shuffling might accidentally mess up the physical machinery, like pumps and valves. The researchers built BALLAST, which uses a learned 'digital twin' (a computer model of the plant) to predict whether each shuffle would be safe before doing it, and it lets in-progress messages finish before switching. On a real water treatment testbed, it cut the success of a hacker's scanning attempts by 85 percent and caused no safety violations in 50 runs, while a comparable earlier design caused five violations and had about 19 times more control error.

The researchers built a computer program that plans a safe route for a tiny, flexible, vine-like robot that grows forward through the fluid-filled space around the spinal cord, a delicate area where a wrong move could damage nerves. They took the well-known A* route-finding method (the same idea behind GPS-style pathfinding) and extended it to work in 3D using medical images, so it picks a path that stays clear of fragile tissue. Their version also deliberately places 'anchor points' along the route, spots where the robot can brace itself so it can steer around bends instead of buckling or drifting. They tested it on a highly detailed model of the spinal space and checked that the paths it found were both efficient and followed the robot's movement limits; the abstract does not report specific numbers, so exact performance figures are not available here.

Robot arms controlled by AI models can break down when a joint gets weak, sticky, or partly fails, because the AI still assumes the arm moves exactly as commanded. The researchers built CAPABLE, an add-on that watches how the arm actually responds to its commands and figures out, on the fly, how well each joint is working, without being told which joint is broken or what kind of fault it is. It then adds small corrections on top of the existing AI's actions, without retraining that AI. On 28 simulated tasks, it raised success on a type of joint failure it had never practiced from 24.8% to 59.3%, beat a comparable baseline by 17.4 points, kept healthy-robot performance intact, and also worked on a real Franka Panda arm.

This is a review paper, not a new robot or controller. The author went through the research on 'deadline' control, the math that makes a system hit its target by a guaranteed time, and found that people use the same labels (finite-time, fixed-time, predefined-time, prescribed-time) for very different promises. Some mean the deadline depends on where you start, some mean it holds from any starting point, and some mean the designer picks the exact deadline. The author sorted the studies by what is actually promised, what math trick produces it, and what controller carries it, then checked each one. The audit found that once real-world messiness like sensor estimation errors, limited motor power, and digital sampling is included, many 'exact' deadline guarantees quietly become 'approximate', and most physical testing has been done only on fast electromechanical systems. A simple one-variable test case showed that apparent differences between methods often come from overly cautious math bounds, starting-condition effects, and numerical tolerance rather than real performance gaps.

When a spacecraft flies close to an asteroid or comet, it can't know exactly how strong gravity is, how hard sunlight pushes on it, or what random bumps will nudge it, so its planned path can drift into dangerous territory. The researchers built a two-layer flight controller: one layer plans a route that deliberately leaves extra safety margin around no-go zones, and a second layer (called L1-DRAC) constantly senses how wrong the planner's assumptions are and corrects for it in real time, while telling the planner how much uncertainty is left. In 1,000 simulated flights where the real physics didn't match the planner's model, the spacecraft entered the keep-out zone 32.7% of the time without the adaptive layer but only 0.2% with it, and actual crashes dropped from 16.4% to zero, all without maxing out the thrusters. The key difference from earlier methods is that planning and real-time correction are linked, so the safety guarantee still holds even when the model of the world is wrong.

The researchers built EndoRSI, a system where an AI coding agent (called EndoForge) writes and rewrites the control software for a robot that guides an endoscope, the thin camera tube doctors use to look inside the body. Instead of engineers studying every failure and deciding what to fix, the AI learned from the robot's real physical tests, including catching that an approach that looked good on past recorded data was actually dangerous when the robot moved on its own. Across four rounds of improvement, the robot's success at inserting the endoscope jumped from 2 out of 21 tries to 17 out of 21, and the final version beat other autonomous approaches on six different pig tissue samples. A human still approved every experiment, and the robot ran inside a safety-limited setup.

The researchers built a computer program that plans a safe route for a tiny, soft, snake-like robot that grows from its tip as it moves through the fluid-filled space around the spinal cord. The program works from medical images and builds on A*, a classic route-finding method like the one in a GPS. It looks for a path that stays away from delicate tissue while placing 'anchor points' along the way, spots where the robot can brace itself so it can steer around bends. They tested it on a very detailed 3D model of the spinal space and checked whether the paths were safe, efficient, and doable for the robot's movement limits. The abstract doesn't give specific numbers, so exact performance figures aren't available here.

Robots that follow spoken or written instructions are usually trained on one specific body, so when a joint gets weak or sticky, they keep sending the same commands and the arm no longer does what they expect. The researchers built CAPABLE, a add-on that watches how each joint actually responds to commands, figures out how much of each movement is really happening, and then adds small corrections on top of the robot's existing brain without ever being told which joint broke or what kind of fault it was. On a joint it had never been trained to handle, success on 28 simulated tasks jumped from 24.8% to 59.3%, beating a similar-sized alternative by 17.4 points, and it also worked on a real Franka Panda robot arm. Unlike earlier fixes, it doesn't need retraining for each task, fault labels, or a separate diagnosis step.

Engineers often need a robot or machine to hit its target by a specific deadline, not just 'eventually,' and several families of control methods promise this under names like finite-time, fixed-time, predefined-time, and prescribed-time. This review shows that those labels are used loosely: some methods have a deadline that grows the farther the system starts from its goal, some have a fixed ceiling, and some let the designer pick the deadline outright. The author checked published studies one by one, recording exactly what each one proves, and found that once real-world messiness like sensor estimation errors, motor limits, and digital sampling is added, many 'exact' deadline guarantees shrink to 'approximately on time.' A simple test problem with two different tunings showed that much of the apparent difference between methods comes from conservative math, dependence on starting conditions, and computer rounding, and that motor saturation and sampling can delay or even erase a deadline. Most hardware testing so far has been on fast electromechanical systems, so slower or more complex machines remain largely unproven.

When a spacecraft flies close to an asteroid or comet, it has to steer itself because messages from Earth take too long to arrive, and it can't know exactly how the object's gravity or sunlight pushing on the craft will act. The researchers built a two-part brain for the spacecraft: a planner that maps out a path while leaving extra safety room around the asteroid, and an adaptive controller (called L1-DRAC) that quickly corrects for pushes and pulls the planner didn't predict, then tells the planner how wrong its guesses were so it can adjust. In 1,000 simulated flights with mismatched gravity, sunlight pressure, and random disturbances, the spacecraft without the adaptive controller strayed into the no-go zone around the asteroid 32.7% of the time and crashed 16.4% of the time, while with it the no-go violations dropped to 0.2%, crashes dropped to zero, and the thrusters never maxed out.

The researchers built EndoRSI, a system where an AI coding agent called EndoForge writes and rewrites the control software for a robot that guides an endoscope (a thin camera tube) through the body, learning from what actually happens when the robot runs on real tissue. A human approves every physical test, and the robot runs inside a safety-limited setup. The AI threw out its first approach after the early evidence looked bad, then found that a strategy that looked good on recorded data was actually dangerous when the robot ran live. By learning from its failed real-world attempts, it raised the robot's insertion success from 2 out of 21 tries in the first version to 17 out of 21 in the fourth. The final version, with no further changes, beat other autonomous methods across six separate pig tissue samples, even when the camera view and hardware changed. Unlike earlier AI-for-science work, which mostly lived in software, this one used messy physical experiments as its teacher.

Robots that follow spoken or written instructions are usually trained on one specific body, so they stumble when something breaks, like a joint that gets weak, stiff, or sluggish and no longer moves the way it is told to. The researchers built CAPABLE, a add-on system that watches how a robot arm's joints actually respond to commands and quietly works out how much each joint is really doing, without anyone telling it which joint is broken or what went wrong. It then adds small, safe corrections on top of the robot's existing AI brain, which stays unchanged. On 28 simulated tasks, it raised success on a joint it had never practiced with from 24.8% to 59.3%, beat a comparable simpler approach by 17.4 points, kept healthy robots working just as well, and also worked on a real Franka Panda arm.

This is a review paper, not a new robot or controller. It looks at the many kinds of 'finish by a deadline' control, where a robot or machine must reach its target on time instead of just eventually getting there. The author noticed that labels like 'finite-time,' 'fixed-time,' and 'prescribed-time' get mixed up, even though they can mean very different promises: a deadline that grows with how far off you start, a deadline that holds no matter the starting point, or a deadline the designer simply picks. After checking the studies one by one, the review found that guarantees proven on idealized math models often shrink to 'roughly on time' once real-world messiness is added, like estimation errors, limited motor power, and computer sampling. Nearly all of the physical experiments were also on fast electromechanical systems, and a simple test case showed that saturation and sampling can delay a deadline or erase it entirely.

Robots that learn from camera images alone often struggle because a flat picture doesn't clearly show an object's 3D shape. The researchers built a training trick called shape-teacher alignment: while the robot learns, a separate AI model that already understands 3D shapes (Point-MAE) acts like a tutor, nudging the robot's image-reading system to pick up on object shapes and parts. Once training is done, the tutor is thrown away, so the robot only needs a regular camera, with no depth sensor or extra equipment. On the LIBERO robot-task benchmark, robots trained this way learned much faster (4.7 times faster on the Object tasks and 5.6 times faster on the Spatial tasks) and succeeded more often.

When AI agents pass tasks along a chain, like a patient's request moving through an insurance reimbursement process, the last agent in line needs proof that the original person actually approved the action, not just that the agent right before it is who it claims to be. The researchers built a prototype with four parties handling a healthcare reimbursement and tested it against 15 different attacks, such as replaying old messages or forging approvals, and it blocked 14 of them in about 5 thousandths of a second per check. The two weak spots they found are that the system can't shrink an agent's permissions as a task gets handed down, and that anyone holding the shared secret key can rewrite what permissions a request claims to carry. Unlike earlier approaches that mostly checked who was sending a message, this design keeps 'who is asking right now' separate from 'who originally gave permission,' so each step can be verified independently.

Face-unlock systems can be tricked by photos, videos, or masks, and the AI that catches these fakes often just memorizes the quirks of the specific cameras and fake types it trained on, so it stumbles in new settings. The researchers built DINOFAS, which teaches a powerful pre-trained vision model (DINOv3) to learn what a real, live face looks like rather than memorizing what each type of fake looks like, while filtering out camera- and lighting-specific clues. When trained on three datasets and tested on a fourth it had never seen, it made mistakes about 9.09% of the time on average (HTER, a combined measure of false accepts and false rejects). When trained only on computer-generated fake data and tested on four real-world datasets, it had the lowest average error (21.41%) and the best average AUC (86.14%) of the methods compared.

Regular cameras struggle when something moves fast in a scene that has both very bright and very dark areas, like a car leaving a tunnel into sunlight. The researchers built HIVE-Diff, an AI system that takes just one ordinary photo plus a stream from an 'event camera' (a special sensor that records only what changes, very quickly) and generates a whole sequence of smooth, high-detail video frames that keep both the bright and dark details. Earlier methods either used the event camera alone, which made colors and brightness drift over time, or needed a matching normal photo for every video frame; HIVE-Diff needs only one reference photo for many frames. Because real training data of this kind barely exists, they trained on synthetic data and then adapted the system to real event cameras using a teacher-student training trick, and they report strong results on synthetic and several real-world datasets (the abstract does not give specific numbers).

Self-driving cars need to spot hazards like potholes and debris even when it's dark, raining, or dusty, so researchers tested four popular AI vision systems under those tough conditions. They found that a popular tool for brightening dark images (called SCI) actually makes detection worse at dusk, cutting accuracy by 16% to 31%, because the lighting is already fairly good and the tool over-processes the picture. To fix this, they built a simple add-on that checks how bright each camera frame is and then picks the right amount of brightening: none, a little, or a lot with noise cleanup. It needs no extra training, wins back most of the dusk losses while keeping the benefits in full darkness, and they showed it runs on a small, cheap NVIDIA Jetson Nano computer.

The researchers built HITCH, a kind of control harness that lets an AI that understands pictures and language (a vision-language model) drive a humanoid robot. The AI can point at anything it sees, get back that spot's 3D location, and then give simple commands like 'move hands here' or 'walk there,' while a separate trained system turns those commands into smooth full-body movement. They then trained the AI by showing it examples of expert robot programs solving five basic tasks through this harness, so it learned how to use a robot body in general. Without any practice on the new tasks, it finished 51% of tasks in one simulated test and 42.5% in another, jumped to 95% after seeing just five examples per task, and on a real G1 humanoid it carried a box to a goal without any real-world training data.

Radar can sense tiny movements of a person's body, like walking, waving, or breathing, even through darkness or smoke, but there's very little radar data available to train AI models compared to photos or text. The researchers built 4D Point Splatting, a program that takes a real radar recording plus a camera view of the same scene and rebuilds it as a cloud of tiny 3D points that each carry a surface type and a speed, then simulates the exact raw radar signal those points would produce. Earlier simulators couldn't match a real recording of a moving person, so AI trained on their fake data performed badly on real data (127.6 cm average joint-position error). When the new method's fake data was used to train a body-pose model, it was only 21.9 cm off on real radar data, close to the 16.7 cm of a model trained on real data, and it can process one recording in about 6 to 13 minutes on a single high-end graphics card.

Many robotics classes use a toolkit called ROS to control real robots, but setting it up and learning its way of splitting programs into many talking pieces is hard for students who aren't strong programmers. The researchers built a small software library that copies the commands of a popular robot simulator called Webots, so a student can write one plain Python program, test it on a computer, and then run the exact same code on a real TurtleBot3 Burger robot with only tiny changes. The library lets the code use the robot's motors, wheel counters, motion sensors, and laser scanner, and comes with scripts that automatically copy the program to the robot and start it. They used it in a master's-level course on self-driving vehicles, and early student feedback suggested it made the technical setup feel less overwhelming so students could focus on how their robot makes decisions; the paper reports feedback rather than hard numbers.

Researchers built SLA, a robot AI model that learns to understand 3D space, not just flat images, during its big 'pre-training' phase instead of only when it's being fine-tuned for a specific job. Most robot AI systems borrow their eyesight from models trained on regular 2D photos and captions, so they're a bit like someone trying to grab a cup using only a flat picture. To fix this, the team started from an existing robot policy called pi05 and trained it on many different robots' data while teaching it to match its internal 'vision' to the output of a separate model that already understands depth and 3D geometry. The extra 3D teaching tools are only used during training and thrown away afterward, so the final robot brain runs exactly like the original. The abstract does not report specific performance numbers, so how much better it performs is not stated here.

Robots that follow spoken instructions using AI (called Vision-Language-Action models) can fail in surprising ways when they face something new, and those failures can break equipment or hurt people. The researchers built VLA-Tug, a small add-on that peeks at the robot AI's internal 'thoughts' while it works and warns when things are about to go wrong, using almost no extra computing power. It catches failures up to 30% earlier than the best competing method at the same false-alarm rate, keeps its promised error limits in up to 86% of runs on brand-new tasks (versus at most 21% for other methods), and can even guess what kind of failure is coming, such as a missed grasp or a dropped object, with up to 44% better top-3 accuracy than a majority-class baseline. The team also released 3,180 annotated robot episodes so others can build on the work.

Tiny drones need to see how things in front of them are moving to dodge obstacles, but the cheap, low-power chips small enough to fly on them have very little working memory, which limits how sharp the camera image can be. The researchers built a design tool called PACE-NAS that first locks in the memory needs of a vision AI model, then automatically searches for the fastest version of it. They found the biggest memory hog in an existing model (EdgeFlowNet) and swapped it for a lighter trick, cutting peak memory use by 18%. Their fastest resulting model, MCUFlowNet-S, runs 1.76 times faster than the original with only a 1.6% accuracy loss, and in simulated forest flights at 2 m/s the drone reached its goal without crashing 51.5% of the time, compared with 41.8% for the original.

The researchers taught a humanoid robot to do parkour, like climbing and vaulting over obstacles, by first copying human movements and then gradually letting the robot figure out its own way to use its hands and knees for support. Human moves don't always fit a robot's body, so they trained in three steps: copy the human moves in a way the robot can physically do, learn skills suited to each type of terrain, then loosen the copying so the robot can adjust where it puts its hands and knees. The robot (called the Noetix E1) picks the right move on its own using only its depth camera and body sensors, and it did 29 of 30 single-obstacle tests and four of five full obstacle courses in the real world without extra retraining after leaving the simulator. In simulation it succeeded 96.34% of the time on mixed courses, and tests showed the final adjustment step really did help it cross the tested terrains more reliably.

The researchers built STEP, a new way to train a humanoid robot to walk over tricky terrain like stairs, gaps, and stepping stones using a depth camera and its own body sensors. Instead of just mixing camera and body information together, STEP teaches the robot two extra skills while it learns to walk: guessing what its body feels like from what the camera sees (and the other way around), and predicting how its own state will change after each move it makes. On a real 23-joint Noetix E1 humanoid, it succeeded in 98 out of 100 trials, including climbing a 40 cm platform, crossing a 70 cm gap, and even walking backward up stairs it couldn't see. It also held up better than other approaches when the camera feed was blocked or delayed.

Researchers built a small touch-screen-like pad that can change both how soft or hard it feels and how warm or cold it feels at the same time, something most earlier devices couldn't do. It works by filling a pouch with tiny particles that lock together when air is sucked out (making it up to 300% stiffer), while heated and cooled water flows underneath to change the surface temperature. The surface can be set anywhere from 10°C to 50°C, stays evenly warm or cool across its whole area, and its control system holds the temperature within just 0.2°C of the target. Before this, touch devices typically handled one sensation at a time, so this is a step toward making virtual objects feel more like real ones.

Researchers built SHORE, an AI system that plays a kind of real-world Tetris: boxes arrive one at a time, and a robot has to decide which box to grab, how to turn it, and where to set it down without knowing what's coming next. The twist is that SHORE learns to predict how likely each possible placement is to keep the stack from toppling, then weighs that risk against how much space the placement saves, instead of just banning anything that looks shaky. In simulation it hit 73% space usage after 0.4 million practice steps, while the same AI without the stability predictor needed about 1 million. On a tougher set of 60 box types it packed 73.4% of the space versus 58.8% for the previous best method, GOPT, at the cost of slightly more failed placements (1.03% versus 0.63%).

Robots increasingly 'see' using more than ordinary cameras, including sensors that detect only changes in brightness (event cameras), count single particles of light (SPAD), measure distance with light pulses (LiDAR and time-of-flight), and sense heat (thermal cameras). The problem is that most robot simulators pretend these sensors are perfect, so robots trained or tested in simulation get surprised by real-world glitches like LiDAR glare, depth readings that 'wrap around' at long distances, event cameras that briefly go blind after firing, and thermal cameras that lag behind changing temperatures. The team built VisionSIM, a simulator that mimics how each sensor physically captures raw measurements, letting engineers tune sensor settings and test different sensor types on exactly the same scenes and robot paths. They also released the software and a large indoor dataset with raw sensor readings and detailed ground-truth labels; the abstract does not report benchmark numbers.

The researchers built and released a free, open-source software package that lets a small wheeled rover follow a trail of arrow signs, drive to a cone at the end, and then find its own way back to where it started, all without a human steering it. The rover uses a camera to spot the arrows (the detection model scored 0.720 on a standard accuracy test using 478 photos it had never seen, and it beat a traditional image-processing method), then combines that with mapping and motion sensors to plan its route. Detection runs in about 25 milliseconds on a small onboard computer (a Jetson Orin NX), and the rover completed three test missions, one indoors and two outdoors, with no reported collisions. What's different is that the whole chain, from seeing arrows to turning the wheels, is shared publicly along with the data, trained model, and test logs, and the authors openly list what went wrong during testing instead of only showing the successes.

Most robot AI today works like an assembly line: a separate 'eyes' program first squeezes each camera image into a compact summary, and only then does the 'brain' decide what to do. The researchers built NEO-VLA, which skips that separate eyes program and instead chops images into small patches and feeds them straight into the same model that reads the instructions, so seeing and understanding develop together. The robot's action module can then pull information from many stages of this process, not just the final one. They found this design beat comparable models with separate vision encoders, that extra fine-tuning or a bigger model size didn't close the gap, and that the details that matter most for grabbing things, like edges, depth, and small changes in an object's position, often show up in the middle of the model and then get lost by the end. (The abstract doesn't give specific benchmark numbers, so I can't cite exact percentages.)

Face-unlock systems can be fooled by photos, videos, or masks, and the software that catches these fakes often fails when it meets a new camera, lighting, or type of attack because it memorized quirks of its training data instead of what a real face looks like. The researchers built DINOFAS, which starts from a powerful pre-trained vision model (DINOv3), tweaks only a small part of it (using a technique called LoRA), and trains it to learn what 'real' looks like rather than catalog every kind of fake. It also strips out distracting details like lighting and camera style, so it focuses on actual signs of life. On a standard test where the system is trained on three datasets and tried on a fourth it has never seen, it made mistakes about 9.09% of the time, and when trained only on computer-generated fake data and tested on four real-world datasets, it had the lowest error (21.41%) and best accuracy score (86.14% AUC) among the methods compared.

Normal cameras struggle to capture fast motion and very bright and dark scenes at the same time, like a car leaving a tunnel into sunlight. Event cameras, which only record changes in brightness, handle speed and lighting extremes well but lose track of absolute color and brightness over time. The researchers built HIVE-Diff, an AI video generator that takes just one ordinary photo plus a stream of event camera data and produces many high-quality, wide-brightness-range video frames, instead of needing a separate regular photo for every frame like earlier methods. Since real training data pairing these two types of footage barely exists, they trained mostly on simulated data and then adapted the model to real event cameras using a teacher-student training trick; the abstract reports strong results on synthetic and several real-world datasets but does not give specific numbers.

The researchers built a backup safety system for self-driving cars that watches for danger and decides when to slam on the brakes, and it's designed to run on small, low-power computer chips. First, a tool called PMCM draws an invisible, curve-aware 'tunnel' along the car's planned path that's wide enough to cover the car's whole body, so only laser-scanner (lidar) readings inside that tunnel get checked. Then a second tool called GDETA looks at each object in the tunnel in two separate ways: how much it physically blocks the path and how soon a crash would happen, and it brakes if either check is clearly alarming or if both are moderately worried. It also waits for several scans in a row to agree, so a single glitchy reading doesn't cause a false stop, and the team tested it in collision simulations, recorded campus driving, and thousands of randomized simulated cases like a car ahead braking suddenly or someone crossing the road. The abstract doesn't report specific numbers, so exact performance results aren't stated here.

Robot brains called vision-language-action (VLA) models take in camera images and spoken instructions and decide what the robot's arm should do next, but they are often too slow to keep up with the robot. Many speed-up tricks exist, but each had only been tested on one type of computer chip and a few models, so nobody knew if they worked everywhere. The researchers tested seven families of speed-up tricks on seven VLA models across four kinds of chips, from a huge data-center H100 down to a small Jetson Thor made for robots, and measured where the time actually goes. They found that the best trick depends on the chip and the model, and that tricks can help or hurt each other when combined, so they wrote a set of guidelines called VLA-Triage for choosing which ones to stack to hit a speed target.

This is a survey paper, so the author didn't build a new robot hand or run new experiments. Instead, Ji Pei read through the research on robot hands from January 2024 to early November 2026 and sorted it into five connected layers: the hand hardware, the data used to teach robots, ways to transfer skills between different robot hands, the AI models that learn the skills, and how everything gets tested. Three big lessons came out of it: videos of humans doing tasks only help a robot if the human hand movements, camera views, and touch contact line up well with the robot's (so more data isn't automatically better), even a shared 'language' for actions can't hide that each robot hand has its own limits in force, speed, and touch, and a robot finishing a task doesn't prove it did it correctly or is ready for real-world use. The paper also admits that nobody has solid proof yet that a contact-heavy skill (like turning a screw) can move to a very different robot hand without retraining, that these hands can run reliably for long stretches, or that touch sensors from different makers can work together.

Teaching a humanoid robot to move around real homes usually requires people to wear motion-capture gear or remotely control the robot for hours, and an hour of that work only produces an hour of training data. The researchers built a system called HALO that skips this by generating training data inside a computer simulation of a thousand randomly designed houses, so more data just takes more computing power instead of more human labor. In the simulation, the robot learned skills like sitting on chairs, walking to named objects, sidestepping through half-open doors, crawling under tables, and pushing boxes, and then chained them together for longer tasks. Even though it never saw a real home during training, it succeeded in 91% of 360 trials across six real-world environments it had never seen before.

MRI machines that run on very weak magnets could be small and cheap enough to roll into a clinic or ambulance, but their pictures come out grainy, and almost nobody has shared the practice data needed to teach AI to clean them up. The researchers built OpenULF, a free open-source simulator that creates realistic paired examples of noisy and clean scans, and used it to train 774 AI models on four sets of body images. They tested two kinds of sensors: expensive super-cold quantum sensors (SQUIDs) and cheap room-temperature coils. They found that the best sensor depends on the images being scanned and the magnet strength, with the quantum sensor's edge disappearing at around 450 microtesla. They also found that a smarter AI can make up for a cheaper sensor.

Robots with a sense of touch can use special sensors that act like tiny cameras inside a squishy fingertip, but until now, most robot brains just treated the touch data like a regular photo without knowing which parts of it actually mattered. These researchers split the touch signal into three separate types of information: how the contact looks, the shape and depth of the press, and how the surface slides and stretches (tracked by dots on the fingertip). After running 720 real robot tests, they found that adding touch raised the success rate from 57.8% to 78.9%, and that the sliding-and-stretching information was the most useful single type, reaching 74.4% on its own. They also found that processing each type of touch information separately worked better than mashing it all together.

Robots that follow spoken or written instructions often get distracted by things in the camera view that have nothing to do with the job, like background clutter, so they miss the object they're supposed to grab. The researchers built A³-VLA, a training method that automatically figures out where the important stuff is (the target object and the robot's own arm) by watching what changes in the video as the robot moves things around, then cleaning those spots up with an existing image-outlining tool. The robot is then trained to pay more attention to those spots and to link them to the words in the instruction. Unlike earlier approaches, this needs no extra human labeling, and it improved several different robot AI models, boosting success rates by an average of 6.5% to 25.2% across simulated and real-world tasks.

3D Gaussian Splatting is a way of capturing a real scene as millions of tiny fuzzy colored blobs, and a moving scene means a whole sequence of these blob collections, which takes up enormous amounts of storage. The researchers built GSCV++, a system that squeezes this data into flat 2D images and then compresses them with ordinary video codecs, the same kind of technology already used for streaming movies. They did this by trimming away redundant color information, arranging the blobs into smooth image layouts that video compressors handle well, and tuning the compressor settings for the content. Compared with the best existing methods, it delivered over 20% better compression quality for single frames and over 60% better for sequences, while also running faster at both creating the images and encoding and decoding them.

Face-unlock systems can be fooled by photos, videos, or masks, and the software that catches these fakes often just memorizes the quirks of the specific cameras and fake types it trained on, so it fails in new settings. The researchers built DINOFAS, which starts from a large pre-trained vision model (DINOv3) and teaches it to focus on what a real, live face looks like instead of cataloguing every possible attack. It also strips out clues tied to lighting, camera, and image style that confuse the system. When tested on a face dataset it had never seen, it got a 9.09% error rate (HTER, a combined measure of letting fakes in and locking real people out), and when trained only on computer-generated fake faces, it still scored best against four real-world datasets with a 21.41% error rate.

Normal cameras struggle to capture fast motion and tricky lighting (like a dark tunnel exit into bright sun) at the same time. The researchers built HIVE-Diff, an AI system that takes just one ordinary photo plus data from an 'event camera' (a special sensor that only reports which pixels got brighter or darker, thousands of times per second) and generates a whole smooth, high-quality HDR video from them. Earlier methods either used only the event data, which made colors and brightness drift, or needed a matching normal photo for every video frame; HIVE-Diff needs only one reference photo. Because real training data of this kind is scarce, they trained on synthetic data and then adapted the system to real event-camera footage using a teacher-student training trick, and the abstract reports strong results on both synthetic and several real-world datasets (no specific numbers are given in the abstract).

Robots can now 'imagine' the outcome of an action using video-prediction AI, but that imagination can be overly optimistic and pick moves that look great on screen but would actually be sloppy in real life. The researchers built a system called TIF that acts like a fact-checker: it only swaps in an imagined-best action when it's clearly better than what the robot already has AND a separate auditor, trained on pairs of imagined videos and real robot runs, says the prediction isn't likely to be overhyped. Otherwise it sticks with the real recorded data. Across four robot-learning test suites, this raised average success from about 73% to 76.25% (a 3-point gain) with the same amount of data and training, and on real robot videos it raised the share of cleanly completed tasks among chosen examples from 58% to 70%.

When you tell a robot arm to move its hand to an exact spot, a calculation called inverse kinematics figures out how every joint should turn, and doing this precisely is surprisingly hard and usually needs a lot of hand-tuned engineering. The researchers built PolicyIK, an AI system trained through trial and error (reinforcement learning) that learns to steer the arm's hand to a target and hold it there. In simulation, it landed within 1 millimeter and 0.2 degrees of the target on 93.5% of new tasks in a single try, rising to 98.9% with an extra deployment procedure. It also beat four traditional methods when trained on a real robot arm, and it carried out the commands of an existing robot AI model (π0.5) in simulated pick-and-place with 95.7% success. Unlike older methods that need careful manual tuning, this one learns the needed precision on its own.

Phone cameras capture raw sensor data that looks dull and noisy until a processing step called an ISP turns it into the polished photos we see. The researchers ran a competition (Mobile AI 2026) where teams built AI models to do this job, then tested them on real phone chips from Qualcomm (Snapdragon 8 Elite Gen 5) and MediaTek (Dimensity 9500). They trained the models on a big set of paired photos: raw data from a phone sensor matched with pro-quality images from a 102-megapixel Fujifilm camera. The best entries turned raw data into a high-quality 5-megapixel photo in under 100 milliseconds (a tenth of a second) on both phone chips, showing that AI-based photo processing is now fast enough to run on a phone's graphics chip.

Today's smartest robot AI models are so big that they think slowly, which makes robots sluggish when they need to react quickly. The researchers built a system called Asynchronous Robot Policy (ARP) that splits the work in two: a big, slow 'thinker' model looks at the scene and updates its notes only occasionally, while a small, fast 'doer' model reads those notes and controls the robot's movements many times per second. They also trained the fast model to cope with notes that are a little out of date, since the thinker is always running behind. On robot-arm tasks, ARP succeeded 18% more often and finished 20% faster than the standard approach, scored 3-5 times better in fast-moving simulations, and kept working well even when the big model ran 10 times less often.

MRI machines normally need huge, expensive magnets, but very weak-magnet versions could be small and cheap, if only their blurry, noisy pictures could be cleaned up. The researchers built OpenULF, a free, open-source software toolkit that simulates these weak-magnet scanners and generates practice data so AI models can learn to clean up the images. They compared two kinds of sensors, ultra-sensitive but super-cold SQUID sensors and cheap room-temperature copper coils, by training 774 AI models on four sets of body-scan images. They found that the sensor that wins depends on the magnet strength and the kind of images being scanned (SQUIDs win below roughly 450 microtesla, coils above), and that a smarter AI can make up for a cheaper sensor.

Robots that must stay safe, like self-driving cars or drones flying in wind, can use a heavy math method that maps out every situation that would inevitably lead to a crash or failure. Until now, that calculation was too slow to run while the robot was moving, so it had to be done ahead of time. The researchers wrote new code for graphics chips (GPUs) that does this calculation in real time, updating about 112 times per second on a regular workstation and 66 times per second on a small robot-sized computer, which is up to 17 times faster than the best existing tool. They also showed it can steer six drones through a simulated wildfire response at once, working out which drone should handle which spot in just 4 milliseconds per update.

Teaching a robot by demonstration usually means a human operator spends hours controlling it to collect examples, and nobody checks whether those examples actually help until afterward. The researchers built GUILD, a system that works like a coach: an AI that understands images and language suggests what the robot should practice next (such as which objects and setups to try), and a scoring method then estimates how much each new example improves the robot's skills on its real target job. That score feeds back into choosing what to collect next, repeating in a loop. The abstract reports that this guided approach made better use of each demonstration and improved performance in simulation and on real robots compared to collecting data without guidance, other baseline methods, and even experienced roboticists, though it does not give specific numbers.

Researchers built ProAlign, an AI system that can recognize the same person in photos taken from a drone high above and from a regular security camera on the ground, two views that look wildly different. They fixed two hidden problems: the AI gradually loses track of where things are in an image as it processes it step by step, and it describes the same person differently depending on the viewing angle. Their fix adjusts how the AI tracks position at each processing stage, and it also keeps separate 'reference profiles' for each person's drone view and ground view, then trains the AI to make those profiles agree. On the CARGO benchmark, a test set of drone and ground footage, ProAlign beat the best existing methods by 1.60% in top-match accuracy and 5.01% in overall retrieval quality.

Some cameras and scientific sensors only record how bright light is, not its 'phase' (the timing of the light waves), and without that missing piece it's very hard to rebuild a clear picture, especially a color photo with noise in it. The researchers built FlowFPR, which combines a pretrained AI image model (a 'Flow Matching' model that knows what natural faces look like) with a math routine that keeps checking the guess against the real measurements. Unlike earlier methods that use slower 'diffusion' AI models and get worse as the noise increases, FlowFPR needs just one quick AI prediction per round and adds smart tweaks that decide how much to trust the AI versus the measurements. In tests on face images, the best version produced the highest average image quality at both noise levels tested, and it ran faster from start to finish than the diffusion-based competitors on the same hardware. The paper's abstract gives no exact numbers for the quality or speed gains.

Researchers in Japan built the Desktop Amid Touch (DAT) screen, a stretchy, see-through mesh that a cartoon-style character is projected onto so you can actually poke it and feel it push back. Their first version could detect one finger touch and work out where and how deep you pressed by measuring tiny changes in how tight the fabric was. The second version added motors that tighten or loosen the screen, so the 'skin' can feel soft or firm. The paper describes the machine and what it did in demonstrations, but it does not test how real people react, and it raises an open question: should a touchable virtual character be able to 'refuse' being touched by getting stiffer?

The researchers built MS-DOTT, a big collection of sensor recordings gathered by driving a robot vehicle over rough, off-road terrain in normal light, dim light, and total darkness. The vehicle carried many different sensors at once: long-range 3D scanners to see the big picture far ahead, close-range high-detail cameras to inspect the ground right in front of it, 4D radar that also measures how fast things are moving, and internal sensors that feel how the vehicle bumps and tilts as it drives. Most earlier datasets capture only some of these views or only good lighting, so robots trained on them struggle when conditions get tough. To show the data is useful, the team took an existing top-performing method for combining sensor inputs and adapted it to predict which patches of ground a vehicle can safely drive over. The abstract describes this as a demonstration of usefulness and does not report specific accuracy numbers.

A robot with a camera needs to know exactly where the camera sits relative to its arm, and also how far the camera's pictures lag behind the arm's position readings, or its movements will be slightly off. The researcher built SyncHeC, a method that figures out both at once by having the robot do one short 6.5-second movement while a computer program keeps adjusting its guesses until a virtual picture of the robot matches the real camera image, with no printed checkerboard or special stickers needed. It found the camera's position to within about 0.2 centimeters and the timing delay to within 2.7 milliseconds (out of 87 ms), roughly 3.7 times more accurate on position and 2.3 times more accurate on timing than the best earlier method it was compared against. When robots were trained and run with the corrected timing, they succeeded 8.1 percentage points more often across 1,800 matched tests.

Face-unlock systems can be fooled by photos, video replays, or masks, and most detectors fail when the lighting, camera, or type of fake changes. The researchers built DINOFAS, which starts from a powerful pre-trained vision model (DINOv3) and lightly retunes it to learn what a real, live face looks like, rather than memorizing the tricks of specific fakes. It also strips out camera- and lighting-specific appearance so the model focuses on liveness itself. When tested on faces from camera and lighting setups it had never seen, it made mistakes about 9.09% of the time on average (a standard benchmark called OCIM). Trained only on computer-generated fake faces, it still beat competing methods on four real-world datasets, with 21.41% average error and 86.14% AUC (a score where 100% means perfect).

Normal cameras struggle to capture fast motion and very bright and dark scenes at the same time, so researchers built a system called HIVE-Diff that fixes this using two inputs: one ordinary photo and a stream of data from an 'event camera' (a special sensor that only reports which pixels got brighter or darker, thousands of times per second). Instead of needing a separate good-quality photo for every video frame like earlier methods, HIVE-Diff uses one photo as a reference and has an AI video generator fill in a whole smooth, high-quality, high-contrast video using the event data as a guide. Because real training data pairing these sensors is rare, they trained mostly on computer-made data and then taught the model to handle real cameras by having a 'teacher' AI coach a 'student' AI. The abstract reports strong results on synthetic and several real-world datasets, but gives no specific numbers, so exact performance gains over earlier methods aren't stated.

Robots that use 3D laser scanners to recognize objects often get confused when conditions change, like switching to a different sensor or dealing with noisy, messy scans. The researchers built 3D-BBDA, a method that helps an existing recognition system adapt to these new conditions without ever looking inside it or seeing the data it was originally trained on, and without any slow retraining. It only watches the system's answers, guesses labels for new unlabeled scans, and uses those guesses to fix its mistakes, even when some guesses are missing or wrong. On a standard test of corrupted 3D shapes (ModelNet-40C), it cut error rates from 35.88% to 32.08% for one popular model (PointNet) and from 34.03% to 29.62% for another (GDANet), beating the previous best black-box method, which scored 33.78% and 32.36%.

Researchers built GazeTags, tiny $2 electronic stickers you can put on everyday objects so that smart glasses or earbuds know what you're looking at, without using any cameras. The glasses send out a narrow beam of invisible infrared light in the direction your head is pointing, and only the tags caught in that beam wake up and reply with their ID and, if needed, extra info like whether a device is on or a sensor reading. Each tag can run for more than a year on a coin battery. Because there's no camera or image-recognition software, the system uses very little power, which suits small wearables, and it avoids the privacy worries of devices that constantly film what's around you.

Robots that need to avoid or follow people have to figure out how far away each person is, and doing that with just one ordinary camera is hard. The researchers built MoSoLoco, a system that reuses the visual information the robot's body-tracking software already computes (the same software that finds stick-figure skeletons on people), instead of throwing it away or adding a second heavy vision system. It can also look at other people in the same photo to fix up each person's estimated position, since people tend to stand in predictable ways around each other. On the JRDB and NuScenes datasets, this cut position error by about 23 percent compared to the best competing skeleton-only method, and it runs fast enough on a small Jetson AGX Xavier computer designed for robots.

Computer chips normally do math by passing 'carry' digits down a long chain, which slows things down, and a trick called redundant number systems avoids this by letting each digit have extra possible values. The older version of this trick (MRSD) uses both positive and negative digits, which makes multiplication clumsy and expensive. These researchers built a new version called MRUD that uses only positive digits and works in higher 'gears' (grouping several bits at a time), and it works for both signed and unsigned numbers like ordinary binary. In chip simulations, MRUD multipliers were up to 30% faster, 26% smaller, and used up to 87% less power than MRSD, and in chains of multiply-and-add operations it delivered up to 64% more throughput than an industry-standard commercial design (DesignWare) and over 150% more than the classic Wallace design.

The researchers built TAMPAgent, a robot planning system that pairs an AI model that can see and reason about images with the kind of step-by-step logic classic robot planners use. Instead of letting the AI just 'call' robot tools one at a time and hope for the best, it first sketches a rough plan that includes moments where the robot should stop and look around, then uses traditional search methods to fill in the details and checks that every move is physically possible (like whether an arm can actually reach something). The robot keeps a running memory of what it has seen, updates its guesses after each action, and replans as it learns more. Tested on household chores with two real robots, the Rainbow Y1 and Unitree G1, it significantly outperformed AI-only approaches, which tended to fail when the robot couldn't see everything in the room; the abstract does not report specific numbers.

MRI machines that run on very weak magnets could be small and cheap enough to roll into a clinic or ambulance, but their pictures come out grainy, and there was no shared way to test whether AI could clean them up. The researchers built OpenULF, a free software toolkit that simulates these scans with two kinds of sensors (super-sensitive but ultra-cold SQUID sensors, and cheap room-temperature coils) and generates matching 'noisy vs. clean' image pairs to train AI. Using it, they trained 774 AI models on four sets of anatomy images and found that how well AI helps depends on both the sensor and the images, and that the cheap coils start beating the cold SQUID sensors at around 450 microtesla. Their big takeaway is that you can't just pick the sensor with the best signal; you have to choose the sensor and the AI together.

The researchers built MISLAM, a navigation system that lets a robot figure out where it is and build a map using only a motion sensor and a ring of nine compass-like magnetic sensors, with no cameras or lasers needed. It works because buildings and underground spaces have their own unique magnetic 'fingerprints' (from steel beams, wiring, and so on), so the system learns those patterns and uses them to correct the small errors that pile up when you track movement over time. In tests with a handheld rig in three indoor spaces, MISLAM cut the position error at the end of a route by 46% to 78% compared to the same system without the map-correcting step. In a dark room where camera-based navigation completely failed, MISLAM kept tracking and ended just 0.33 meters off horizontally, though it still drifts up and down more than the researchers would like.

Researchers built a robot fingertip sensor called ToFTouch that lets a robot 'see' how close an object is before it touches it, using tiny light-based distance sensors (the same kind of technology used in phone cameras to measure distance), plus a pad that feels pressure once contact happens. They attached it to a two-finger robot gripper and tested it on three jobs: adjusting its grip before grabbing something, pulling an item out of a messy pile, and sliding an item into a tight space. Because the gripper could start closing while it was still approaching, grabbing tasks got 7.4% faster, and it successfully pulled items out of clutter even when its aim was off by up to 2 cm in either direction, including cases where the robot without the sensor failed. What makes this different from earlier approaches is that the robot gets useful information before contact, rather than only reacting after it has already bumped into something.

The researchers built PanoTac, a squishy robot fingertip that costs under $50 and can feel both where something is touching it and how hard it's pushing or sliding, much like the sense of touch in your own fingertip. Each fingertip gives the robot a detailed touch map (a 12 by 32 grid of tiny sensing spots, each reporting pressure and sideways pull) 60 times per second. When they combined this touch sense with a camera and used it for tricky jobs like preparing test tubes, scooping grains with a spoon, and pouring salt, robots using touch succeeded far more often than robots relying on vision alone, with an average improvement of 46.7 percentage points. They also showed that taking away either the touch map or the sideways-force sensing made the robots worse, so both are important.

Researchers built a method called D&A (Describe & Assess) that lets an off-the-shelf AI model that understands images and text judge how far along a robot is in finishing a task, without any extra training. Normally these AI judges are fooled by their own assumptions: they tend to assume a robot is succeeding and give it credit even when it fails, or they just say 'done' or 'not done' instead of giving nuanced scores. D&A fixes this by splitting the job in two: first the AI writes a plain-language description of what is happening in the video and what success would look like, then it grades the robot against a clear scoring checklist. The abstract does not give specific numbers, but the authors report that this simple prompting trick matches or beats rival systems that were expensively retrained on real robot data, and that its scores work well for teaching robots through trial and error.

Satellite and aerial images can be compared over time to spot how land has changed, like a forest becoming a parking lot, but most existing AI systems only work for a fixed list of change types decided in advance. The researchers built HyperFlow, a system that can learn new, more detailed types of change over time (for example, splitting 'vegetation' into 'forest' and 'grassland') without forgetting what it already knew. It works by organizing land types in a curved mathematical space that naturally mirrors how categories branch into sub-categories, and it flags a change when a location's label 'flows' in an unexpected direction between two images. They also released HiChange, a large high-resolution dataset with detailed layered labels, and found that learning categories gradually, from broad to fine, detects changes better than learning all the detailed categories at once. The abstract reports this as a qualitative result and does not give specific numbers.

Researchers built ForceLDM, a system that helps robots handle tricky jobs where touch and pressure matter, like inserting parts or pushing things into place. Normally a robot using only a camera can't tell how hard it's pressing or what's about to happen on contact. The team trained a 'teacher' model that was allowed to peek at the future (the forces and motion that actually happened next), then taught a 'student' model to predict those future forces and motions using only what the robot can sense right now. At run time the robot needs no peeking, yet it can anticipate contact before it happens. The abstract reports that it beat state-of-the-art methods on five real-world tasks, worked with new objects, and held up when the environment was disturbed, but it doesn't give specific numbers, so exact performance gains can't be stated here.

Researchers took an AI model that learned to read satellite images (both radar and regular photos) without needing human labels, and tested how well it runs on ordinary, cheap computers instead of expensive specialized chips. They tried it on three everyday x86 machines, from a weak low-power one to a more modern one, using three levels of number precision, including a compressed 8-bit version called INT8. The compressed version was just as accurate as the full-size one (the difference was only 0.0006, smaller than normal run-to-run wobble), yet it ran up to 1.45 times faster even on the oldest chip and used less energy. They also found that on the weakest computer, its built-in graphics chip was 4.38 times faster than the main processor, but on better computers the main processor became the smarter choice.

Researchers had people lift weights while wearing an exosuit, a soft wearable device that helps the elbow muscles do the work, and then tested more than just how tired the muscles got. They checked how heavy things felt, how well people adjusted when the situation kept changing, and whether people decided a lifting task was worth the effort. The suit did reduce muscle activity, but that didn't tell the whole story: things felt lighter, though how much lighter depended heavily on what people experienced first, and the suit made people worse at adapting to changing conditions. Whether people chose to do the lifting also depended on their first experiences, not simply on how much their muscles were relieved. The surprise is that measuring muscle savings alone, which is how most exosuits are judged, can't predict how users will feel, adapt, or choose to act. The summary above is based only on the abstract, which doesn't give specific numbers.

Big robot arms, like the long hydraulic ones used on heavy machinery, bend and wobble a little when they move, but most robot controllers pretend the arm is perfectly stiff, so the robot's idea of where its hand is ends up wrong. These researchers figured out which wobbles matter most, then showed that you only need as many small motion sensors as there are important wobbles, plus one extra reference sensor, to rebuild how the whole arm is bending. They used that to calculate where the arm's tip really is and to steer it, and on a long two-link hydraulic arm their method located the tip within about 1 centimeter (0.0107 m and 0.0194 m in position, 0.0102 rad in angle) while using fewer sensors than the older approach of treating the arm as a chain of stiff pieces. They also ran it live in real reaching tests, showing the system can sense the bending and correct for it in real time.

Teaching robots to help in surgery requires huge amounts of well-organized data, like video, robot movements, and sensor readings, but collecting it is expensive, hard to repeat, and usually tied to one specific lab setup. The researchers built Sensorium, a free, open-source software toolkit that records data from many different robots and sensors at once, cleans it up, lets people label what's happening, and packages it into neat, ready-to-use training sets. They tested it on 1,516 recordings from experiments on fake tissue (phantoms), tissue taken from animals, and live pigs, covering several surgical tasks and equipment setups, and gathered early feedback from users. Unlike earlier approaches that were custom-built for a single machine, Sensorium is designed to work with whatever hardware a lab happens to have.

Today's best robot-learning methods work like sculptors starting from a block of random noise and chipping away at it over many small steps until a clean movement plan appears, which takes time and can leave the plan slightly out of date by the time the robot acts. The researchers built a system called DMAT that skips the chipping and predicts the finished two-armed movement plan in a single step, using the robot's 3D camera view and its current arm positions. Across 567 test trials per method, including tricky unfamiliar situations, DMAT succeeded 129% more often than a method called IDP3 and 96% more often than one called DiTFlow3D, while producing movement plans 2.06 times and 1.34 times faster. It also kept working when someone repeatedly shoved the robot with 50 newtons of force, about the weight of a 5 kg bag of flour.

Researchers built RoboArchitect, a system where an AI coding model watches a robot try (and fail at) tasks, figures out what went wrong, and rewrites the 'wrapper' code around the robot's brain to fix it. The robot's brain itself is never retrained or changed; only the surrounding code that decides when to use the brain, when to look at things with cameras, and when to just move the arm directly gets improved. On new scenes the robot hadn't seen, success jumped from 9.7% to 43.3%, and on new tasks it went from 12.7% to 40.2%. The system even invented smart tricks on its own, like lifting a stuck arm clear or reaching in sideways when something blocks the top, and built a memory so it could remember lessons like how deep to grab an object. Before this, people had to hand-build this wrapper code separately for every new robot or test.

Computer chips normally do math by passing 'carry' digits down a long chain, which slows things down, and a trick called redundant number systems avoids this by letting each digit have extra possible values. The older version of this trick (called MRSD) uses both positive and negative digits, which makes multiplication clunky and costly. The researchers created MRUD, the first version that works with only non-negative digits while still handling bigger 'chunks' of numbers at a time, and it can represent both signed and unsigned numbers like regular binary. In chip simulations, their multipliers used up to 30% less delay, 26% less area, and 87% less power than the older approach, and their multiply-accumulate units (the basic building block of AI and signal processing) ran up to 64% faster than an industry-standard design and over 150% faster than another common design.

The researchers built a mapping system that lets a robot quickly work out how far away every nearby obstacle is, which robots need in order to plan safe paths. Instead of recalculating everything from scratch, their software uses the graphics chip (GPU) to update only what changed whenever new sensor data arrives, while still remembering everything the robot has seen before. They tested it on recorded datasets and found it beat the best existing robot mapping systems, especially when the robot is exploring places it has never been. They also ran it on real drones and ground vehicles, where it kept up in real time on small, low-power onboard computers. The abstract doesn't give exact speed or accuracy numbers, so the size of the improvement isn't specified here.

Researchers taught a humanoid robot to get back on its feet after falling down underneath something low, like a table or a shelf, where the old trick of just standing up would make it bump its head and get stuck. Their system, called ROOF, uses trial-and-error learning with a special reward that pays the robot for gradually pushing itself out from under the obstacle, without telling it exactly how to move. This let one learned controller figure out when to make room, how to brace its arms and legs, and when to finally stand, using only its own sense of body position and no cameras. In simulation it recovered 88.5% of the time under plates it could only push up, versus 18.9% without that special reward, and on a real Unitree G1 robot it got up in 95 of 150 tries across seven setups, including furniture it had never seen during training.

AI coding assistants now work on software projects for hours or days with almost no one watching, so the researchers asked a simple question: what did the AI actually do, and is the job really finished? They studied 45 real AI coding sessions (over 100,000 records) and found that about 23% of the AI's editing rounds ended with nobody checking the result, and that 58% of the to-do items the AI ticked off as 'done' had no proof of completion. They also found that 1,326 records contained password-like secrets and that nearly half of the saved conversation text was too long for common viewing tools to replay. To fix this, they designed Soei, a tamper-evident logbook that records who did what and keeps 'the AI says it's done' separate from 'someone proved it's done,' while using only 20% of the storage and storing no actual code or passwords.

Researchers built a knee exoskeleton, a wearable robotic brace that helps your leg muscles when you squat, using cheap off-the-shelf parts and common fabrication tools. Normally, the software that tells these devices how much to help has to be trained by recording people wearing that exact device, which is slow and has to be redone for every new machine. Instead, the team trained their software entirely inside a computer simulation of human muscles and bones, so no recordings from the real device were needed. When seven healthy volunteers wore it, the exoskeleton reduced the peak turning force their knee muscles had to produce by 21.5% and cut the activity of a major thigh muscle (the vastus medialis) by 26.7% during squats.

Researchers took an AI model that has learned to read satellite images (both radar and regular camera photos) and tested how well it runs on ordinary, cheap computers instead of expensive specialized chips. They shrank the model's math from precise decimal numbers down to simple whole numbers (called INT8 quantization), and this made the model run up to 1.45x faster on a weak processor with no accuracy loss, since the score changed by just 0.0006, less than normal random variation. They also found that on the weakest computer, the built-in graphics chip was 4.38x faster than the main processor, but on stronger computers the main processor became the better choice.

Researchers built LogicTree, a writing helper that plugs into Overleaf (a popular tool scientists use to write papers). Instead of chatting back and forth with an AI and getting walls of text, you work with 'writing objects,' like building blocks for your ideas that sit in a tree-shaped outline. The AI can edit these blocks, and a review feature checks whether each part makes sense on its own and whether the whole paper holds together. In a small test with 12 people, each person tried both LogicTree and a regular chatbot-style helper, and LogicTree helped them organize ideas, felt less mentally tiring, and produced writing with better logic. The abstract doesn't give exact numbers, and the study was small and done under controlled conditions, so the results are early evidence rather than proof.

Event cameras are special sensors that only record changes in brightness, which lets them see well in very dark or very bright scenes, but they have no color information at all. The researchers built EventSeeColor, an AI system that first turns the camera's data into a black-and-white picture, then uses that picture along with the raw brightness-change signals to guess realistic colors, using a type of image-generating AI called a diffusion model. The key idea is that how and when a pixel fires depends on the color and material of the surface, so the signals contain hidden color hints that past methods ignored. On two real-world event datasets, it scored best among the outside methods they compared against for structural similarity, perceptual quality, and color accuracy in colorful regions, though the abstract gives no specific numbers.

Passwords are a hassle for lots of people, so these researchers tested whether your heartbeat could replace them. They surveyed 337 adults about how they log in today and whether they'd trust heart-based (ECG) login, then had 49 people try a mock health-care app that let them unlock it with a simulated heart scan or a regular password, followed by a questionnaire about the experience. Unlike most earlier ECG research, which focuses on how accurate the technology is, this pilot study asks what real people think of it, including how different age groups feel about security, convenience, and trying it themselves. Note that the abstract describes what was measured but does not report the actual results, so we can't say yet how people rated it.

Researchers built BURGER, a test where a robot arm starts with a blank page and has to draw whatever a text instruction asks for, like a specific object or a scene with things arranged in certain positions. Because there are many valid ways to draw the same thing, the test can show whether AI robot-control models really understand language or are just memorizing movements. They trained and compared five leading robot AI models on 28,200 simulated drawing demonstrations covering 282 different tasks, and found that some of the models got better as they saw more varied tasks and more examples, could draw in several different valid styles, and could draw new combinations of objects they had only seen separately before. They also put one trained model on a real Franka Panda robot arm, where it kept drawing sensibly even when a person interrupted it mid-drawing.

The researchers built StreamStudio, a prototype tool that lets people steer an AI video generator while it is still making the video, instead of typing a prompt, waiting for the whole clip, and then fixing mistakes afterward. While the video unfolds, a creator can guide what happens next, jump back to an earlier moment, and try out different continuations from that point. It works as a plug-and-play layer that can sit on top of different video-generation and editing models, so it can improve as those models get faster and easier to control. The abstract describes the interaction design and the new way of working rather than reporting benchmark numbers, so there are no specific performance results to quote.

Robots that need to decide 'stop or keep going' around people often use a single camera to figure out where pedestrians are, but most tests only check how accurate the position estimates are, not whether the robot made the right stop/go call. The researchers built a way to split blame for wrong decisions between the safety rule itself and the camera-based perception, and tested it on about 900 pedestrians from public walking videos. They found that a simple rule using only side-to-side distance never missed a real danger (when given perfect positions) but was right only 6-32% of the times it hit the brakes. With real camera perception, the biggest problem wasn't bad distance estimates (their calibrated method was off by about half a meter) but failing to see pedestrians at all, since the detector caught only 26-43% of them.

Robots that roam homes build maps of what's around them, but those maps don't say how a door or drawer will actually feel when pulled: stiff, loose, sliding, or swinging. The researcher built PhysVLMM, which gives every door and drawer in the map a 'best guess plus how unsure I am' about its physical behavior, and shares what the robot learns from one pull with similar-looking parts it hasn't touched yet. Tested on real doors and drawers in 18 homes, it correctly identified the joint type 86% of the time (versus 48% for a competing method) and predicted how a pull would play out with 41% less error than a physics simulator, in 13 milliseconds instead of 230 seconds. It can also say 'this will probably work' or 'I'm not sure, so I won't try,' and its mistaken 'safe' calls stayed within the risk limit set for it.

Computer chips normally do math by passing a 'carry' from one digit to the next, like carrying the 1 in long addition, which slows things down. A trick called redundant number systems skips the carrying, but the best-known version (MRSD) stores numbers using both positive and negative digits, which makes multiplication clunky. The researchers built a new version called MRUD that uses only positive digits, works with bigger digit groupings, and supports both signed and unsigned numbers like ordinary binary. In simulated chip designs, their multipliers were up to 30% faster, 26% smaller, and used up to 87% less power than MRSD, and their multiply-and-add units reached up to 64% higher throughput than a leading commercial design (DesignWare) and over 150% higher than a standard Wallace-tree design.

A researcher built an AI system that looks at brain scans to tell whether a stroke was caused by a blood clot (ischemic) or by bleeding (hemorrhagic), mimicking how an emergency room sorts patients. On the data it was trained on, it scored an impressive 95.48% accuracy-style grade (F1-score), but when tested on brain scans from completely different hospitals and scanners, performance crashed to about 58-62%. The AI was also good at being right when it called a clot (77% precision) but missed many real clots (only 57% caught), often mistaking them for bleeding. The study's big contribution is honestly exposing this 'internal validation illusion,' where AI looks great on familiar data but stumbles on new equipment, and identifying one combination of image-reading models (DenseNet201 + ViT) as the most consistent performer across repeated tests.

Teaching a robot hand to do delicate tasks usually means a person has to remote-control the robot over and over, which is slow. The researchers built TouchBridge, a system where a person wears a special glove-like device with touch sensors in the fingertips and does the task normally, and software then translates what the person did (including where their fingers touched things) into training data a robot can learn from. A key piece called Tac-Retarget uses the actual touch readings to match human fingertips to robot fingertips, so it doesn't need 3D models of the objects or a physics simulator. Robots trained only on this converted human data succeeded 72.5% of the time on four tricky real-world tasks, close to the 77.5% from robots trained on remote-controlled demos, while collecting the human demos was 7 times faster.

The researchers built HiFOR, a system that helps a robot 'imagine' what will happen next before it moves. Unlike earlier approaches that guess only the next few moments or only the final goal, HiFOR predicts three things at once: what happens right away, the key steps along the way (like 'grab the cup, then lift it'), and what the finished scene should look like. As the robot works out its motions, it looks back at this imagined future and pulls out only the pieces that matter for the move it's making right now, instead of feeding in all its predictions at once. They tested it on two simulation benchmarks and six real-world robot manipulation tasks and report that it works well, though the abstract doesn't give specific numbers for how much better it did.

AI coding assistants now work on software for hours or days with little supervision, so the real question becomes what they actually did and whether the job is truly finished, not just what they said. The researchers studied 45 real coding sessions (over 100,000 records) and found that about 23% of the agent's code-editing rounds ended with no check that the code worked, and that 58% of to-do items the AI marked 'done' had no proof of completion. They then built Soei, a tamper-evident logbook that records what the AI did, keeps 'I claim it's done' separate from 'here's proof it's done,' and stores no private content or passwords, so it takes up only 20% of the raw log size. Unlike earlier monitoring tools, which they also audited and found had gaps such as an unprotected local control panel, Soei treats evidence and intent as first-class records you can verify later.

Researchers built LogicTree, a writing tool that plugs into Overleaf (a popular program scientists use to write papers) and treats parts of a paper, like claims, arguments, and sections, as building blocks that both the writer and the AI can see, move, and edit. Most AI writing helpers today just trade chunks of text back and forth in a chat, which forces writers to dig through the AI's output to figure out whether it fits their plan. LogicTree instead keeps the paper's structure visible as a tree and can flag spots where the argument doesn't hold together. In a small test with 12 people, each of whom used both LogicTree and a regular chat-style assistant, LogicTree helped them organize their ideas, felt less mentally demanding, and produced writing that scored higher on logical quality. The authors say this is early evidence, since the test was small and the writing tasks were tightly controlled.

Event cameras are special sensors that only record changes in brightness instead of full pictures, which lets them work in very dark or very bright scenes, but the images people rebuild from them are black-and-white. The researchers built EventSeeColor, an AI system that takes a rebuilt grayscale image plus the raw stream of brightness changes and uses a diffusion model (the same family of AI behind many image generators) to guess the scene's true colors. Their key idea is that the timing and pattern of those brightness changes quietly carry hints about color, because different surfaces and lights trigger the sensor differently, even though the camera itself is color-blind. The abstract doesn't give exact scores, but on two real-world event datasets it beat other comparable methods on structure, perceptual quality, and color accuracy in the colorful parts of images.

Passwords are a pain for lots of people, so these researchers tested whether your heartbeat could replace them. They surveyed 337 adults about how they log in and how they feel about options like fingerprints and face scans, then had 49 people try a mock health-care app that let them log in using a simulated ECG (the electrical signal your heart makes) or a regular password, and fill out a questionnaire afterward. The abstract describes the study design and what was measured, such as security views, convenience, and willingness to adopt ECG login, but it doesn't report specific results, so we can't say yet how people actually rated it. What makes this different from earlier ECG work is its focus on real people's opinions and experience, not just whether the technology can identify someone accurately.

Researchers built BURGER, a test where a robot arm starts with a blank canvas and has to draw whatever a text instruction describes, like a specific object or a scene with things arranged in certain positions. Because there are many valid ways to draw something, the test shows whether a robot AI truly understands the words rather than just copying memorized motions. They trained and compared five leading robot AI models on 28,200 simulated drawing demonstrations covering 282 different tasks, and found that some models get better as they see more varied tasks and more examples, can learn multiple valid ways to draw the same thing, and can even draw new combinations of familiar objects they were never shown together. They also put a trained model on a real Franka Panda robot arm, which kept drawing sensibly even when a person interfered mid-drawing.

The researchers built StreamStudio, a prototype tool that lets people steer an AI-generated video while it is still being made, instead of typing a prompt, waiting for the whole clip, and then fixing mistakes afterward. While the video unfolds, a creator can guide what happens next, jump back to an earlier moment, and try different versions of how the story continues. The paper doesn't report benchmark numbers or test results. Its contribution is the new way of working and the controls that make it possible, and it is built as a plug-in interface that can sit on top of different video-generation models as they get faster and better.

Robots that move near people need to decide, over and over, whether to stop or keep going, and most research only checks how accurately a camera can pinpoint where a person is. These researchers instead asked where the wrong stop-or-go decisions actually come from: the rule the robot uses, or the camera's mistakes. Using video of real pedestrians and a simulated robot, they showed that a simple rule based only on side-to-side distance never missed a real danger when given perfect positions, but it stopped the robot unnecessarily most of the time (only 5.6-31.9% of its stops were truly needed). When they used an ordinary single camera, the biggest problem was that it often failed to spot people at all (it found only 26-43% of them), and a method that estimates positions on the ground was off by about half a meter, much better than a basic geometric approach (1.4-1.7 m) and a popular depth-estimation AI (0.7-0.8 m).

Robots that map a home usually record what each object is, but not how a door or drawer will actually feel and move when pulled. Researcher Dibyendu Ghosh built PhysVLMM, a system that gives every door and drawer in a robot's map a running guess about how it behaves, including how unsure that guess is, and that shares what it learns from one pulled drawer with similar-looking ones nearby. Tested on real doors and drawers in 18 homes, it correctly identified how a part moves (a hinge versus a slider) 86% of the time versus 48% for a learned single-camera method, and it predicted the response to a pull with 41% less error than a physics simulator while running in 13 milliseconds instead of 230 seconds. It can also tell the robot whether an action is safe enough at a chosen risk level, or say "I don't know" instead of guessing.

Computer chips normally add big numbers by passing 'carry' digits down the line, which slows things down, and a trick called redundant number systems avoids that by using extra digits, though the usual version uses both positive and negative digits that make multiplication clunky. The researchers created a new number system called MRUD that uses only positive digits, and it works for a wide range of number sizes while keeping carry-free addition. In computer simulations of chip designs, their multipliers used up to 30% less delay, 26% less chip area, and 87% less power than the older signed-digit approach. For repeated multiply-and-add work, their design delivered up to 64% more throughput than an industry-standard commercial design (DesignWare) and over 150% more than a classic design called Wallace.

A researcher built an AI system that looks at brain scans to tell apart two kinds of stroke: ones caused by a blocked blood vessel and ones caused by bleeding. It works like an emergency-room triage process, combining two types of image-reading AI that share information with each other. On the data it was trained on, it scored an impressive 95.48%, but when tested on scans from other hospitals and scanner types, its score crashed to about 58-62%. The big discovery is that the AI had been fooled by quirks of the original scanners instead of really learning stroke patterns, and it also tended to wrongly call blocked-vessel strokes 'bleeding' (catching only 57% of them), which could lead to the wrong treatment.

Teaching robot hands to do delicate tasks usually means a person has to steer the robot by remote control, which is slow. The researchers built TouchBridge, a system where people wear a special glove-like device with touch sensors on the fingertips, and software called Tac-Retarget then translates what the human fingers felt into movements the robot's very different-looking hand can copy. Robots trained only on these converted human demonstrations succeeded 72.5% of the time on four tricky real-world tasks, almost as well as robots trained on remote-controlled demonstrations (77.5%), while collecting the human demonstrations was 7 times faster. Unlike older methods, it doesn't need a 3D model of the object or a physics simulation, and it beat two competing methods by 25 and 42.5 percentage points.

The researchers built HiFOR, a robot brain that predicts the future at several time scales at once: what the scene will look like in the next moment, the key checkpoints along the way (like 'cup grasped' or 'lid opened'), and what the finished task should look like. Earlier systems usually treated short-term and long-term predictions separately, and they fed all the predicted futures into the robot's action planner whether or not those details mattered for the move being made. HiFOR instead organizes its predictions into a searchable 'memory of the future' and, while the robot works out each movement, pulls out only the future details relevant to that exact movement. The abstract says it works well on two simulation benchmarks and six real-world manipulation tasks, but it gives no specific numbers, so exact performance gains over other methods can't be stated from this text alone.

AI coding assistants now work on software for hours or days with almost no one watching, so the researchers asked a simple question: what did the AI actually do, and is the job really finished? They studied 45 real AI coding sessions (over 100,000 records) and found that about 1 in 4 times the AI edited code and then never checked its own work, and that more than half of the to-do items the AI marked 'done' had no proof between the edit and the checkmark. They also found that 42% of sessions run longer than a day, and that passwords and keys had leaked into the logs in 16 sessions. To fix this, they designed Soei, a tamper-evident, privacy-safe logbook that records who did what and keeps 'the AI says it's done' separate from 'someone proved it's done,' while taking up only 20% of the space of the raw logs.

Researchers took an AI model that learned to read satellite radar and regular photo images on its own, and tested how well it runs on ordinary computer chips, the kind found in basic PCs, instead of expensive specialized hardware. They shrank the model's math from detailed numbers to simple whole numbers (called INT8 quantization), and the model's accuracy barely changed (a difference of just 0.0006, smaller than normal run-to-run noise). The shrunken version ran faster on every machine tested, including 1.45x faster on an old chip lacking modern speed-up features and 1.53x faster on a newer one. They also found that on the weakest computer the built-in graphics chip beat the main processor by 4.38x, but on better computers the main processor became the best choice.

Researchers built LogicTree, a writing tool that plugs into Overleaf (a popular program scientists use to write papers) and treats parts of an essay, like claims, evidence, and sections, as movable building blocks arranged in a tree instead of one long block of text. Most AI writing helpers work by chatting back and forth, which forces writers to dig through walls of generated text and check whether the AI followed their plan. With LogicTree, the writer and the AI both work on the same visible blocks, and a built-in reviewer flags spots where the logic doesn't hold together. In a small test with 12 people, each trying both LogicTree and a regular chatbot, LogicTree helped people organize their ideas, made the work feel less mentally exhausting, and produced writing with better logical quality. The abstract doesn't give exact numbers, and the study was small and done under controlled conditions, so the results are early evidence rather than proof.

Event cameras are special sensors that only record changes in brightness, which lets them work in very dark or very bright scenes, but they see the world in black and white. The researchers built EventSeeColor, an AI system that guesses the colors in a scene by combining a grayscale picture rebuilt from the events with the raw pattern of events, since those patterns subtly depend on how different surfaces reflect light. It uses a diffusion model (the same kind of AI behind many image generators) to paint in the colors, with extra training steps to keep the colors balanced and the textures sharp. On two real-world event datasets, it beat other methods on structural similarity, perceptual quality, and color accuracy in colorful regions, though the abstract does not give exact scores and the colors are inferred rather than measured.

Passwords are annoying to remember and manage, so these researchers tested whether your heartbeat could replace them. They surveyed 337 adults about how they log in today and how they feel about biometrics, then had 49 people try a mock health-care app that let them log in using a simulated ECG (heart signal) scan or a regular password, followed by a usability questionnaire. Unlike fingerprints or face scans, an ECG comes from your body's electrical activity and is hard to fake, and this is one of the early studies to ask everyday users, across age groups, how they actually feel about it. The abstract reports that the study explored willingness to adopt and hands-on reactions, but it doesn't give specific results, so we can't say yet how well people liked it.

Researchers built BURGER, a testing ground where a robot arm has to draw whatever a text instruction asks for, like 'draw a cat next to a tree,' starting from a blank page each time. Because there are many valid ways to draw the same thing, it's a good way to see whether AI robot brains truly understand language or just memorize moves. They generated 28,200 practice drawings across 282 tasks in simulation and tested five popular robot AI models, finding that some got better with more variety and more examples, could handle drawing styles with many right answers, and could even draw new combinations of objects they had only seen separately. They also put a trained model on a real Franka Panda robot arm, which kept drawing sensibly even when a person interrupted it.

The researchers built StreamStudio, a prototype tool for making AI-generated videos in a new way. Normally you type a description, wait for the whole video to finish, and then try again if you don't like it. With StreamStudio, the video is generated bit by bit like a live stream, and you can steer what happens next, jump back to an earlier moment, or try different directions from that point. The abstract doesn't report any speed or quality numbers; the contribution is the interaction design itself, built to plug into whichever video-generation models are available now or come later.

Robots that move around people often use a single regular camera to decide a simple question: stop or keep going? The researchers realized that most tests only measure how far off the camera's position guesses are, not whether the robot makes the right stop-or-go choice, so they built a way to split the blame between a bad safety rule and bad camera vision. Using video of 898 real pedestrians, they showed that a rule counting only side-to-side distance never missed a danger when given perfect positions, but it was wrong about most of its stops (only 5.6-31.9% were truly needed). With a real camera, their calibrated method for finding where people stand on the ground was off by about 0.5-0.6 meters, versus 1.4-1.7 meters for a basic geometric approach, and the biggest cause of missed dangers turned out to be the camera system not spotting people at all (it found only 26-43% of them), rather than mis-measuring their position.

Robots that roam homes build maps of what objects are and where they sit, but those maps don't say how a door or drawer will feel when pulled. The researcher built PhysVLMM, a system that keeps a running 'best guess, with uncertainty' about how every door and drawer in a map will respond, learns from each pull the robot actually does, and shares what it learns with similar-looking doors and drawers it hasn't touched. Tested on real doors and drawers in 18 homes, it correctly worked out the type of joint (hinge vs. slider) 86% of the time versus 48% for a competing learned method, and predicted how a pull would play out with 41% less error than a physics simulator, in 13 milliseconds instead of 230 seconds. It can also say 'this will probably work' at a chosen risk level, or admit it doesn't know and hold off.

Computers normally add numbers by passing a 'carry' from one digit to the next, like carrying the 1 in long addition, and that waiting slows chips down. One trick to avoid it is a 'redundant' number system, which lets the chip add all digits at once, but the leading version (called MRSD) uses both positive and negative digits, which makes multiplying clumsy and wasteful. These researchers built a new version called MRUD that uses only positive digits, works with bigger digit sizes, and handles both signed and unsigned numbers. In simulated chip tests, their multipliers used up to 30% less delay, 26% less area, and 87% less power than MRSD, and their multiply-accumulate units (which repeatedly multiply and add) reached up to 64% higher throughput than a leading commercial design called DesignWare.

Edge detection is how a computer finds the outlines of objects in a picture, and its last step, deciding which faint lines are real edges by following them wherever they lead, is hard to do on the fly because a line can be any length. Raj Mali built one small set of hardwired circuit blocks on a cheap Artix-7 chip (using at most 1455 of its logic cells) that can run this step two ways: a fast mode that decides about each pixel just 262 to 721 microseconds after the camera sends it (46 to 127 times sooner than waiting for a full video frame at 30 frames per second), and an exact mode that works on 128x128 chunks and needs only 3 to 7 passes instead of 38 to 82. The fast mode never marks something as an edge that the exact method would reject, finds 77 to 96% of the exact edges, and scores at least 98.6% as well as the exact method on a standard 200-image test set. Earlier chip designs either skipped the tricky step with approximations or needed extra dedicated hardware, while this one reuses the same building blocks for both jobs.

A researcher built an AI system that looks at brain scans to tell apart two kinds of stroke (one caused by a blocked blood vessel, one caused by bleeding), mimicking how an emergency room sorts patients. It scored an impressive 95.48% on the data it was trained on, but when tested on brain scans from other hospitals and scanners, its score crashed to about 58-62%. This shows that many medical AI tools may look great only because they learn quirks of one hospital's machines instead of real signs of disease. The system also tended to wrongly call blocked-vessel strokes 'bleeding' strokes (catching only 57% of them), which is dangerous because the treatments are opposites; the best-performing, most consistent design combined two kinds of image-reading AI (DenseNet201 and a Vision Transformer).

Teaching a robot hand to do delicate tasks usually means a person controlling the robot by remote, which is slow. The researchers built TouchBridge, a system where a person wears a special glove-like device with touch sensors on the fingertips, and software called Tac-Retarget converts what the human's fingers felt into robot actions, using the pressure points on the fingertips instead of needing a 3D model of each object. Robots trained only on these converted human demonstrations succeeded 72.5% of the time on four tricky real-world tasks, compared with 77.5% for robots trained on the same number of remote-controlled demonstrations, while collecting the human demonstrations was 7 times faster. Their touch-based method also beat two earlier methods (DexPilot and UniDex) by 25 and 42.5 percentage points.

The researchers built HiFOR, a system that helps a robot's AI brain 'imagine' what will happen next before it moves. Instead of treating nearby moments (like where an object is in half a second) and the big picture (like the finished task) as separate things, HiFOR predicts both at once, including the key checkpoints in between, and keeps them connected. It then stores these imagined futures in an organized way and, as the robot decides on each movement, pulls out only the parts of the imagined future that matter for that exact movement, instead of feeding in everything. The authors report that this approach works well on two simulation benchmarks and six real-world robot manipulation tasks, though the abstract does not give specific numbers.

AI coding assistants now work on software for hours or days with almost no human watching, so the researchers asked a simple question: what did the AI actually do, and is the job really finished? They studied 45 real coding sessions (over 100,000 records) and found that about 23% of the time the AI edited code and then never checked its work, and that 58% of the to-do items the AI marked 'done' had no proof of completion. They also found that 42% of sessions ran longer than a day and that credential-like strings such as passwords or keys showed up in 16 sessions. To fix this, they designed a system called Soei that keeps a tamper-evident log of what happened (hash-chained, so changes are detectable), only 20% of the original size, with no private content stored, and that clearly separates 'the AI says it's done' from 'there's evidence it's done.'

Researchers took an AI model that learned to understand satellite images (both radar and regular photos) without needing humans to label them, and tested how fast and how energy-hungry it is on three ordinary computers of different ages and strengths. They shrank the model's math from high-precision numbers to simple whole numbers (called INT8), and the model's accuracy barely changed (a difference of just 0.0006), while it ran up to about 1.45x faster even on an older chip. They also found that on the weakest computer the built-in graphics chip was 4.38x faster than the main processor, but on better computers the main processor became the smarter choice. Before this, almost nobody had measured how these big satellite-image models actually perform on everyday hardware out in the field.

Squeezing a baseball or a table tennis paddle the right way matters, but you can't see how hard you're gripping, so it's hard to learn. The researchers put sensors in a glove that measure how hard different parts of your hand press, and showed 28 beginners that pressure live on a screen in two ways: a smooth, color-changing gradient or a set of bars that rise and fall. People matched the target grip pressure more accurately with the smooth gradient and kept their eyes more focused on it, even though they said the bars felt more precise. This is different from earlier teaching methods, which relied on words or touch demos and could never show you your own grip in real time.

Robots with cameras and laser scanners (LiDAR) need to know exactly how the two sensors are lined up, plus the camera's own quirks like lens warping, or their 'vision' falls apart. Earlier AI methods could match pixels in a photo to points in a laser scan, but only if the camera had already been separately calibrated and the image corrected. The researchers built a system that skips that step: it takes raw camera images and laser scans, then repeatedly matches pixels to points and fine-tunes its estimates until it has figured out the camera's internal settings, its lens distortion, and how the camera and LiDAR sit relative to each other, all at once and without any checkerboard targets. They trained it with synthetic distortions so it works on cameras it has never seen, and tests on a KITTI driving setup and three real robots showed it aligned the sensors more accurately than methods that needed pre-calibrated cameras, while also recovering good camera settings. The abstract doesn't give exact error numbers, so the size of the improvement isn't specified here.

Robots with two arms often fail in ways that are hard to untangle: a tool might slip out of its socket while still being held, both hands might do the right thing but at different times, or an attempt might fail for two reasons at once. The researchers built a simulated two-armed tool-use task where the true cause of every failure is recorded, then tested what different sensors (on the tool hand, on the other hand, or on both) can actually reveal about what went wrong. They found that some causes can be read from one hand's sensors, 'which hand was late' needs both arms, and whether a late attempt was also too weak can't be figured out from passive sensing at all when the tool hand is late. Surprisingly, a repair strategy that simply tries something broader when the cause is unknowable fixed just as many failures within two attempts as one that was handed the true cause. They also found that an AI vision-language model internally 'knows' which hand was late almost perfectly, yet whether it says so depends on how the question is worded.

Researchers built a system called FLORE that teaches humanoid robots to control how hard they push or grip things, not just where their hands move. They recorded humans doing tasks with handheld grippers that feel force, plus body trackers, so no robot was needed to collect the training examples. An AI model then learned to watch, sense pressure, and decide both what motion to make and how hard each hand should press, while a separate controller carried out those commands without the robot falling over. On three tricky tasks involving physical contact, the robot succeeded 80% of the time, versus only 26.7% for a version trained on the same demonstrations that ignored force.

Most robot AI systems are built to control just one robot, but real jobs like factory work often need several robots to team up while each watching the scene through different cameras. The researchers built World Dreamer v5-lite, which merges all the camera views into one shared 3D picture of the workspace, then lets each robot ask that picture questions and plan its own moves. During training, they randomly hid some cameras while still teaching the robots the right actions, which forced them to learn to rely on what their teammates could see. On a multi-robot test called RoboFactory it succeeded 74.0% of the time (23.7 points better than the best competitor), and on four real-robot tasks it hit 78.8% (13.8 points better).

Researchers built a glove with 864 tiny touch sensors that records how a player's hand squeezes and pushes on a badminton racket 100 times per second. They collected over 14,000 strokes from more than 70 people at different skill levels and used the data to figure out what experts do differently from beginners, something experts usually can't explain themselves. The surprising finding was that better players use their hands more selectively: they squeeze harder only in certain spots, get ready before the hit, and waste less force fighting against themselves. When learners got personalized coaching based on these hidden hand-force patterns, they improved by 0.72 expert-rated skill levels, versus just 0.05 for learners who only got a basic skill-level score.

The researchers built EgoThumb, a small robotic thumb that straps onto your hand and acts like a sixth finger, helping you hold things while your real fingers do the work. Older devices were bulky and only worked with big objects, and they usually waited for you to make a specific hand movement to activate. EgoThumb moves its motors to the forearm so the thumb itself stays light, and it uses a tiny camera in the palm to see both your hand and the object. It learned by imitating human demonstrations, so it can figure out what you want to do just by looking, without any special signals. The abstract says it works well across different people and environments, but it does not give specific success rates or numbers, so the exact performance is something you would need to check in the full paper.

Event cameras are special sensors that don't take normal photos; instead, each pixel reports a tiny signal the instant something changes in its view. To track moving objects with them, most methods squash those signals into flat, picture-like snapshots, but this fails when two objects' paths cross or run close together, because they blur into one smudge. The researchers built MvT, which looks at the same data from three different angles (including views that stretch time into a dimension) so objects that look tangled in one view can be told apart in another, then merges the results into one 3D picture to link up each object's path. It needs no training, works with existing image-based tracking tools, and beat both learning-based and non-learning trackers across four datasets, including a new small-objects dataset the team collected. The paper's abstract does not give specific numerical scores, so exact performance margins aren't stated here.

Edge detection is how a computer finds the outlines of objects in a picture, and its last step, called hysteresis, has to follow a line of edge pixels wherever it leads, which makes it hard to do on the fly as camera pixels stream in. Raj Mali built one small set of hardwired circuits on a cheap Artix-7 chip (about $50-class hardware, using at most 1455 logic blocks) that can run in two modes. In the fast mode, each edge decision comes out just 262 to 720 microseconds after the pixel arrives, which is 46 to 127 times sooner than a normal computer could even start working on a 30-frames-per-second video frame, and it never marks an edge that the exact method would reject while keeping at least 98.6% of the exact method's accuracy on 200 standard test photos. In the exact mode, the same circuits give identical results to the textbook method but finish the tracing step 6.6 to 21.7 times faster by sweeping forward and backward through the image instead of repeating dozens of passes.

A researcher built an AI system that looks at brain scans and tells whether a stroke was caused by a blood clot (ischemic) or by bleeding (hemorrhagic), copying the quick sorting steps that emergency doctors use. On the data it was trained on, it scored an impressive 95.48%, but when tested on brain scans from other hospitals' machines (three outside datasets), its score crashed to about 58-62%. The AI also tended to mistake clot-type strokes for bleeding ones, catching only 57% of true clot strokes, a dangerous error because the two need opposite treatments. The study shows that great scores on one hospital's data can be an illusion, and it identifies one combination of AI models (DenseNet201 plus a Vision Transformer) as the most consistent performer across repeated runs.

The researchers built Omni-IGN, a system that lets a small drone fly to a spot shown in a photo, even in a place it has never seen before. Instead of one forward-facing camera that forces the drone to spin around to look for clues, it uses four wide-angle fisheye cameras that together see in every direction at once, plus an AI trained through trial and error to figure out which camera view shows the way to the goal. The same cameras also help the drone dodge obstacles, so it doesn't need a special depth sensor, and everything runs on the drone itself rather than on a remote computer. The system beat other continuous-flight methods in standard simulated tests (the abstract doesn't give exact scores), and it worked on a real drone right after training in simulation, with no extra tuning and no outside positioning system like GPS or motion capture.

Factory robots usually rely on cameras and laser scanners, which can't see around corners or through boxes, so they can miss a person or object hiding out of view. The researchers showed that the Wi-Fi-style radio signals already bouncing around a factory can be used to 'see' these hidden things: when a person or obstacle moves, it subtly changes how signals travel between devices. They turned these signal measurements into compact mathematical fingerprints using a lightweight technique called hyperdimensional computing, then trained a system to judge how risky the situation is for a robot. In simulations and tests with the robot operating system ROS, it reached up to 89% accuracy even when views were heavily blocked, without the heavy computing that rebuilding the radio environment would normally require.

When a computer vision system labels the pixels of a picture (say, 'this is a box' versus 'this is background'), a common next step is tracing the outline of each shape. The standard method for this, called Suzuki-Abe, works one step at a time and gets slow on large, high-resolution images. The researchers built TRUCO, a new method that lets many processor cores trace different outlines at the same time without waiting on each other or stitching the image together from tiles. It does this by giving each outline a single 'owner' that starts it and by having helpers stop as soon as they hit an outline someone else owns, so no outline is traced twice. In tests on both synthetic and real images, across home-computer and server-grade chips, TRUCO ran more than ten times faster than the industry standard and kept speeding up as more cores were added. The abstract does not give an exact speedup figure beyond 'over an order of magnitude.'

The researchers built GAWM, a small robot-brain program (under 100 million parameters, versus billions for rivals) that teaches robots to manipulate objects by first imagining what the scene will look like a moment later, then picking the right movements. Instead of imagining full video frames, it predicts compact summaries of future camera views, which keeps it fast and cheap to train. Despite being tiny and needing no extra pretraining on robot or video data, it beat much bigger models on the RoboTwin 2.0 benchmark and matched billion-parameter models on LIBERO. On a real two-armed robot it predicted actions more accurately than a fine-tuned billion-parameter model while responding much faster, and the 'imagine the future' step helped most when training data or time was scarce.

Robot "brain" models that follow spoken or written instructions (like "pick up the cup") usually don't know how to dodge obstacles, especially ones that move, and retraining them to do so is expensive and can make them worse at their original job. The researchers built VLA-Stem, a small add-on safety layer, loosely modeled on the brainstem's reflexes, that sits between the big model and the robot's arms. It takes the path the big model wants to follow and tweaks it on the fly to steer around obstacles, without touching the big model itself. In six simulated obstacle-heavy tests, robots with VLA-Stem finished tasks without hitting anything 52.8% of the time versus 23.7% for the best competing safety method, and they performed just as well as before when no obstacles were present. Real-world tests also showed fewer collisions with both still and moving obstacles.

Researchers took an AI model that has learned to read both radar and regular satellite images, and tested how fast and how power-hungry it is on three ordinary computers, from a weak low-power chip to a stronger one. They shrank the model's numbers from high-precision to low-precision (called INT8 quantization) and found it made almost no difference to accuracy (a change of just 0.0006 on their score, within normal run-to-run noise). The shrunken version ran faster on every computer, including a 1.45x speedup on the oldest chip, and used less energy where it was measured. They also found that on the weakest computer the built-in graphics chip was 4.38x faster than the main processor, but as the processors got better, the main processor became the best choice.

Squeezing a baseball or a table tennis paddle the right way is hard to learn because you can't see how hard you're gripping. The researchers put a sensor-covered glove on 28 beginners and showed them their grip pressure live on a screen, comparing a smooth color gradient (like a heat map) against a simple set of bars. People matched a target grip pressure more accurately with the gradient, and their eyes darted around the screen less, even though they said the bars felt more precise. The study didn't report exact accuracy numbers in the abstract, but it shows that what feels most precise to users isn't always what helps them perform best, and that spatially resolved live feedback can make an invisible skill visible.

Robots that use both cameras and laser scanners (LiDAR) need to know exactly how the two sensors line up, and each camera's own quirks, like lens warping and zoom, which engineers normally measure with special checkerboard targets. The researchers built a system that figures all of this out automatically from ordinary driving data, with no targets needed, by teaching a neural network to match pixels in a raw camera image to the matching spots in the laser scan and then repeatedly refining its estimates. It was tested on an unseen camera-LiDAR setup from the KITTI driving dataset and on three real robots without any retraining, and it lined up the two sensors more accurately than earlier methods that required an already-calibrated camera, while also recovering the camera's own settings. The abstract doesn't give exact error numbers, so the size of the improvement isn't stated, but the key difference is that earlier learned methods needed a separately calibrated camera first and this one does both jobs at once.

Robots with two arms that use tools can fail in ways that one-armed robots don't: a tool might slip out of its socket while still being held, both hands might do the right thing but at different times, or two things might go wrong at once. The researchers built a simulated two-armed tool task where the true cause of every failure is recorded, then tested what different sensors can actually tell a diagnoser. They found that the tool's slip shows up in the tool hand's sensors, but figuring out which hand was late requires information from both arms, and in one case (a late attempt that was also too weak, when the tool hand was the late one) the cause simply can't be figured out from passive sensing. A repair strategy that admits 'I can't tell' and escalates to a more cautious fix fixed just as many failures within two attempts as one that was handed the true cause, and the team also found that an AI vision-language model internally knows which hand was late almost perfectly, but whether it says so depends on how the question is worded.

Researchers built FLORE, a system that teaches humanoid robots to control how hard they push, pull, or grip, not just where their hands move. Humans recorded demonstrations without any robot, using two handheld grippers with built-in force sensors plus wearable body trackers, and an AI model learned from these to decide both movements and how much force each hand should apply. A special controller then carries out those commands while keeping the robot balanced, using force sensors in the hands to correct mistakes. On three tasks that need careful physical contact, the force-aware robot succeeded 80% of the time, compared with only 26.7% for a robot trained on the same demonstrations that only copied hand positions.

Researchers built World Dreamer v5-lite, an AI system that lets several robots work together by sharing one combined 'mental picture' of the workspace built from all their cameras. Most robot AI is designed for a single robot, and just piling more camera feeds together doesn't help robots understand where things are relative to each other. In this system, each robot asks questions of the shared picture and decides its own moves, and during training some camera views are hidden so each robot learns to lean on what its teammates can see. After learning from over 10,000 hours of robot data, it succeeded 74.0% of the time on a multi-robot benchmark called RoboFactory (23.7 points better than the best competitor) and 78.8% of the time on four real-robot tasks (13.8 points better).

Researchers built a glove packed with 864 touch sensors that records how hard and where your hand squeezes a badminton racket 100 times per second. They collected over 14,000 strokes from more than 70 players across five badminton skills, then used a physics-based computer model to figure out two hidden things the hand does: pushing the racket through the swing and gripping it steady. They found that better players don't squeeze harder or with more of their hand; they use less, more precise force, adjusting just the fingertips ahead of time, while beginners waste effort with muscles that cancel each other out. When learners got coaching based on these hidden hand mechanisms, they improved by 0.72 skill levels (as rated by experts), compared with just 0.05 for learners who only got feedback on their overall level.

The researchers built EgoThumb, a small robotic thumb that straps onto your hand and gives you an extra finger, so one hand can do jobs that normally take two, like holding a jar steady while you twist off the lid. The thumb's motors sit on the forearm instead of at the fingertips, which keeps the part on the hand light and slim enough to handle small objects, not just big ones. A tiny camera on the palm watches your hand and whatever you're reaching for, and an AI trained by watching human demonstrations decides on its own when and how to move the thumb, so you don't need to press buttons or make special gestures. The abstract says it works well across different people and settings, but it doesn't give specific success rates or numbers, so those details would need to come from the full paper.

Event cameras are special sensors that, instead of snapping full pictures, report only the tiny spots in a scene where brightness changes, which makes them very fast but awkward to work with. The common trick is to squash these changes into flat 'pseudo-pictures' so regular image tools can follow moving objects, but this breaks down when objects cross paths or sit close together because their trails blur into one. The researchers built MvT, which looks at the same stream of events from three different angles (adding time as an extra view) and then combines the results in 3D to keep objects straight, and it needs no training on labeled examples. Tested on four datasets, including their own collection of small moving objects, it beat both learning-based and non-learning trackers in general scenarios; the abstract does not give specific numbers.

Edge detection is how a computer finds the outlines of objects in a picture, and its last step, called hysteresis, has to follow lines of unknown length, which makes it hard to do on the fly as camera pixels arrive. Raj Mali built one small set of fixed circuits on a cheap Artix-7 chip (a programmable chip costing only a few tens of dollars, using at most 1,455 of its logic blocks) that can run in two modes. A fast mode makes each edge decision only 262 to 720 millionths of a second after the pixel arrives (46 to 127 times sooner than a normal frame-by-frame computer can even start), never marks an edge that the exact method would reject, and still scores at least 98.6% as well as the exact method on 200 test photos. An exact mode gives identical results to the textbook method but finishes the line-following step 6.6 to 21.7 times faster by sweeping through the image forward and backward in place instead of repeating many passes, so previous designs had to pick between speed and exactness while this one offers both from the same hardware.

A researcher built an AI system that looks at brain CT scans to tell whether a stroke is caused by a blocked blood vessel (ischemic) or by bleeding (hemorrhagic), combining two kinds of image-analysis AI and training them to focus on the right parts of the scan. On the data it was trained with, it scored an impressive 95.48%, but when tested on brain scans from completely different hospitals and scanners, performance crashed to roughly 58-62%. The AI was also too quick to call strokes 'bleeding' (about 77% precise but only 57% sensitive for blocked-vessel strokes), meaning it missed many of them. The big contribution is honesty about this gap: the paper shows that great scores on one hospital's data can be an illusion caused by scanner quirks, and it identifies one combination of AI models (DenseNet201 + ViT) as the most consistent across repeated runs.

The researchers built Omni-IGN, a navigation system that lets a small drone fly to a spot shown in a photo, even if it has never been in that building before. Instead of one camera that only sees straight ahead, the drone uses four wide-angle fisheye cameras that together see in every direction, so it doesn't have to waste time spinning around to hunt for clues. An AI trained through trial and error combines what all four cameras see to decide which way to fly, and a built-in safety check stops it from crashing, using only the camera images instead of a special depth sensor. It beat other methods that use smooth, continuous movement on standard simulated tests, and it worked in real-world flights without any extra tuning after training in simulation. The abstract doesn't give specific benchmark numbers, so the exact size of the improvement isn't stated.

Factory robots usually rely on cameras, LiDAR, or radar, which can only see what's in their direct line of sight, so they can't spot a worker or a cart hiding around a corner. The researchers built a system that uses the wireless signals the factory already has for communication, noticing how those signals get bent and blocked by people and objects, to figure out whether something risky is out of the robot's view. They convert these signal readings into compact, simple patterns using a lightweight technique called hyperdimensional computing, which avoids the heavy math of rebuilding a full picture of the signals. In simulations with a commercial ray-tracing tool and tests in a robot software environment (ROS), the system correctly classified hidden hazards up to 89% of the time even with heavy obstructions, and it helped robots plan safer paths without needing much computing power.

When a computer vision system labels the pixels of an image, say, 'this is a box' and 'this is background,' a later step has to trace the outlines of those shapes so the robot gets usable boundaries instead of a blob of pixels. The standard way to do this, the Suzuki-Abe algorithm, works one step at a time on a single processor core, which gets painfully slow on big, high-resolution images. The researchers built TRUCO, a method that lets many processor cores trace outlines at the same time without locking or waiting on each other. It does this with a simple rule that assigns each outline to exactly one worker, which lets them trace without stepping on each other or needing to stitch separate image tiles back together. In tests on both synthetic and real images, across consumer and server CPUs, TRUCO ran more than ten times faster than the industry-standard approach and kept scaling well as more cores were added. The paper reports speedups as 'over an order of magnitude' rather than giving one exact figure.

Many of today's smartest robot-control systems work by imagining what the scene will look like next, but they rely on giant AI models with billions of parameters that are slow and expensive to run. The researchers built GAWM, a much smaller system (under 100 million parameters, roughly 10 times smaller or more) that squeezes each camera view into a few compact 'summary tokens' and predicts how those summaries will change at two moments in the future, based on the task rather than on the robot's actions. It was trained to predict detailed spatial features of future camera frames, which forces it to learn where things will be in the scene. Even without any special robot or video pretraining, it beat billion-parameter world-action models on the RoboTwin 2.0 benchmark, matched billion-parameter vision-language-action models on LIBERO, and on a real two-armed robot predicted actions more accurately than a fine-tuned billion-parameter model while responding much faster.

Robots controlled by AI that understands images and instructions (called VLA models) are good at picking things up in open, empty spaces but tend to crash into things when the environment is cramped or when objects move. The researchers built VLA-Stem, a small add-on safety layer that sits on top of the robot's main AI and acts like a reflex: it keeps the original plan but quickly adjusts the robot's movements to dodge obstacles, without retraining the main AI. In six simulated test setups, robots using VLA-Stem finished their tasks without any collisions 52.8% of the time, compared with 23.7% for the best competing safety method, and they did just as well as before when no obstacles were around. Real-world tests also showed fewer collisions with both still and moving obstacles.

Researchers figured out how to let a physical system that steers waves (like light, sound, or radio signals) teach itself to do a better job, without needing a computer simulation of how it works. This trick already worked for 'two-way' systems where signals behave the same going forward or backward, but it broke down for 'one-way' systems, like devices that let waves pass in only one direction. The team solved this by cleverly choosing which signals to send in and where to measure, so the hidden 'backward' information could be pieced together using only ordinary forward experiments. They showed it working on tasks like blocking and passing signals in the right direction, absorbing waves perfectly, shaping wavefronts, and sensing in specific spots, and the number of experiments needed stays the same no matter how many knobs the system has to tune. It even works when parts of the system can't be touched or measured directly.

The authors didn't run an experiment or build a working tool. This is a Perspective paper, an opinion-style proposal, arguing for a new kind of 'carbon label' for AI models. Instead of just measuring how much energy an AI uses per request, the label would measure the expected carbon cost of getting a task done correctly. A big model wastes energy on easy jobs, and a too-small model wastes energy by failing, retrying, and escalating to a bigger one. Under their idea, models would first have to prove they're good enough for a given type of task, and only then would they be compared on energy and emissions. The paper reports no measured results or numbers; it's a call for standardized capability tests, full energy accounting, and transparent carbon reporting.

The researchers built EmbodiedLab, a test where a robot has to run real-style science experiments in a simulated lab, like figuring out a hidden physical law, by actually handling the equipment and reading the instruments through its cameras. Unlike older tests where robots are told exactly what end state to reach, or science tests where AI just types out numbers, here the robot has to choose its own steps and then show what it learned. It covers 30 experiments across five science fields using 14 types of lab equipment, and the settings are randomized every time so the answer can't be memorized. Six top AI models were tested, and even the best one succeeded less than half the time; most failures came from fumbling the equipment itself rather than from not understanding the science, and giving weaker models pre-built hand skills helped them more than giving them better vision and motion planning.

Researchers built FLORE, a system that teaches a humanoid robot to control how hard it pushes, not just where its hands move. Instead of using the robot itself for training, people wore trackers and held two special grippers with built-in force sensors, so the system recorded both their motions and how hard they pressed on things. A learning model then used what the robot sees, feels, and senses about its own body to decide both where to move and how much force each hand should apply, while a balance controller kept the robot upright. Across three tasks that involve pressing, pushing, or gripping, the force-aware robot succeeded 80% of the time, compared with only 26.7% for a robot trained on the same demonstrations that only copied hand positions.

Imagine trying to figure out how hard someone is pushing on a loose piece of rope when you can't put any sensors on the rope itself. The researchers built a software method, based on a tool called a factor graph, that treats the rope (or a cable or wire) as a chain of uncertain clues and works out three things at once: how strong the push is, which direction it points, and where along the rope it lands, while also figuring out the rope's shape. Unlike earlier approaches that needed extra sensors on the cable or readings from motors, theirs uses just one type of sensing data, and it kept working accurately even when they added realistic noise to the measurements while two robot arms moved the cable along a set path. The abstract doesn't give specific accuracy numbers, so we can only say the force estimates were described as accurate rather than quantify how accurate.

Researchers built a glove packed with 864 tiny touch sensors that records how a player's hand squeezes and moves a badminton racket 100 times every second. They collected more than 14,000 strokes from over 70 people of different skill levels, then used a physics-based computer model to figure out two hidden jobs the hand does: pushing the racket through the swing and gripping to keep it steady. They discovered that better players don't squeeze harder or use more of their hand; instead they use their grip more selectively, adjusting just the fingertips at the right moment and getting ready before the hit. When learners got coaching based on these hidden grip patterns, they improved by 0.72 skill levels (as rated by experts), compared with only 0.05 for learners who just got told their overall level.

Edge detection finds the outlines of objects in a camera image, and its last step, called hysteresis, has to follow an edge as far as it goes, which makes it awkward to do on the fly as pixels arrive. The researcher built one small set of hardwired circuit blocks on a cheap Artix-7 chip that can run in two modes: a fast mode that decides about each edge pixel only 262 to 721 microseconds after the camera sends it (46 to 127 times sooner than a computer that must wait for the whole frame at 30 frames per second), and a slower exact mode that gives perfect results. The fast mode never marks an edge that the exact method would reject, finds 77 to 96 percent of the true edges, and scores at least 98.6 percent as well as the exact method on 200 standard test photos. The exact mode also cuts the number of repeat passes from 38-82 down to 3-7, making that step up to 21.7 times faster (40 times on a worst-case tile) with identical output, all while using at most 1,455 of the chip's basic logic units.

A researcher built an AI system that looks at brain scans and decides whether a stroke was caused by a blood clot (ischemic) or by bleeding (hemorrhagic), copying the quick sorting that emergency doctors do. On the scans it was trained on, it was right about 95% of the time, but when tested on scans from other hospitals with different machines, its score crashed to around 58-62%. It also tended to call clot-type strokes 'bleeding' strokes, catching only 57% of the true clot cases, which is risky because the two types need opposite treatments. The big takeaway is that impressive results on one hospital's data can be an illusion, and the paper shows how to measure that gap honestly and which model combination (DenseNet201 plus a Vision Transformer) stays the most consistent.

AI models that understand pictures and words are great at general planning, but they get confused when looking at specialized things like machine parts or industrial equipment. The researchers built a system called TrySee that keeps the AI's reasoning but adds specialist 'vision helpers' that clean up and label what the robot sees, then loops back to check each step as the robot works. Instead of retraining the AI or showing it thousands of examples, you just swap in a different helper for each new job. They tested it on planning tasks in 5 very different areas, including a real robot taking apart equipment in an actual factory-style setting. The abstract does not report specific numbers, but the team says the real-world test showed the approach works in practice even with very little training data.

Researchers built a new robot 'brain' called neuromorphic decision dynamics (NDD) that lets many robots squeeze through crowded spaces without crashing or getting stuck in a standoff. Each robot only watches the neighbors near it and slows down or speeds up along its planned path, without talking to the others, without assigned ranks, and without trying to guess what anyone else wants. When two or more robots start to block each other, their internal 'decision' signals tip from hesitation into a clear pecking order, so they take turns, then go back to normal once the jam clears. The team proved with math that this avoids collisions and endless deadlock for any number of different robots, and showed it working in large simulations, comparisons against other methods, and real hardware tests. The paper does not report a single headline number, and its main advance is that earlier approaches typically needed communication, priority rules, or knowledge of the group's size.

The researchers built MiD-VLM, an AI system that spots fake news that uses real photos with misleading captions, like putting a false story under an authentic picture, which older tools miss because they only look for edited pixels. They combined two vision models (SigLIP and DINOv2) with a large language model (Qwen2-VL-7B), and tweaked only a small slice of it using a lightweight training trick called LoRA instead of retraining the whole thing. On a test set called DGM4+, it correctly sorted real from misleading image-caption pairs with an F1 score of 0.9679 (where 1.0 is perfect), and it also tried to name the type of trickery and point to the exact misleading words. That last part, pinpointing the specific words, was the weakest, so the authors say it still needs work.

Scientists wanted a reliable way to measure how well water spreads across a contact lens, which tells you how wettable and comfortable the lens material is. Labs usually do this by hand, placing a tiny water droplet on the lens and measuring the angle where it meets the surface, but results change from person to person and lab to lab. So the team built RAISE-Vision, a robot setup that uses a lab liquid-handling machine plus custom 3D-printed lens holders and camera mounts to place droplets, take photos, and measure angles automatically with free, open-source software. On senofilcon A lenses, the angle rose from about 63° to 83° over 10 measurements as the lens dried in air, matching what a person got doing it by hand and matching a commercial software package.

Researchers built an AI system that learns how to secretly mess with a car's sensor data just by watching normal sensor readings, without needing to know how the car's software or its attack-detection tools work. Earlier attack methods needed inside knowledge of the system, which hackers rarely have in real life. In tests, their AI nudged a simulated car into a dangerous 2.51 meter drift out of its lane while slipping past five different security detectors, and on real hardware it pushed a vehicle's speed off by about 8 km/h without setting off any alarms. The big takeaway is that cars can be attacked stealthily even when the attacker knows almost nothing about them.

Researchers taught a robot to gently reshape soft, squishy material by showing it examples from a human operator and letting it watch its own work with OCT, a scanner that makes tiny 3D images of what's inside tissue, similar to ultrasound but using light. The robot compares what it sees now with a 3D picture of the shape it should reach, then decides its next move, repeating until the shape is right. They tested several ways of storing the 3D images (full scans, trimmed scans, and point-cloud versions) and two types of AI decision-makers, and the best setup got within about 0.44 to 0.53 millimeters of the target shape on fake-tissue tests, while adding information about the 'gap' between current and goal shape cut errors from 0.748 to 0.555 mm in one case. It also worked on 60 trials with real pig tissue, ending up about as accurate as the human demonstrations it learned from, and it didn't need slow, complicated physics simulations of squishy tissue.

Researchers built OpenTac, a flexible 'skin' for robots that can feel not just how hard something is pressing, but also which direction it's sliding, using a grid of tiny pressure-sensing dots covered by a bumpy rubbery layer that turns sideways pushes into patterns of pressure. What makes it different is that they also built free software that can automatically design a custom skin for almost any shape, even from a text request like 'make a sensor for a size 9 shoe insole,' and they used it to fabricate more than 30 sensors for different robots. They tested the skin against a precise lab force sensor and showed it working on four real robots for tasks like controlling contact and learning to handle objects. They also found a clever readout trick that checks only a few dots at a time, making a 1024-dot skin update 19.2 times faster than scanning every dot in order.

Robot AI models that follow spoken instructions often get stuck after one small mistake pushes them into situations they were never trained on. The researchers built Backtrack, a tiny add-on (less than 1% extra size) that watches the robot's own 'thoughts' to predict when a task is about to fail. When it senses trouble, it pauses the robot, rewinds the arm along the path it just took, and lets the original, unchanged AI try again from an earlier spot. On the hardest set of long, multi-step tasks (LIBERO-Long), this cut failures by 19-48% across three different robot AI models, raising success by up to 7.4 percentage points, and it helped on a second test (MetaWorld) too, all without any new training demonstrations or retraining of the main model.

Researchers built a system called AWARE that can tell when a robot crane is malfunctioning just by watching it with an ordinary camera, without needing any sensors inside the machine. It works by learning how the crane normally moves, predicting where it should go next, and flagging anything that doesn't match, like a collision with a load or a motor wearing out. Tested on 240 real crane runs with messy, camera-only data, AWARE was 26% better at spotting problems than the best competing method, and it correctly pinpointed which motor was failing 88% of the time. Earlier approaches needed direct access to the machine's internal sensors, which older equipment often lacks or which security rules don't allow anyone to touch.

Modern robot-control AI models plan movements by running a many-step math process, and engineers have always assumed you should run that process in full detail and re-plan often. These researchers found the opposite can be true: if a robot is going to carry out a long chunk of its plan without stopping to re-check, cutting the number of math steps actually makes it more accurate, because the shortcut keeps the planned motions bunched tightly together instead of drifting apart over time. By pairing long action chunks with fewer calculation steps, they got higher task success rates and much faster response times on popular benchmarks (LIBERO, RoboTwin 2.0) and on a real Franka robot arm, using well-known models like π0, π0.5, and GR00T. The surprising part is that it needs no retraining and no changes to the models, just a different setting chosen at run time. (The abstract does not give specific numbers, so exact gains can't be quoted here.)

Researchers built a robot that learns to do ultrasound scans by watching real people scan, instead of being programmed step by step. They collected training examples using a handheld device that records the ultrasound images, a small camera on the probe, and how hard the probe presses on the body, all while a person scans naturally with no robot involved. The robot first uses a regular camera to find the right starting spot on the body, then relies mostly on what the probe itself 'sees and feels' to finish the scan. On 16 people it had never scanned before, it successfully captured the right pictures of the kidney, gallbladder, and liver 96%, 94%, and 88% of the time, and tracked the wrist artery 94% of the time, beating a leading general-purpose robot AI (pi_0) by 10 to 42 percentage points on the belly scans while moving more smoothly and pressing more gently.

Researchers built TravSUITE, a system that helps off-road robots figure out which patches of ground are safe to drive on at high speed. It combines a 3D map that uses pretrained AI vision models to recognize things like grass, mud, and rocks, with a neural network that learns how 'costly' each spot is purely by watching examples of good driving, with no humans labeling any data. The system also fills in gaps where the robot can't see (like behind bushes or around bends) and knows how unsure it is about those guesses, so it can slow down or steer more carefully when risk is high. In real-world robot tests, combining the gap-filling with this uncertainty awareness cut navigation errors by 80% while making the robot about 5% faster.

Researchers built SkeLAM, an AI system that learns to predict what a robot's camera will see next when the robot moves, by studying lots of videos. The tricky part is that earlier systems mixed up the robot's own movement with everything else changing in the scene, like objects being pushed around. SkeLAM fixes this by splitting what it learns into two parts: one tied directly to the robot's skeleton (its arm and joint positions) and one that captures everything else. On a large robot video collection called DROID, it made the predicted robot arm positions 19.5% more accurate and the generated video frames 11.1% closer to reality compared with the previous best system, DreamDojo. It can even copy human arm motions onto a robot in generated videos without extra training.

Teaching a surgical robot to work from camera images alone is hard: pure trial-and-error learning struggles, and copying human experts requires far more demonstrations than surgeons can realistically provide. The researchers built a 'teacher-student' training method for laparoscopic (keyhole surgery) robots in simulation. First, a teacher robot learns each task using perfect inside information, like exact object positions that a real operating room couldn't easily supply. Then a student robot, which only sees camera video and its own joint readings, learns by copying the teacher's behavior. Across several simulated surgical tasks, standard trial-and-error training for vision-only robots was unreliable, while the teacher-student approach performed more consistently and stably. The abstract gives no specific numbers, so the size of the improvement isn't stated here.

The researchers built a smarter control system for wearable robotic suits (exoskeletons) that helps people move by predicting where the user is about to go. The system watches the person's whole-body movement and the exoskeleton's own sensors, then generates several possible future paths, much like imagining a few ways the next few seconds might unfold. When those guesses agree, the exoskeleton assists firmly; when they disagree, it relaxes and becomes softer and more flexible so it doesn't fight the wearer. In tests, this approach lowered muscle activity compared to standard methods and reduced the energy users burned compared to wearing no assistance at all, though the abstract doesn't give exact percentages.

Robots that follow spoken or written instructions can still make mistakes, and today the usual way to catch those mistakes is to run a second big AI model that watches over the first one, which is slow and expensive. These researchers found a simpler trick: they trained tiny, lightweight 'probes' (basically small add-on gauges) that read the robot AI's own internal signals to estimate how far along it is in a task, like a progress bar. If the robot's progress stops matching what it normally looks like during successful runs, the system flags a likely failure. Tested on an open-source robot model called π0.5, in both simulated and real-world tasks, this approach matched or beat monitors that use separate vision-language AI models, and even beat methods that had to be trained on examples of failures. The abstract does not give specific numerical results, so exact accuracy figures are not stated here.

Researchers built OpenTac, a stretchy electronic 'skin' for robots that can feel not just how hard something is pressing, but also which direction it's sliding, using a patterned rubber layer that turns sideways pushes into pressure the sensor can read. They also made a design program that automatically creates build files for custom-shaped skins from a drawing or even a text request like 'design a sensor for a size 9 shoe insole.' Using it, they made more than 30 different sensors for four real robots, tested them against a high-precision force sensor, and used them to guide robot movements and train robots to handle objects. A new reading method lets the skin check just 16 of its 1,024 sensing spots at a time and update 19.2 times faster than scanning every spot in order, and all the designs and software are free online.

Researchers built CoHelix, a tracking system that figures out how fast each of a drone's four propellers is spinning using a special camera that only reports tiny changes in brightness instead of full pictures. The hard part is that when the camera itself is moving, it's tough to tell blade spin apart from the whole scene shifting, and the repeating blades can trick a tracker into guessing half or double the real speed. CoHelix solves this by having all four propellers share one estimate of the viewing angle, so each propeller helps correct how the others are interpreted. In tests with a moving camera, it stayed within 2% of the true spin speed 62.9% of the time versus 39.8% and 22.2% for earlier methods, and on a different quadcopter it hit 95.9% versus 56.2% and 61.1%.

Robots that learn from cameras and instructions often use several camera views at once, such as a wide shot of the whole scene and a close-up from a camera on the robot's hand. The researchers found that today's top robot models lean on the hand camera almost all the time, even when a wide view would help, like when reaching toward an object. They built FocusVLA, which looks at what the robot just did to guess what it's about to do next, then uses that guess to decide which camera view to pay attention to at each step. In tests, it beat the previous best model (π0.5) by about 10 percentage points on a standard simulated benchmark, and in real-world tests it jumped from a 71.7% to an 85% success rate.

The researchers built VecTile, a thin, bendy sensor pad that lets a robot feel not just how hard it's pressing on something, but also how much the object is trying to slide sideways, like feeling a glass slipping out of your fingers. It works by pairing a pressure-sensitive material with little silicone bumps that turn pushes and slides into different pressure patterns, and the whole 4x4 sensor can be made at home for under $35. In tests, it measured pushing force to within about 0.39 newtons and sideways force to within about 0.16 newtons, and it still worked when bent after being calibrated while flat. In demos, it stopped a sharp scalpel from popping a balloon after touching it and made a robot much better at plugging in a power plug.

Researchers built SkeLAM, an AI system that learns to predict what a robot's camera will see next after the robot takes an action, essentially a video simulator for robots. Earlier systems learned from videos by guessing hidden 'actions' that explain each change between frames, but those guesses tangled together the robot's own movement with things like objects getting pushed around. SkeLAM splits the guess into two parts: one tied to the robot's skeleton (its arm and joint positions) and one that captures everything else happening in the scene. On a large real-world robot dataset called DROID, this made the robot's hand position in the predicted videos 19.5% more accurate and the images 11.1% closer to reality than the previous best system, DreamDojo. It could even copy human arm motions onto a robot in generated videos without extra training, and its predictions of whether a robot policy would succeed matched what happened on real robots.

Researchers wanted to teach a simulated surgical robot to do delicate tasks in keyhole (laparoscopic) surgery using only camera images, the way a real surgeon would see the scene. Teaching it by trial and error alone turned out to be unreliable, and teaching it by copying human experts needs far more demonstrations than are realistic to collect in surgery. So they built a two-step approach: first train a 'teacher' robot that cheats by knowing exact object positions, then have a 'student' robot learn to copy the teacher using only camera images and its own joint information. The abstract doesn't give specific numbers, but the student approach performed more consistently and stably across several surgical tasks in simulation than standard trial-and-error training did, and it needed fewer expert demonstrations than copying humans.

Researchers built a control system for a wearable robot suit (an exoskeleton) that predicts where the wearer is about to move by watching their whole body and the suit's own sensors, plus a short description of the task. The system doesn't just make one guess: it generates many possible future movements, uses their average as the plan, and uses how much those guesses disagree as a measure of how unsure it is. When it's unsure, the suit goes softer and gives the wearer more freedom, and when it's confident, it provides firmer help, which keeps it safe and comfortable. In tests, wearers' muscles worked less hard than with standard approaches, and their bodies burned less energy than when wearing no assistance at all. The abstract doesn't give exact percentages, so the size of the improvement isn't stated here.

Robots that follow spoken or written instructions, called vision-language-action (VLA) models, sometimes make mistakes without realizing it, so they need a watchdog to notice when a task is going wrong. Until now, that watchdog was usually a second large AI model watching over the robot's shoulder, which is slow and expensive to run. The researchers built Progress Probes (P²), a tiny add-on that reads the robot's own internal 'thoughts' (its activations) and estimates how far along it is in a task, then raises an alarm if the robot falls behind where it should be. Tested on the open-source π0.5 robot model in both simulated and real-world tasks, this simple approach matched or beat monitors that rely on a separate vision-language model, and even beat methods trained on examples of failures, without needing any failure examples itself.

Researchers built OpenTac, a stretchy 'electronic skin' for robots that can feel not just how hard something is pressing, but also which direction it's sliding or pushing sideways. A special bumpy rubber layer on top turns sideways pushes into pressure changes that neighboring sensor spots can compare, like how your fingertip senses slipping. They also made a free design tool that automatically creates build files for custom-shaped skins from a simple outline, a 3D surface, or even a text request like 'make a sensor for a size 9 shoe insole,' and they used it to make more than 30 sensors for different robots. They tested the skins on four real robots, and a smart reading trick let a 1,024-spot skin update about 19 times faster than checking every spot one by one.

Researchers built CoHelix, a software tracker that figures out how fast each of a drone's four propellers is spinning using a special camera that only reports pixels that change, instead of taking regular photos. The hard part is that when the camera itself is moving, it's tough to tell blade motion from camera motion, and the blades look the same every time they pass, so trackers often lock onto half or double the real speed. CoHelix solves this by treating the four propellers as one rigid flat group, so every propeller helps the system understand the camera's viewpoint, which makes it easier to read every other propeller. In tests it stayed within 2% of the true spin rate 62.9% of the time on moving-camera recordings, versus 39.8% for the best earlier method (HelixTrack), and hit 95.9% on a different drone versus 56.2% for HelixTrack.

Robots that learn from cameras, language, and actions often have several cameras, like a wide shot of the whole table and a close-up from the robot's hand. The researchers found that today's best models mostly stick to the hand camera and don't switch to the wide view when it would help, like when the robot needs to find an object before reaching for it. They built FocusVLA, which looks at what the robot just did to guess what it's about to do next, then uses that guess to decide which camera to pay attention to at each stage of a task. On a robot-simulation benchmark called RoboTwin 2.0, it beat the previous best model (π0.5) by about 10 percentage points, and on real robots it raised the success rate from 71.7% to 85.0%.

Researchers built VecTile, a thin, bendy sensor pad that works like artificial skin for robots and can feel not just how hard something presses down, but also which way it's sliding sideways. It uses a layer of material that changes its electrical signal when squeezed, topped with tiny silicone bumps that turn pushes and slides into different pressure patterns the robot can tell apart. A 4x4 grid of these sensors costs under $35 and can be made in a regular lab without special equipment, and in tests it measured downward force within about 0.39 N and sideways force within about 0.16 N. Most cheap, flexible touch sensors can only feel straight-down pressure, so this is a big step; the team showed it by stopping a scalpel before it popped a balloon and by helping an AI-controlled robot plug in a power cable more reliably.

Researchers built SkeLAM, an AI system that learns to predict what a robot's camera will see next if the robot moves in a certain way, by watching lots of videos. Earlier versions got confused because they mixed up the robot's own movement with everything else changing in the scene, like a cup getting knocked over. SkeLAM fixes this by splitting what it learns into two parts: one tied directly to the robot's skeleton (its arm and joint positions) and another for everything else that changes in the scene. On a big robot dataset called DROID, it tracked the robot's gripper position 19.5% more accurately and made 11.1% more realistic-looking video than the previous best system, DreamDojo, and its predictions of whether a robot would succeed at a task lined up with real-world tests.

Researchers built an artificial skin for humanoid robots out of a dense grid of tiny sensors that detect touch by tracking how ions (charged particles) move in a soft, gel-like material. The skin is organized like the human nervous system, with some processing happening near the sensors and the rest happening higher up, so it can quickly shrink a flood of touch data into the important parts instead of sending everything to the robot's main brain. This setup let robots feel fine textures, handle delicate objects, and react to harmful stimuli (like a pain reflex). The abstract does not give specific performance numbers, such as sensor density or response speed, so those details would need to come from the full paper; what is different from earlier skins is that this one pairs a large, high-resolution sensor surface with built-in fast readout and data compression.

Researchers wanted to teach a simulated surgical robot to do delicate tasks using only camera images, the way a real surgeon sees the operating field. Training from images alone with standard trial-and-error learning turned out to be unreliable, and learning by copying human experts needs far more demonstrations than are practical in surgery. So the team first trained a 'teacher' robot that cheats by knowing the exact positions of everything in the scene, then trained a 'student' robot that only sees camera images and its own joint positions to copy the teacher. The student learned more consistently across the different surgical tasks than robots trained with general-purpose trial-and-error methods, and it needed far fewer human demonstrations than pure copying. All of this was tested in simulation only, and the abstract does not give specific performance numbers.

The researchers built a smarter control system for a wearable robot suit (an exoskeleton) that helps people move. The system watches how your whole body is moving, guesses several possible ways you might move next, and uses the average guess to decide how to help. When the guesses disagree with each other, the system takes that as a sign it isn't sure what you're about to do, so it makes the suit softer and more flexible to avoid fighting your movements. In tests, this approach reduced muscle effort compared with standard methods and lowered the energy people burned compared with wearing no assistance. The abstract does not give exact percentages, so the size of these gains isn't stated here. What sets it apart is that older systems act on a single prediction and can't tell when they're wrong, while this one measures its own uncertainty and adjusts.

Robots that follow spoken instructions (called vision-language-action, or VLA, models) often make mistakes, and catching those mistakes usually means running a second big AI model to watch over the first, which is slow and expensive. The researchers built Progress Probes (P²), a tiny add-on that reads the robot's own internal 'thoughts' while it works and estimates how far along it is in a task, like a progress bar. If the robot's progress stalls or goes off track compared to what it learned from good demonstrations, the system raises a flag that something is going wrong. Tested on the open-source π₀.₅ robot model in both simulation and real-world tasks, this simple approach matched or beat monitors that rely on separate vision-language models, and even beat methods trained on examples of failures, all without needing a second AI watching the robot.

Researchers built OpenTac, a stretchy 'robot skin' that can feel not just how hard something is pressing on it, but also which direction it's being pushed or dragged sideways, a feature most cheap touch sensors lack. They also made a design program that automatically creates the manufacturing files for a custom skin from a simple outline or even a text request like 'design a sensor for a size 9 shoe insole.' The team used it to build more than 30 different sensors and tested them on four real robots doing tasks that need delicate touch. Their faster reading method can check a 1,024-spot skin 19.2 times faster than the standard approach of scanning every spot one by one, and they've released all the designs and code for free.

Researchers built CoHelix, software that uses a special camera (an event camera, which reports only the pixels that change, instead of full video frames) to measure how fast each of a drone's four propellers is spinning, even while the camera itself is moving. The trick is that all four propellers sit flat on the same drone, so the system shares one picture of the drone's tilt and position across all of them, and each propeller's spin helps correct the shared picture used to read the others. This matters because earlier methods often lost track of the true speed or locked onto a wrong answer, like half or double the real rate. CoHelix stayed within 2% of the true speed 62.9% of the time on moving-camera tests, versus 39.8% for HelixTrack and 22.2% for EventPro, and reached 95.9% on a separate drone it was never tuned for, versus 56.2% and 61.1%.

Robots that learn from images and instructions often have several cameras, like one that sees the whole workspace and one mounted on the robot's hand. The researchers found that existing robot AI models mostly just stare through the hand camera the whole time, even when the wide view would help more, like when the robot is first figuring out where an object is. They built FocusVLA, which looks at what the robot has been doing recently to guess what it's about to do, then uses that guess to switch between the wide camera and the hand camera at the right moments. This boosted success rates by about 10 percentage points on a standard simulated test (RoboTwin 2.0) and from 71.7% to 85.0% on real robots, beating the previous best model, π0.5.

Researchers built VecTile, a thin, bendy sensor pad that works like artificial skin for robots and can feel not just how hard something is pressing down, but also which way it's sliding or dragging across the surface. It uses a pressure-sensitive layer topped with little silicone bumps that turn sideways pushes into distinct pressure patterns, and a 4x4 version costs under $35 and can be made without special equipment. In tests, it measured pushing force within about 0.39 newtons and sliding force within about 0.16 newtons (a newton is roughly the weight of a small apple). Most cheap, flexible touch sensors only feel straight-down pressure, so this is a big step; the team showed it could stop a scalpel from popping a balloon and helped a robot plug a power cord into an outlet much more reliably.

The researchers built a navigation system for mobile robots that pairs two tools: an AI model that has learned from example paths and can suggest several different routes to a goal, and a safety controller that steers the robot along the chosen route while avoiding obstacles and staying within the robot's physical limits. The AI planner alone can't react to a surprise obstacle, so the team added a trigger that makes the system re-plan whenever the controller has to swerve, feeding what the controller did back into the next set of suggested paths. In computer simulations of cluttered environments, including obstacles the robot had never seen before, the system navigated without collisions. The abstract doesn't give specific numbers, and the work was only tested in simulation, not on real robots.

The researchers built HyperDrone, a drone simulator that can generate millions of realistic camera images every second on an ordinary gaming graphics card, which is more than 20 times faster than the best earlier simulators of its kind. It pairs a fast model of how a quadcopter flies with a new graphics engine called HyperLux that uses the same ray-tracing technology that makes video game lighting look real, producing color images, depth maps, object labels, and motion information with reflections, shadows, and motion blur. To show it works, they taught an AI to steer a tiny Crazyflie drone's direction using its camera, training it entirely in the simulator. They then loaded it onto a real drone, where it ran on the drone's own small computer with no further training.

Companies record every step of their business processes in logs, like a trail of footprints, but those logs often mix together several different kinds of workflows, which makes one-size-fits-all analysis misleading. The researchers built TracePrism, an open-source tool that works like sorting a messy pile: you pull out one coherent group of cases, set it aside, and repeat with what's left, switching to a different way of comparing cases each round if needed. Every decision is saved and can be reopened later, with both the original choice and the revision kept on record. They tried it on three real-world event logs and it even surfaced things they hadn't planned for, like processes changing over time. The paper reports demonstrations rather than benchmark numbers, so there are no accuracy figures to compare against older methods.

Researchers built an artificial skin for humanoid robots made of a dense grid of tiny sensors that detect touch by tracking how charged particles move inside a soft, gel-like material. The skin is paired with fast electronics and a compression system that works like the human nervous system, so the robot's "brain" only gets the important touch signals instead of a flood of raw data. The abstract says this lets robots feel fine textures, handle delicate objects, and react to harmful, pain-like stimuli (such as sharp or damaging contact). The abstract does not give specific numbers like sensor counts or response times, but the key difference from earlier robot skins is that it can cover large areas with high detail without overwhelming the robot's processing.

Researchers built GenXR-Bench, the first big test for seeing how well AI coding assistants can build virtual and augmented reality apps, which are programs that react to your body movements and the room around you. The test has 112 tasks, like adding new features, fixing bugs, and building whole apps from scratch, and it checks the results by actually running them on real VR/AR headsets, agreeing with human expert judges 96.5% of the time. When they tried 10 different AI models, even the best one only got about 51% of tasks right on its first try. The AIs especially struggled with things that go beyond ordinary code, like handling sensors that report data at unpredictable times, making virtual objects behave as if they obey real-world physics, and understanding how people physically interact with 3D spaces.

The researchers built UniRAP, a single AI model that looks at a scene and understands a spoken or written instruction like 'pick up the mug by the handle.' It figures out which object you mean, which specific part of it to touch (the handle, not the rim), and exactly where and at what angle a robot gripper should make contact. Earlier systems usually split these jobs across separate programs that had to be stitched together, while UniRAP does it all in one pass and stays consistent as objects move in video. The paper reports it beats prior methods on three standard tests (finding objects from descriptions, locating usable parts, and predicting grasp positions), though the abstract doesn't give exact scores, and it trains in stages so it needs less hand-labeled text data.

Researchers built a system called ContactFlowFilter that lets a robot arm figure out where it is being touched, and how hard, using only the sensors already inside its joints and base, with no skin or cameras needed. This is tricky because several different touches can feel nearly identical to the sensors, and touches can start and stop at any moment. Their solution pairs a method that keeps a swarm of educated guesses and updates them over time with an AI model that suggests promising new guesses, including when a new touch appears. In real-world tests it located touches to within 0.36 cm for one contact and 0.88 cm for two, taking under 3 milliseconds per estimate.

Robots that need to see in every direction at once, like in a crowded hallway, often use a spinning laser sensor (LiDAR) that produces a flat, panoramic picture of how far away everything is. Teaching a robot to make sense of this picture while it learns to navigate by trial and error is slow, and existing pre-trained vision models are too bulky to run in the thousands of simulated robots researchers use for training. The team built RangeNav, a tiny 183,000-parameter 'eyes' network that they trained in advance on synthetic data to rebuild distances, label what objects are, and predict a bird's-eye map, then locked it in place while the robot learned to drive. Adding the labeling and map-prediction tasks raised success rates by about 32 percentage points in training worlds and about 24 points in realistic unseen worlds compared with distance-reconstruction alone, and a Unitree B2-W robot dog used it to walk through dense crowds, dark rooms, and construction zones without any real-world retraining.

The researchers built an AI system called the Video-Point Model (VPM) that watches videos of a scene from several camera angles, reads a text instruction, and then predicts both what the scene will look like next from any viewpoint and exactly where individual points in 3D space will move. The key trick is that every tracked point has to stay consistent across all the cameras, which forces the AI to understand the real 3D motion underneath the pictures instead of just making plausible-looking video. To train and test it, they created a simulated dataset called VPM-Data and a benchmark called VP-WorldBench covering both simulated and real environments. Compared to a version trained on video alone, the point-tracking version produced sharper videos, more accurate 3D motion, and higher success rates when they extended it to control robots in simulated and real-world manipulation tasks (the abstract does not give specific numbers).

The researchers built LocoPilot, a setup that lets one person control a robot dog with a robotic arm on its back, moving the body, the arm, and the gripper all at once. The person steers the dog with handheld controllers and moves a second, identical arm that the robot's arm copies, and the person even feels a push-back when the robot's arm bumps into something, even though the robot has no force sensor to measure it. While the person works, the system records what the robot's cameras see and exactly what commands were sent, and the team then used this data to retrain an existing AI model (MolmoAct2) on pick-and-place demonstrations and ran it on the real robot without having to translate or convert the commands. The abstract doesn't report numerical success rates, but the key difference from earlier work is that it combines recording on the real robot, touch feedback without expensive motion-capture cameras, and one command format shared by the human operator and the AI.

The researchers built a system called REACT that teaches a humanoid robot to do close-contact things with a person, like hugging, using videos of two humans doing those moves together. The tricky part is that when robot and person are pressed together, the person is blocked from the robot's camera, so it can't see what it's doing. To fix this, they used an AI that understands images and language to figure out which body contacts actually matter (like 'hand on shoulder') and copy those onto the robot, then trained the robot to guess where its partner's body is even when it can't fully see them. The result is a Unitree G1 humanoid that performed all five contact-heavy interactions using only its own onboard depth camera, with the partner-guessing trick improving contact success on four of five tasks, mostly where the person was most hidden. The paper's abstract doesn't give exact percentage numbers, so the gains are described qualitatively.

Companies often record every step of a business process, like handling a customer order or a patient visit, in a big log, but that log usually mixes together several different ways the work actually gets done. The researchers built an open-source tool called TracePrism that sorts these cases step by step: an analyst picks out a group that behaves alike, checks that the group makes sense both in how the work flows and in how it turns out, sets it aside, and repeats with what's left. Unlike older methods that use one fixed way of judging similarity for the whole log, TracePrism picks a new way of comparing cases each round and lets analysts reopen and revise earlier decisions while keeping a record of both versions. They tried it on three real-world logs and, along the way, spotted things they hadn't expected, such as processes changing over time (called process drift). The abstract doesn't report numerical performance results, so the evidence is demonstration scenarios rather than benchmark scores.

Robots that combine sight and touch can get confused when conditions change, like dim lighting, a worn-out touch sensor, or a swapped-in new sensor, and one unreliable sense can drown out the other sense that was actually right. The researchers built SenseAlign, a method that fixes this while the robot is working, with no new labeled training examples and no retraining of its core vision or touch models. It does two things: it checks how well each sense agrees with word descriptions of the possible objects (for example, 'smooth glass' or 'rough fabric') to decide which sense to trust more, and it uses those same word descriptions to nudge each sense's readings so similar-looking objects are easier to tell apart. The paper says it performed strongly across many datasets with both real-world changes and artificially added corruptions, but the abstract gives no specific accuracy numbers, so the size of the improvement is not stated here.

Researchers built an artificial skin for humanoid robots that works a bit like human skin and the nervous system behind it. It is covered in a dense grid of tiny sensors that detect touch by tracking how charged particles move inside a soft, gel-like material, and a fast readout system plus data compression keep all that information manageable instead of overwhelming the robot's brain. Like the human nervous system, it handles information in layers, so simple reactions (like pulling away from something harmful) can happen quickly while finer details get processed further up the chain. The abstract says this lets robots feel fine textures, handle delicate objects, and react to painful-type stimuli, but it doesn't give specific numbers such as sensor counts or response times, so those details would need to be checked in the full paper.

I can't write a faithful summary of this paper because the material provided contains only the title, the journal name, and the issue date. It has no author list and no abstract, so there are no findings, numbers, or methods to draw on. From the title alone, I can say that 'Fast Feature Field (F3)' appears to be a general-purpose way for robots to interpret events (likely from event-based cameras, which respond only to changes in a scene) and to predict what will happen next, but I can't say how it works, what it was tested on, or how well it performed without inventing details.

Researchers took a general-purpose AI model (the kind that understands text and images) and taught it to control a robot hand that can feel touch, without any special robot training. They showed it a few expert demonstrations, boiled those down into written tips and 'what touch should feel like' examples, and let the AI read live touch-sensor feedback to fix its mistakes as it worked. On five touch-heavy tasks, it succeeded 93.8% of the time on average, about as well as specially trained robot AI systems that need lots of data and per-task tuning. On a peg-in-hole style task called Insert Hole, using touch feedback jumped its success from 31% to 99%.

The researchers built PhysCanvas, an AI system that acts like a video game version of the real world for robots, predicting both what a robot would see and what its fingertips would feel when it touches things. Testing robots in the real world is slow and expensive, but earlier AI simulators often looked realistic while getting the physics of touch wrong, so they gave misleading feedback. PhysCanvas fixes this by combining camera views, touch-sensor images, and the robot's movements in one model, then training it with three 'grader' models that check it stays consistent with how real tasks actually turn out. As a result, its predicted success rates matched real-world results much better (a correlation score rising from 0.602 to 0.885 across four tasks), and a robot policy practiced inside it improved from 59.1% to 70.8% real-world success.

Teaching a robot hand to "feel" usually means collecting huge amounts of data from the robot itself, which is slow and has to be redone for every new hand or sensor. The researchers built a system called HuTact that first studies videos and motion data of humans handling objects, learning how fingers and objects interact, without any touch-sensor data at all. It then carries that knowledge over to a robot's touch sensors and fine-tunes with a small amount of unlabeled robot play data. In a test on predicting grasps, it matched the score of a model trained on all the labeled data (88.26% vs. 88.23%) while using only 25% of the labeled examples.

The researchers built UniWALM, a single AI model that watches video, picks robot actions, and writes down short notes in plain English all at the same time, instead of using separate programs for planning, seeing, and moving. The robot's own notes get fed back to it on the next step, so it can 'remember' what it already did, like someone jotting down where they have already looked. In a real-world test where a robot had to find a hidden item, writing these notes raised its success rate from 11.1% to 61.1%, while top existing robot AI systems did no better than chance (33.3% or less). It also beat a rival memory-based approach on a standard test, scoring 34.5% versus 28.5%, without needing any pretrained language model and using just one reference image.

Researchers took GPT-6 Astra, a general-purpose AI that understands images and text, and tested whether it could directly control a robot arm without being trained as a robot specialist. It showed some surprising skills: it could use depth information, pick up simple tasks from a few example demonstrations, and fix its mistakes using touch feedback. It scored 76% on the RoboTwin 2.0 benchmark and 26.92% on RoboDojo, but only 11.1% on LIBERO-GeoMotion, a new test the team built that requires precise positioning and anticipating the physical consequences of movements. In short, the AI is good at understanding what to do but still struggles to turn that understanding into smooth, precise, safe physical motion, and it is also slow to respond.

Robots that run on AI "brains" have a timing problem: while the robot is busy carrying out one set of moves, the AI is already working out the next set, but by the time it finishes, the scene has changed and its plan is based on an outdated view. The researchers built PACT-VLA, which has the AI draft several possible next move-sets and then, using the waiting time, takes a fresh look at the scene and lets the same AI pick the one that fits best, with no extra training or separate judge needed. With a four-step delay, it beat the previous method (RTC) by 15 percentage points on a simulated task set called Kinetix and a single-plan approach by 5.2 points on another called LIBERO. On three real-robot tasks it raised success from 60% to 82% using the same AI model. Unlike earlier approaches, it picks one full plan late with fresh information instead of judging plans by the old view or hopping between plans mid-motion.

Researchers built PrismWAM, a robot-brain system that splits its thinking into two separate jobs instead of mashing everything together. First, it looks at a single camera image and imagines what the finished task should look like (the 'what' and 'looks'). Then it separately imagines how objects physically move to get there, using depth (distance) maps instead of colors and textures, and turns that movement into robot commands. The abstract doesn't give specific benchmark numbers, but the team reports strong results in both simulation and on real robots without any special robot-action pretraining, and says it even beats models like OpenWAM-α that were trained on huge amounts of robot data.

Researchers reviewed how AI-based image compression, which shrinks photos into much smaller files, can move from lab experiments to real products, and they built an open test system called TinyLIC to measure the trade-offs. AI compressors have been beating traditional formats like HEVC (the standard behind much of today's video) in quality per file size, but they often need too much computing power and can give slightly different results on different chips, which breaks the decoding. TinyLIC shows that a very lightweight version, needing only about 10,000 math operations per pixel to unpack an image, already beats HEVC's still-image mode on a standard test set called Kodak. A bigger version at 50,000 operations per pixel matches VVC, the newest traditional standard, on several test sets.

Researchers built a system called XRT that lets two people each remotely control a humanoid robot to carry a heavy crate together, then added a small buzzing sensation on the operator's fingertip (or a sound played through open-ear speakers) whenever the robot's fingertip touched the crate. Sixteen pairs of people lifted and flipped a crate with no touch feedback, buzz only, sound only, and both. All 32 people ranked the fingertip buzz as more helpful than the sound, and 18 picked it as the best of all, saying it was far easier to feel and understand. But the surprise is that the feedback didn't measurably change how fast teams finished, how often they failed, or how hard the task felt; practice mattered much more, since teams got noticeably faster over repeated tries.

Researchers built RoboPhoto-VLA, a single AI system that lets a robot camera take photos the way a human photographer would: it reads an instruction like 'take a flattering portrait,' looks at the scene, works out step by step how to move the camera, and then moves it. To teach the robot what looks good, they trained it on human preferences using a method called ADPO, and they created OpenPhotography, a new collection of example photo sessions paired with written instructions. In real-world tests, the robot's photos matched human taste better than earlier approaches, and it handled people, camera angles, poses, and tricky instructions it had never seen before. The abstract doesn't give specific numbers, so exact performance gains over earlier systems aren't stated here. What makes it different is that older systems split seeing, planning, and moving into separate pieces, while this one learns them together as one model.

Researchers built an artificial skin for humanoid robots that works a bit like human skin and nerves: it uses a dense grid of tiny sensors that detect touch by tracking how charged particles move in a squishy, gel-like material. The skin doesn't send every raw signal to the robot's main computer; instead, it quickly reads and squeezes the data down first, much like our nerves handle things before they reach the brain, so it can cover large areas without getting bogged down. With this skin, robots could feel fine textures, handle delicate objects, and react to harmful stimuli (like something too sharp or hot) as a kind of built-in pain reflex. I can only work from the abstract here, so specific numbers like sensor density, response time, or the compression ratio aren't included, but the key difference from earlier skins is combining high-density sensing, fast readout, and data compression in one large-area system.

I can't write a reliable summary of this paper because the information provided contains only the title, journal name, and a placeholder abstract, with no authors, findings, methods, or numbers, and I can't verify the paper's actual contents. From the title alone, 'Fast Feature Field (F3)' appears to be a general-purpose way for robots to represent events, likely from event cameras, which only record changes in a scene rather than full images, so that a robot can predict what will happen next. Reporting specific results, speedups, or accuracy figures without the paper's text would mean inventing them, which I won't do.

Researchers taught a small humanoid robot called NAO to pick things up, move them, and push objects just by watching videos of a person doing the task. Instead of making the robot learn from millions of raw camera pixels, which takes huge amounts of data and computing power, they first boiled each video down to a few key facts: where the person's joints were (tracked with a Kinect camera) and where the objects were in 3D space (found by telling an AI what to look for in plain words). The robot then learned from those compact facts, and in simulation it succeeded 78% of the time at pick-and-place after seeing just 16 demonstrations, rising to 86% with 100 demonstrations. It also pushed objects successfully 71% of the time after only eight demonstrations, and the team showed it working on a real robot too.

Researchers showed that GPT-6 Astra, a general-purpose AI model, can learn to use the sense of touch for robot hands without being built for it. Tactile sensors produce small camera-style pictures that show how a surface is being pressed, and the team simply fed those pictures into Astra the same way it looks at normal photos. In computer simulations of 19 tricky tasks, where robots must carefully grip, line up, and handle objects, Astra succeeded about 94% of the time on one test set and 82% on the other, beating the best specialized robot programs by 23 and 13 percentage points. Until now, experts assumed that touch-heavy tasks needed custom-built, single-purpose AI, but this suggests a general AI can do it after seeing just a few examples. Results came only from simulation, and the model still struggled with things like handling sideways forces and fixing its own mistakes.

Researchers took two versions of a cheap robot hand (the LEAP Hand), one with fingers laid out like a human hand and one with a symmetric, evenly spaced layout, and gave both artificial fingertip 'skin' that sees touch using tiny cameras. They taught each hand through trial and error to keep spinning an object in its palm, testing it on 12 unseen objects in simulation and 10 in real life. Giving the hand rich touch information instead of just joint positions made the robot rotate objects 95% further with the human-like hand and 67% further with the symmetric one, while squeezing less hard overall. In real-world tests, the symmetric hand did better, spinning objects 32% more times with 20% less total fingertip force, because its fingers shared the work more evenly, while the human-like hand relied more on a few specialized fingers.

Researchers built EgoXperience, a system that teaches computers to make sense of videos filmed from a person's own point of view, like a head-mounted camera. Their model, called EgoX, watches one regular video and, in a single pass, works out where the camera moved, what the room looks like in 3D, and how the person's hands and the objects they touch move through that space, all placed in the same shared map of the world. To train it, they built an automatic labeling tool and used it to create a 50-hour dataset of people doing tasks indoors and outdoors, with sentence-level descriptions of what's happening every second. Compared to the best existing methods, EgoX cut camera errors by 68.9%, hand errors by 65.6%, and depth errors by 42.9%, and improved object-tracking scores by 28.0%.

Quantum computers are built from tiny parts called qubits, and on real machines each qubit can only talk directly to a few neighbors, so running a quantum AI model means adding lots of extra steps to shuttle information around. The researchers built a tool called ConQUESTA that trims away the connections in a trained quantum neural network that matter least, while checking that the finished circuit still gets the answers right. Instead of ranking connections one by one, it tests whole trimmed designs against how real chips are wired, and it cut the work the quantum chip has to do by about 62% to 82% on three test tasks (breast cancer, handwritten digits, and iris flowers), beating the best simple approach by 2 to 9 percentage points. It also found valid trimmed designs in 22 of 24 runs, up from 16 of 24, and it only had to check a few hundred designs even when the number of possible designs grew to over 12 million.

Researchers built an electronic skin for humanoid robots that works a bit like human skin and nerves: it uses a dense grid of tiny touch sensors that detect pressure through the movement of ions (charged particles) in a soft material. The skin also has a fast readout system and a data-compression step, so it can handle huge amounts of touch information without bogging down the robot's brain, similar to how our nerves and spinal cord filter signals before they reach the brain. With this setup, humanoid robots could feel fine textures, handle delicate objects, and react to harmful stimuli (like pain-style reflexes). Only the abstract was available to me, so specific figures such as sensor count, skin area, or response speed are not included here; the key difference from earlier e-skins is that this one scales to large areas while processing touch in layers rather than sending raw data everywhere.

I can't write a reliable summary of this paper because the information provided is too thin: the author list is blank, and the abstract field contains only the journal citation (Science Robotics, Volume 11, Issue 119, October 2026), not the paper's actual findings. From the title alone, 'Fast Feature Field (F3)' appears to be a representation that helps robots predict upcoming events from event-camera data, but I don't know what the researchers built, what they tested, or what numbers they achieved. To avoid inventing results, please supply the full abstract or paper text.

Most of what scientists know about how our brains handle attention, memory, and language comes from experiments where people sit still, stare at a flat computer screen, and press buttons while their heads are held steady for brain scans. This paper is a review, not a new gadget or a single experiment: the authors look at a growing pile of studies, including their own, that use virtual reality (a fully digital world) and augmented reality (digital objects layered onto the real room) so people can move around, reach for things, and look at 3D scenes while their brain activity is recorded. The paper doesn't report one headline number; its main finding is that this approach lets researchers run experiments that are both tightly controlled and much closer to real life. The authors also warn that problems with headset hardware, split-second timing, and measurement accuracy still have to be solved, and that a virtual world is not a perfect stand-in for the real one.

The researchers built a new robot planning method called Time-Optimal Ergodic Retrieval (TOER) for jobs where a robot has to search an area, find an object, and bring it back to base as fast as possible. Older search planners only tried to finish a full, complete sweep of the area quickly, even though a real robot stops searching the moment it finds the object and then has to travel home. TOER treats finding the object like a game of chance that could happen at any moment, and it plans the search with the trip home built into the calculation. In tests, this cut total mission time by up to 19% compared to older methods, with bigger savings when the trip home is more costly, and it worked in both simulation and real hardware, in 2D and 3D spaces, and in areas with odd shapes and obstacles.

The researchers built REKI, a robot-control AI with 2.4 billion parameters that looks at camera images, reads instructions, and decides what the robot's arms should do, and they trained it only on publicly available data. They gave it a simple short-term memory: a few extra 'note-taking' slots that summarize what the robot saw in recent moments, so it remembers what it just did. This memory makes robots about four times less likely to get stuck wobbling back and forth between poses, and it also boosts success rates in both simulations and on real robots. On three standard robot tests (LIBERO-Plus, RoboTwin, and RoboCasa365), only models roughly twice as big beat REKI, so it gets strong results for its size.

The researchers built P³-WAM, a single AI model that learns to watch a first-person video of hands handling objects, imagine what will happen next if the hands move in a certain way, and come up with a plan of hand movements to reach a goal you describe in words or a picture. Normally these three jobs (understanding hand motion in 3D, predicting future video, and planning actions) are handled by three separate systems, but here they share one video-generating AI brain that is trained on all three at once. The abstract reports that training all three jobs together made each one better than training them separately, and the model beat specialized single-purpose systems at 3D hand tracking and at predicting video from planned actions across four datasets. When asked to plan, it also produced manipulation videos that followed instructions more closely and showed more realistic progress toward the goal than ordinary video-generation models. The abstract does not give exact numbers, so the size of those gains isn't specified here.

Researchers taught a small wheeled robot (a TurtleBot3) to dodge both still and moving obstacles using just one ordinary camera, without ever figuring out how far away things are or how big they are. Instead, the robot watches how the picture shifts from moment to moment (called optical flow) and uses that to judge whether it is on a collision course. A learning program running on the robot estimates how fast obstacles are approaching and tracks how wrong its own guess might be, then builds in extra safety room to cover that error. Their error estimates held up in 98.3% of simulation samples, and the robot got through cluttered rooms without a crash in 93 of 100 real-world trials.

Researchers built an artificial skin for humanoid robots that works a bit like human skin and nerves. It is covered in a dense grid of tiny sensors that feel touch using moving charged particles (ions) in a soft material, and a fast reading system plus data-squeezing step passes the signals up through layers, much like nerves sending messages to the brain. Because the skin only passes along the important information, it can cover large areas without being overwhelmed by data. With it, a robot could feel fine textures, handle delicate objects, and react to painful stimuli. Note: the abstract provided does not include specific numbers (such as sensor count or response time), so I can't cite exact figures without reading the full paper.

I can't write an accurate summary of this paper, because the information provided contains only the title ("Fast Feature Field (F3): A general predictive representation of events for robot perception") and journal citation (Science Robotics, October 2026). The abstract, author list, methods, and results were not included, and I don't have reliable access to the paper's contents. From the title alone, F3 appears to be a way for robots to represent what their event-based sensors (cameras that report only changes in a scene) see, in a form that predicts what will happen next. But I can't state what the researchers built, what numbers they achieved, or how it compares to prior work without inventing details.

Big AI models that connect images and text can already recognize new objects from just a handful of example photos, but they usually only look at the very last step of their processing and ignore useful clues from earlier steps. The researchers built LAMP, which grabs those earlier clues in a single pass, makes a separate prediction from each layer, and blends them using a small set of labeled photos, with no retraining of the model at all. Averaged across five different amounts of example photos, LAMP beat the standard last-step-only approach by about 1.1 to 1.6 percentage points, and an upgraded version, LAMP-F, improved it by about 2.0 to 2.5 points. At 16 example photos per category, LAMP scored 78.73% on average with a ResNet-50 model, the best among published methods that don't require training, and LAMP-F reached 83.57% on the larger ViT-B/16 model.

The researchers built VIGOR-MPC, a system that teaches a camera-guided race car to drive well without needing a powerful computer. First, a 'teacher' driver in simulation, which can see the whole track perfectly, learns to plan far ahead while keeping the track in view of its camera. Then a lightweight 'student' driver, which only gets the messy, partly blocked view a real camera would give, learns to copy the teacher by adjusting what its short-range planner cares about on the fly. In simulation and on a real car, the student handled tracks it had never seen, came close to the teacher's lap times, and used over 90% less computing per decision.

Robots that predict what will happen when they act often get it wrong because they can't see hidden factors like how slippery a surface is, how heavy an object is, or what the rules of a task are. The researchers built T2-Z, a system that gives a robot's world model a small adjustable 'environment note' (called a latent) that it figures out on its own, with no one telling it what factors exist. When the robot enters a new situation, it freezes the main model and just tunes this note from one or a few quick interactions, like a person nudging a box to feel how heavy it is. Across 7 simulated settings and 4 real-world robot tasks, this cut prediction error from 15.20 to 7.00 and raised the rate of successful actions from 33.73% to 72.96%.

Humanoid robots that copy human movements are usually trained to be very stiff, so if someone bumps or pushes them, they react in unpredictable and sometimes unsafe ways. The researchers built C-GMT, which keeps an existing, already-trained motion-copying robot brain and adds a small 'adapter' on top that watches the robot's recent body feelings (like joint positions and movement) and gently adjusts its targets so it gives way to pushes instead of fighting them. Before this, robots were either good at copying lots of different motions or good at being soft and flexible, but only for one specific motion, and C-GMT does both. The abstract reports competitive accuracy and softness compared to the best existing methods and better safety and recovery in simulation and on a real Unitree G1 humanoid, but it doesn't give specific numbers.

Most brain and behavior experiments have people sit still in front of a flat computer screen, press buttons, and keep their heads motionless inside brain scanners, which captures only a narrow and unusual slice of how people actually act. In this review paper, the researchers pulled together studies of attention, memory, and language (some their own, some from others, a few using EEG brain recordings) that used virtual reality headsets and augmented reality glasses to let people move around and interact with 3D tasks while experimenters kept tight control and could repeat the setup exactly. The authors did not build one new device or report a single headline number. Instead, they argue that XR opens up studying the brain during natural, active behavior, while warning that problems with hardware, timing precision, and measurement still need solving, and that a virtual world is not a perfect stand-in for the real one.

The researchers built a new way for robots to plan search-and-fetch missions, like finding an object in a big space and bringing it back to a home base as fast as possible. Older methods planned the fastest way to search an entire area, but that's wasteful when the robot will stop searching the moment it finds the object and then has to travel back. The new method, called time-optimal ergodic retrieval (TOER), treats finding the object as a matter of chance during the search and plans the path to minimize the total time of searching plus the trip home. In tests it cut mission times by up to 19% compared to older approaches, with the biggest gains when the trip back was long or costly, and it worked in both simulations and real-world robot tests, in flat and 3D spaces with obstacles.

The researchers built REKI, a 2.4-billion-parameter AI 'brain' for robots that looks at camera images, reads instructions, and decides how to move. It was trained only on publicly available data, and on three major robot tests (LIBERO-Plus, RoboTwin Clean2Rand, and RoboCasa365) only models about twice its size beat it. Their key trick is giving the robot a short-term memory: a few special 'register' tokens quietly summarize what the robot just saw and keep that summary around at almost no extra cost. This memory helped robots succeed more often in both simulation and real life, and made them about four times less likely to get stuck wobbling back and forth between two poses.

The researchers built P³-WAM, a single AI model that learns to do three connected jobs for robot hands: Perceive (watch a video and work out how the hand and camera moved in 3D), Predict (imagine what the video will look like next if the hand does a certain action), and Plan (given a starting image and a text instruction like 'pour the water,' invent both the hand movements and a video of what should happen). Instead of training three separate models, they plugged a compact 3D description of hand motion into an existing video-generating AI, so seeing, predicting, and planning share what they learn. Training all three together made each skill better than training it alone, and the combined model beat specialized models at 3D hand reconstruction and action-conditioned video prediction across four datasets. Its planned videos also followed instructions more closely and showed more realistic progress toward the goal than regular video-generation models. The abstract does not give exact numbers, so the size of the gains isn't specified here.

The researchers taught a small wheeled robot (a TurtleBot3) to dodge obstacles using just one ordinary camera, without ever figuring out how far away things are or building a map. Instead of guessing where obstacles are, the robot watches how things in the image move (called optical flow) and uses that to judge whether it's on a collision course, much like how you sense a ball heading toward you without calculating its exact distance. A built-in 'safety filter' gently nudges the robot's planned path only when needed, and it accounts for its own uncertainty by leaving extra safety margin. In 100 real-world trials in cluttered spaces with both still and moving obstacles, the robot made it through without a crash 93 times, and its self-reported error limits held true in 98.3% of simulated tests.

Li and colleagues built a robot skin that works a bit like human skin and the nerves behind it. It has a very dense grid of tiny pressure sensors that detect touch by tracking how charged particles move inside a soft material, plus fast electronics that read all those signals and squeeze the data down so it isn't overwhelming. This lets a humanoid robot feel fine textures, handle fragile objects, and react to harmful touches, like a sharp poke, the way a pain reflex would. What's new is that earlier robot skins either covered small patches or couldn't process all their sensor data quickly, while this design handles a large surface by sorting information in layers, like the nervous system does. The abstract doesn't give specific performance numbers, so details like sensor count and response time would need to come from the full paper.

I can't write a reliable summary of this paper because the information provided contains only a title (Fast Feature Field (F3): A general predictive representation of events for robot perception) and a journal issue, with no authors, abstract text, methods, or results. From the title alone, F3 appears to be a way of representing what an event camera sees (cameras that only record changes in a scene rather than full frames) so that robots can predict what happens next. I don't have the actual findings, performance numbers, or comparisons to earlier approaches, and I won't invent them. Please share the abstract or full text and I can write an accurate, specific summary.

AI systems that match pictures to words, like the ones that recognize objects from a few example photos, usually only use the very last layer of their 'brain' to make a decision, ignoring useful clues from earlier layers. The researchers built LAMP, a method that lets each layer make its own prediction and then blends those predictions together using a small set of labeled examples, with no retraining of the model at all. Across eleven image datasets, it beat other published no-training methods using a ResNet-50 model (78.73% accuracy with 16 examples per category) and improved on a standard baseline by about 1 to 2.5 percentage points on average. The upgraded version, LAMP-F, pushed 16-example accuracy to 83.57% on one model type and 79.10% on another, and tests showed that combining multiple layers was the main reason for the gains.

The researchers built VIGOR-MPC, a system that teaches a robot car to race using only its onboard camera, even when its view of the track is blurry, partly blocked, or incomplete. First, a 'teacher' controller in simulation, which can see everything perfectly and plan far ahead, figures out the best way to drive. Then a lightweight 'student' controller learns to copy the teacher using only what the camera sees, by learning how to adjust its own driving priorities on the fly. In simulation and on real hardware, the student drove well on race tracks it had never seen, came close to the teacher's lap times, and needed over 90% less computing power per step.

Robots that predict what will happen after they act are often tripped up by hidden things they can't see, like how slippery a surface is or how heavy an object is. The researchers built T2-Z, a system that gives a robot's 'world model' (its internal simulator for predicting outcomes) a small learned set of numbers describing the environment, without anyone telling it what factors to look for. When the robot meets a new situation, it keeps the model fixed and quickly tunes just those numbers from a single trial run, instead of retraining everything. Across 7 simulated settings and 4 real-world robot tasks, this cut prediction error from 15.20 to 7.00 and raised the rate of successful actions from about 34% to 73%.

Humanoid robots that can copy almost any human movement, like dancing or walking, are usually trained to follow their target motion stiffly, so when someone bumps or pushes them they can react in unsafe, unpredictable ways. The researchers built C-GMT, a add-on module that sits on top of an existing motion-copying robot brain and learns to give a little when pushed, using the robot's recent sense of its own body position and movement. This lets one robot keep copying a huge range of motions while also yielding gently to outside forces, instead of needing a separate custom 'soft' program for each motion. The abstract says it tracked motions about as accurately as the best stiff systems and was as springy as the single-motion soft ones, and it worked in both simulation and on a real Unitree G1 humanoid, though the abstract does not give specific numbers.

This paper is a review, not a single experiment, so there are no new numbers or a new gadget to report. The authors argue that most brain-and-behavior research uses artificial setups: people sit still, stare at flat screens, press buttons, and keep their heads motionless for brain scans. Pulling together studies of attention, memory, and language (including some of their own, a few using brain-wave recording while people wore headsets), they show that virtual reality and augmented reality let researchers run controlled, repeatable experiments where people actually move around and interact in 3D spaces. They also warn that the technology still has real problems, like imprecise timing between headset and brain recordings, hardware limits, and the fact that a virtual world is not the same as real life.

The researchers built a new robot planning method called Time-Optimal Ergodic Retrieval (TOER) for jobs where a robot has to search an area, find an object, and carry it back to its starting point as fast as possible. Older methods plan the search as if the robot will cover the whole area and only care about making that search quick, but in real life the robot stops searching the moment it finds the object, and then it has a trip home to make. TOER treats finding the object as a matter of chance, like rolling dice at each spot, and plans the path so the search time plus the trip home is as short as possible. In tests, this cut total mission time by up to 19% compared to older search planners, and the gap got bigger the harder the trip home was, and it worked in both simulations and real robots, in flat 2D and 3D spaces and in oddly shaped areas.

Researchers built REKI, a 2.4-billion-parameter AI "brain" for robots that looks at camera images, reads instructions, and decides how to move. It was trained only on publicly available data, and on three major robot-skill tests (LIBERO-Plus, RoboTwin, and RoboCasa365) it was beaten only by models roughly twice its size. The team also gave it a simple short-term memory: a handful of extra summary tokens that carry information from recent moments forward at almost no extra computing cost. This memory helped the robot succeed more often in both simulation and real-world tests, and made it about four times less likely to get stuck wobbling back and forth between positions.

The researchers built P³-WAM, a single AI model that teaches itself three connected skills for robot hands working from a first-person camera view: figuring out how a hand and camera moved from a video (Perceive), imagining what the video will look like if the hand does a certain action (Predict), and coming up with both the hand movements and the imagined video needed to finish a task described in words or a goal picture (Plan). Instead of training three separate models, they built it on top of an existing video-generating AI and taught it all three jobs at once by randomly hiding different pieces (video or hand motion) during training so the model learns to fill in whatever is missing. Training everything together made each skill better than training them alone, and the model beat specialized single-purpose systems at reconstructing 3D hand motion and predicting action-based video across four datasets, while also making videos that follow instructions more closely than regular video generators. The abstract doesn't give exact scores, so the main finding is that one combined model beat the specialists rather than a specific number.

Researchers taught a small wheeled robot (a TurtleBot3) to dodge obstacles using just one ordinary camera, without ever figuring out how far away things are or how big they are. Instead, the robot watches how things in its view appear to move across the image and uses that to tell whether it's heading for a crash, then nudges its steering only as much as needed to stay safe. The system also keeps track of how wrong its own guesses might be and builds in an extra safety cushion to cover that. In simulation its error estimates stayed inside the predicted safe range 98.3% of the time, and in real-world tests the robot made it through cluttered spaces with both still and moving obstacles without a collision in 93 out of 100 trials.

Li and colleagues built an artificial skin for humanoid robots out of a dense grid of tiny sensors that detect touch by measuring how charged particles (ions) move inside a soft material. Instead of sending every sensor's raw signal to the robot's main computer, the skin processes and shrinks the data in layers, the way human nerves filter touch signals on the way to the brain, so it can read signals quickly even when it covers a large area. In the reported demonstrations, this let a humanoid robot feel fine surface textures, handle fragile objects, and react to harmful stimuli like pain-type signals. The abstract does not give specific numbers such as sensor counts or response times, so those details would need to come from the full paper; the main difference from earlier electronic skins is that this one pairs a high-density sensor array with built-in data compression, which has been a major bottleneck for covering a whole robot body.

I can't write a reliable summary of this paper, because only its title and journal were provided. The authors, the abstract text, and the results were all missing. Going by the title alone, Fast Feature Field (F3) appears to be a way for robots to make sense of what they see by predicting how a scene will change, probably using event cameras that react only to changes rather than capturing full frames. But I don't know what F3 was tested on, how well it performed, or how it compares with earlier approaches, so I won't invent numbers or findings.

Researchers built LAMP, a method that helps an AI image-recognition model learn new categories from just a handful of example photos, without any retraining. Most approaches only use the model's final 'answer' layer, but LAMP also pulls clues from the middle layers of the same model, which capture details like textures and local shapes, and blends them using a small set of labeled examples to decide how much to trust each layer. On eleven image datasets, this beat other published no-training methods for the common ResNet-50 model, reaching 78.73% accuracy with 16 examples per category, and its upgraded version (LAMP-F) hit 83.57% on a stronger model. The key finding is that the extra accuracy, roughly 1 to 2.5 percentage points over using the final layer alone, comes mainly from combining information across layers rather than from extra tricks.

The researchers built VIGOR-MPC, a system that lets a robot race around a track using only its onboard camera, even though the camera view is noisy and sometimes blocked. First, a 'teacher' planner in simulation, which sees everything perfectly and plans far ahead, figures out the best way to drive while keeping the track in view. Then a lightweight 'student' planner learns to copy the teacher's smart driving using only what the camera actually sees, by learning how to tune its own driving goals on the fly. The student drove on tracks it had never seen before, in simulation and on real hardware, came close to the teacher's lap times, and needed over 90% less computing per step.

Robots often can't see things like how slippery a surface is or how heavy an object is, which makes it hard for them to predict what will happen when they push or move something. The researchers built T2-Z, a system that gives a robot's 'imagination' model a small hidden code describing the environment, and then figures out that code on the spot from just a few tries at the new task. The robot was never told what factors to look for, like friction or mass; the useful patterns emerged on their own during training. Across 7 simulated settings and 4 real-robot tasks, this cut prediction mistakes from 15.20 to 7.00 and boosted how often the robot succeeded from about 34% to about 73%, even when it only watched a single attempt in the new environment.

Today's best humanoid robots can copy almost any human movement from motion-capture data, but they do it stiffly, like a robot that refuses to give way even when someone bumps or pushes it, which can be unsafe. The researchers built Compliant GMT (C-GMT), which keeps an existing, already-trained motion-copying system and adds a small helper module on top. The helper watches the robot's recent body sensations (how its joints have been moving and feeling) and nudges the target motion so the robot gives way to pushes instead of fighting them. The abstract doesn't give specific numbers, but the team reports that C-GMT tracks motions about as accurately as top general-purpose trackers and responds to forces about as well as policies built for just one motion, and they showed it working in simulation and on a real Unitree G1 humanoid.

This is a review paper, not a new robot or experiment, so there are no new test results or numbers to report. The authors read through the fast-growing pile of research on giving robots a sense of touch and organized it by what touch actually does inside a robot's brain: helping it learn useful 'feelings' about objects, guiding how it moves its hands, predicting what will happen when it pushes or grips something, and carrying skills over to new objects, new sensors, and new robot bodies. Earlier surveys mostly covered the touch sensors themselves, but this one focuses on how robots learn from touch data. The authors conclude that touch is shifting from a simple 'did I bump into something?' alarm into a core sense that could power general-purpose robots, and they point toward large 'foundation models' for touch, like the ones behind modern chatbots, as the next step.

This is a review paper, not a single experiment, so the authors didn't build one gadget or report one headline number. Instead, they pulled together lessons from their own and other researchers' studies using virtual reality (a fully digital world) and augmented reality (digital objects layered over the real room). The core problem they point to is that most brain-science experiments have people sit still, stare at a flat screen, and press buttons while their head is held steady, which captures only a narrow, unnatural slice of how people actually behave. Their argument is that VR and AR let scientists run controlled, repeatable experiments where people walk around, move in 3D, and interact with things (even while wearing brain-activity sensors), but they warn that headset hardware, precise timing, and measurement quality still need work, and that a virtual world is not a perfect stand-in for reality.

Researchers wanted to know if a special 'event camera', which only reports pixels that change instead of snapping full photos, can do a better job than a normal camera at seeing through leaves and branches by combining views from a moving camera. They tested this in a computer simulation so both cameras saw the exact same scene and movement. When the camera moved fast (25 meters per second) in bright light, the normal camera only captured three pictures and couldn't see past the leaves, while the event camera still found the hidden target, even after throwing away most of its data. But in dim light at that speed the event camera failed too, and at slow speed (1 meter per second) it had no advantage over a normal camera.

The researcher built a system that turns a phone video of a person doing a task into a 'body-free' record of what happened to the object: where it moved, when it was touched, and a 3D model of it. Instead of copying the human hand's motions onto a robot, the system checks whether each robot could reproduce the object's motion, and it tests this in simulation for each robot. Across 42 recordings and 8 robots (157 pairs), 31.2% passed, 52.2% failed, and 14.0% were refused up front with a stated reason, such as a robot hand that is welded shut in its public model. Every one of the 13 refused pairs that were run anyway failed, so the refusals were right, while just reading a robot's description file barely predicted which robots would succeed. No robot policy has been trained on this data yet.

I can't responsibly write a specific summary of this paper, because the only details provided are the title (Fast Feature Field, or F3: a general predictive representation of events for robot perception) and a journal issue date; the abstract, author list, and results were left blank. From the title alone, F3 appears to be a way of turning the output of event cameras (sensors that report only changes in a scene, not full frames) into a compact, reusable representation that predicts what will happen next, so robots can perceive fast motion efficiently. Any specific numbers, benchmarks, or comparisons to earlier methods would have to come from the paper's actual text, and I won't invent them.

Researchers built FoveaVLA, a robot brain that works like human eyesight: instead of strapping a small camera to the robot's hand, it uses one or two cameras fixed in the room and teaches the robot to 'zoom in' on the exact spot it will need to see next. Along with each batch of movements, the robot predicts where to look next, then gets a sharp, full-detail crop of that area plus the wide view of the whole scene. In real-world tests across four types of tasks, the one-camera version succeeded 70.8% of the time and the two-camera version 77.1%, compared with 52.1% for a similar robot model that had a hand camera. The new approach matched the old one on simple pick-and-place jobs and did better with cluttered tables, folding cloth, and reaching far-away objects.

Imagine driving a race car using only a camera, where the view of the track is blurry, sometimes blocked, and your small onboard computer has to handle both seeing and steering. The researchers built VIGOR-MPC, which works like a teacher and student: in simulation, a 'teacher' controller that can see everything plans far ahead and drives really well, then a 'student' controller learns to copy that skill using only the messy camera view and a much simpler, faster planner. The student learned to adjust its own driving goals on the fly, and it handled race tracks it had never seen before in both simulation and real hardware. Its lap times came close to the all-knowing teacher while using over 90% less computing power per decision.

Researchers built RTISSLAM, a system that lets a robot map a building and figure out where it is using only sound, like a bat does, with a special sonar sensor that works in the air. Sonar is hard to use indoors because sound bounces off smooth walls like a mirror, which confuses older mapping methods. This system fixes that by recognizing places it has been before from their echo patterns, then correcting its whole map and path when it realizes it has come back to a familiar spot. In computer-simulated offices with smooth, echo-prone walls, it cut the robot's position error from 8.2 meters (using wheel measurements alone) down to 0.31 meters, while a standard laser-style mapping method failed completely on the same sonar data.

The researchers built SEAR, a testing system that lets AI chatbots like GPT-style models teach themselves to control robots by writing code, trying it out, and saving the tricks that work for next time. The big question was whether the AI is truly learning or just getting more tries, so they ran seven top AI models through 330 simulated tasks and five real-robot tasks (over four years of total computer time) with special checks to tell the two apart. They found that harder tasks reward long practice sessions, while on easy tasks just retrying many short attempts works equally well. They also found that reusable code and shared routines carry over to new tasks and new simulators, but one-off task-specific solutions do not, and that on a real robot, skills practiced in AI-designed scenes didn't fully hold up in new scenes designed by humans.

Most robots learn tasks by copying movements, and when they have touch sensors, the touch data is only used as extra information to look at, not as something the robot plans. The researchers built ILA, which teaches the robot to plan a combined 'package' that describes how its movement, the contact it makes, and the force it applies should all change over time, and then turns that package into real motions. Using this approach on three different kinds of robot AI systems, the robots succeeded 21 to 36.5 percentage points more often across four real-world tasks than versions that used touch data in the usual way. The same system can also learn from the robots' own failed attempts by comparing them against examples from expert demonstrations and fixing them.

The researchers built EgoExplorer, a 100-hour collection of recordings that capture how people move their whole bodies, fingers, and sense of touch while doing real jobs like professional tasks, all recorded with a lightweight wearable kit instead of a big lab setup. Each recording lines up first-person video, full-body motion, finger positions, and touch data, along with step-by-step descriptions of what the person is doing. Because a wearable kit only has a few sensors on the body, they invented a three-step method (calibrate, complete, constrain) that first measures each person's body and sensor placement, then fills in the missing joint movements, then checks that the motion matches the sensors and looks physically realistic. Compared to tracker-based reference motion, their method cut body-position errors by 71.9% versus the best competing approach, and it also did better at keeping hands steady and detecting when fingers touch objects.

The researchers took a tiny, cheap distance-sensing chip (the kind found in consumer gadgets) that only captures blurry 54-by-42-pixel pictures of depth and brightness, and taught a small AI model to sharpen them four times over into 216-by-168 images. The twist is that the AI runs directly on a basic, low-cost microcontroller with just 640 KB of memory, which is smaller than a single phone photo, so no powerful computer or cloud connection is needed. They tested several compact AI designs on both simulated and real sensor data, shrank the winning one down to 8-bit numbers to save space, and loaded it onto an STM32 chip alongside custom sensor firmware. It is the first demonstration of this kind of image sharpening running on such a cheap, bare-bones chip with this type of sensor.

Researchers built LIBERO-RIG, a test that checks whether AI robot brains still work when the robot's own body or setup changes, such as a bumped camera, slightly off calibration, a different control speed, or worn-down gripper pads, while the tasks stay exactly the same. They ran nine of the latest vision-language-action models (AI systems that see, read instructions, and control a robot) through 210 conditions, with 500 tries each. Success dropped from 93% on the standard setup to 77% with medium-sized changes and 51% with the biggest ones. Some kinds of changes hurt far more than others, and training the AI on lots of altered camera images did not help when the problem was something the camera could not see, like a hardware fault. Earlier tests mostly changed the scene or the instructions, not the robot itself.

Robots that follow spoken instructions using cameras can get thrown off when an object slips from their grip or something blocks their view. The researchers built ForkCast, an add-on that works like a robot's "what if?" brain: before each move, it imagines three possible futures (keep going as planned, move the camera to get a better look, or redo the arm's path) and picks whichever one it predicts will make the most progress on the task. Unlike older fixes, it doesn't need a separate alarm that detects failures or a hand-written repair script, and it doesn't require retraining the robot's main brain. In simulated tests with blocked views and slipping objects, it more than doubled the success rate of a leading robot policy, from 13.3% to 30.0%, and it also helped on two other robot brains and on a real robot.

Farm machines that pick crops come in many types, and people describe them in so many different ways (by crop, by how they grab the plant, by what sensors they use) that comparing them is a mess. These researchers built a simple sorting system, called a taxonomy, that organizes every harvesting machine along just two lines: how the machine physically touches the plant (cutting, pulling, shaking, brushing, air blasts, and so on) and how much of the job is automated. Their main finding is that making a machine more automated doesn't automatically make it pickier about what it harvests; the real jump happens only when the machine's 'eyes and brain' directly control the part that touches each individual fruit or plant. This is a conceptual framework rather than an experiment, so there are no test numbers, but it gives engineers one shared map instead of a pile of mismatched labels.

Event cameras are special sensors that don't record regular video frames; instead they only report which pixels got brighter or darker, which makes them great at catching fast motion and keeps people's faces and details less exposed than normal cameras. The problem is that turning this stream of changes into a single image (the usual trick) works fine for short clips but falls apart when the action is long or complicated. The researchers fixed this by chopping each recording into several time slices (a 'multi-frame' representation) and teaching an AI model to fill in missing pieces of these slices, like solving a jigsaw puzzle, before training it to recognize actions. They also added a smart way of skipping the empty, boring parts of the data, and their system now beats all previous methods on two hard benchmarks for long, complex actions, THU-EACT-50 CHL and DailyDVS-200. The abstract doesn't give exact accuracy numbers, but it reports a big jump over the single-image approach.

Tracked robots like the ones used in search and rescue have little arms called flippers that help them climb over rubble and obstacles, but nearly every system that controls them relies on a 3D map of the ground, and that map goes bad as the robot's own position estimate slowly drifts off. The researchers built a controller called SAS (Stabilizing Anti-Stuck) that skips the map entirely and just uses the robot's tilt sensor, the angles of its four flippers, and a simple yes-or-no signal for whether the robot is actually moving. One part keeps the robot from tipping side to side or front to back, while another part wiggles the flippers to free the robot when it gets stuck. In simulation and on a real robot it climbed obstacles about as well as the best map-based controllers, and when a log was hidden in tall grass where the laser scanner couldn't see it, the best map-based controller got stuck while SAS drove right over it.

During surgery, doctors need to know exactly where their tools are inside the body, and the systems that do this today use expensive infrared cameras that stop working if someone's hand or arm blocks the view. The researchers built LARK, a tracking system that uses five ordinary color cameras (costing under $1,000 total) and combines what they all see, using a math tool called a Kalman filter to smooth out mistakes. In tests on a precision-machined grid, LARK located points to within about 0.64 millimeters and tracked tool paths to within about 0.73 millimeters, close to the accuracy of the expensive gold-standard system, and its accuracy faded gently rather than failing outright when some cameras were blocked. The key difference from earlier systems is that having extra cheap cameras provides backup views, so the system keeps working even when parts of the scene are hidden.

Power grids use thousands of sensors to report what's happening on the wires, and hackers can send fake sensor data that looks so normal the grid's safety checks don't notice it. The researchers built ROAM, an AI system that constantly reshuffles which ID belongs to which sensor, like a shell game that keeps changing, and it learns by trial and error how much to shuffle and which method to use depending on how threatened the grid seems. Older shuffling methods were either fast but easy to break if a secret key leaked, or hard to break but too slow; ROAM mixes both and adapts on the fly. In tests on simulated 14-, 57-, and 118-bus power grids, fewer than 3% of sneaky attacks got through while over 93% were caught, and it held up (under 2.6% stealthy attacks) even against a smart AI attacker that could see its setup.

The researchers took a tiny, cheap distance-sensing chip (the kind found in phones and small gadgets) that only produces a blocky 54×42 pixel picture of how far away things are, and taught an AI to sharpen it into a much clearer 216×168 picture, four times more detail in each direction. The remarkable part is where it runs: not on a powerful computer or graphics card, but on a small microcontroller (an STM32H563ZI, similar to the brain of a basic appliance) with just 640 KB of memory, less than a single smartphone photo takes up. To make it fit, they compared several compact AI designs, shrank the winning one down to simple 8-bit numbers, and wrote custom code so the chip could sharpen both the distance image and a regular brightness image on its own. This is the first time anyone has shown this kind of AI image sharpening working directly on such a low-cost chip paired with a consumer-grade distance sensor.

Researchers built PalmSpace, a wristband with infrared sensors that turns your bare palm into a touchpad for smart glasses and mixed reality headsets, with no special sticker or glove needed. The wristband can tell whether a finger is touching your palm, what kind of touch it is (like a tap or a drag), and exactly where on the palm it landed. In tests with 17 people, it found the touch location to within about 6.7 millimeters (roughly the width of a pencil eraser), spotted touches 98.9% of the time, and correctly identified the type of touch about 97% of the time, even for people it had never seen before. Earlier palm systems could usually only do one narrow job, like detecting a tap or recognizing a single gesture, but PalmSpace handles precise pointing, dragging, typing digits without looking, and multi-finger moves like scrolling and pinch-zooming on a map, all in one system.

The researchers built a new way to sort and compare all the different machines that pick crops, from old-fashioned shaking and cutting equipment to modern picking robots with cameras and AI. Until now, these machines were described in lots of different ways (by crop, by how they grab the plant, by what sensors they use), which made them hard to compare. Their system uses two simple questions: how does the machine physically touch the plant, and how much of the picking is automated? They found that adding more automation doesn't automatically make a machine pick more carefully. The real jump happens only when the machine's 'eyes and brain' directly control the part that touches each individual fruit or vegetable. This is a conceptual framework based on qualitative analysis, so the paper does not report experimental numbers.

Event cameras are special sensors that, instead of snapping full pictures, only record tiny changes in brightness, which makes them great at catching fast motion and keeps people's faces and identities less exposed. The problem is that the usual way of turning this data into a single image-like snapshot works fine for short clips but falls apart when someone does a long or complicated action. The researchers fixed this by turning each recording into several snapshots over time (a 'multi-frame' representation) and then pre-training an AI model on unlabeled data by hiding parts of the snapshots and making it fill in the blanks, with a smart trick to skip the empty, uninformative regions to save computing power. Their approach set new top scores on two hard benchmarks for recognizing long, complex actions, THU-EACT-50 CHL and DailyDVS-200. The abstract doesn't give the exact accuracy numbers, but it says the multi-frame approach greatly beat the single-snapshot version.

Tracked robots like the ones used in search-and-rescue have little movable arms called flippers that help them climb over rubble, but nearly every existing controller depends on a 3D map of the ground, and that map goes bad over time because the robot's own position tracking slowly drifts and the ground under the robot can't be seen. The researchers built a controller called SAS (Stabilizing Anti-Stuck) that skips the map entirely: it only uses the robot's tilt sensor, the angles of its flippers, and a simple signal that says whether the robot is actually moving. One part of SAS keeps the robot body level, and another part wiggles the flippers to free it when it gets stuck. In simulation and on a real four-flipper robot, SAS climbed obstacles about as well as the best map-based controllers, and it even crossed a log hidden in tall grass that the laser scanner couldn't see, which made the best map-based controller get stuck.

Surgeons who use computer-guided navigation need to know exactly where their tools are inside the operating room, but the standard infrared tracking systems are very expensive and stop working when someone's hand or equipment blocks the view. The researchers built LARK, a tracking system that uses five ordinary color cameras (under $1,000 in total) instead of pricey specialty gear, and combines what all the cameras see so the system keeps working even when some views are blocked. A smoothing algorithm called a Kalman filter cleans up the noisy measurements, and in tests on a precisely machined grid, LARK located points to within about 0.64 millimeters and tracked tool paths to within about 0.73 millimeters, roughly the width of a pencil lead. Its accuracy also dropped off gradually, not suddenly, as cameras were blocked or removed, and the designs and software are free for anyone to use.

Power grids use thousands of sensors to track electricity flow, and hackers can sneak in fake readings that fool the grid's normal safety checks. A common defense is to keep shuffling the sensors' ID labels so attackers can't keep up, but older versions either shuffle on a fixed schedule or force a trade-off between fast-but-easy-to-crack and secure-but-slow methods. The researchers built ROAM, an AI agent that learns by trial and error how much to shuffle, which sensors to relabel, and which of the two methods to use, based on what attacks it sees in real time. In tests on three simulated grids of 14, 57, and 118 buses, ROAM let fewer than 3% of stealthy attacks through while catching over 93%, and it held up (under 2.6% stealthy, over 92% detected) even against a smart AI attacker that could see its settings.

The researchers took a cheap, tiny 3D-sensing chip (the VL53L9CX, which measures distance using flashes of light) that only produces a blurry 54-by-42-pixel picture, and taught a small AI model to sharpen it into a much clearer 216-by-168 picture, four times more detail in each direction. The AI sharpens the depth picture and the brightness picture at the same time, and it's small enough to run directly on a basic microcontroller (an STM32 chip with just 640 KB of memory, less than a single photo on your phone) with no cloud or powerful computer needed. They tested several compact AI designs on both computer-made and real sensor data, shrank the winner to 8-bit numbers to fit, and wrote custom firmware to run it on the actual chip. It's the first time anyone has shown this kind of image sharpening working on such a low-cost chip with a consumer-grade sensor.

Researchers built PalmSpace, a wrist-worn device that turns your bare palm into a touchpad for smart glasses and mixed-reality headsets. It uses infrared light, and an AI model figures out whether your finger is touching your palm, what kind of touch it is (like a tap, drag, or pinch), and exactly where on your palm it landed. Earlier palm systems could only spot a few preset gestures or zones, and they needed tuning for each person, but PalmSpace works on new users without any setup. In tests with 17 people, it pinpointed touches to within about 6.7 millimeters (less than a pencil's width), detected contact 98.9% of the time, and identified the type of touch with 96.7% accuracy.

Researchers built LARK, a system that tracks surgical tools using five ordinary color cameras costing under $1,000 total, instead of the expensive infrared tracking systems used in hospitals today. Surgeons rely on this kind of tracking to see exactly where their instruments are inside a patient, but the standard systems cost a lot and fail whenever someone's hand or arm blocks the view. By having several cameras watch at once and blending their views with a smart error-smoothing method called a Kalman filter, LARK could locate points to within about 0.64 millimeters (less than the thickness of a pencil lead) and follow tool paths to within 0.73 millimeters. When cameras were blocked or removed, its accuracy dropped gradually instead of failing suddenly, and the team compared it against a gold-standard commercial system to check the results.

The researchers built a complete system that turns a hiker's phone into a trigger for a rescue drone. A phone app constantly saves where the hiker has been and any calls for help, and sends that data to an online database. A rescue operator checks the data on a control screen, approves a mission, and a drone then flies a path at 80 meters above the ground, follows the terrain, and returns to its launch site. In tests, the drone-to-ground-station communication caught lost connections within 1 second, phone data passed from the app through the drone to the ground station, and in outdoor flights the drone's downward camera clearly showed a person, a footpath, and plants. What's new is that earlier work treated phone location data and drone searching as separate things, while this links them in one step-by-step workflow.

Robots driven by AI models usually plan a whole batch of moves at once and then carry them out, which makes motion smooth but slow to react when something changes. If the robot re-plans every moment instead, it reacts quickly but moves jerkily. The researchers built REACT, a system that keeps a running queue of planned moves and keeps polishing all of them using the newest camera view, so the next move the robot makes has already been refined several times against recent observations. They also split the robot's 'eyes,' 'brain,' and 'muscles' into separate parts that run at the same time, and on the RoboTwin 2.0 simulation benchmark and real robots doing two-armed and fast-moving tasks, it succeeded more often, reacted faster, and moved more smoothly than the older approaches. The abstract does not give exact numbers, so the size of the improvement is not stated here.

Researchers took a simulated touch sensor (a soft gel pad with a camera behind it, like a robot fingertip) and boiled down its video of how the surface stretches and shifts into just 126 numbers, then used those numbers to tell which way a held object was starting to twist. They tested this under Earth, Mars, Moon, and orbital gravity and found that gravity changes the touch data only slightly (about 1.6%), but that's enough to cause trouble: a model trained only on Earth data dropped from 94.4% accuracy to 75.9% in orbit. When they trained one model on all four gravity settings together, it hit 96.3% accuracy everywhere, without ever being told which gravity it was in. Even better, they cut the data down to 40 numbers while keeping 95.7% accuracy, and the model makes a decision in just 0.14 milliseconds.

The researchers took a cheap, tiny distance-sensing chip (the kind that measures how far away things are using flashes of light) that only produces blurry 54×42 pixel pictures, and built an AI program that sharpens them to 216×168 pixels, four times sharper in each direction. The AI makes a sharper picture of distance and a sharper picture of brightness at the same time. What makes this special is that the AI runs on a very small, inexpensive computer chip with only 640 KB of memory (far less than a basic photo on your phone), instead of needing a powerful computer or cloud connection. They tested several compact AI designs on both simulated and real sensor data, shrank the winner down to run efficiently, and got it working on the actual chip, which they say is the first time this has been done for this kind of sensor.

Robots often learn by watching human demonstrations, and the fanciest way to do this (diffusion or flow matching, which generates actions step by step) has beaten the simpler method of just guessing the action and averaging out mistakes (MSE regression). Most people assumed the fancy method wins because humans can do the same task in several different ways. This team found a different reason: in real robot data, prediction errors are wildly uneven (some situations are much noisier than others) and have extreme outliers, and the simple method lets those outliers dominate training and throw it off. They built HT-Policies, which learns how uncertain each situation is and downplays the outliers (using a Student-t statistical model), so it produces a whole sequence of actions in one quick pass. Across four simulation benchmarks and real-robot tests, it matched the success rates of the fancier generative policies while training and running faster, including when built on top of pretrained vision-language-action models. The paper does not report a single headline number in its abstract, so the key result is 'competitive success rates at lower compute cost.'

Most modern robots rely on a big AI model that looks at camera images and decides what to do, even while the robot is running. These researchers built something different called Code-Only-as-Policy (COAP): ordinary computer code that reads the camera and sensor data, keeps track of where everything is, and makes every decision itself, with no AI model running during the task. AI coding assistants wrote and improved this code over many rounds, building one shared library of skills that works across many tasks. On 42 two-armed robot tasks in a test called RoboDojo, the finished code succeeded 70.24% of the time without any AI model running at test time.

Researchers built GLIO2, a software system that helps self-driving cars and drones figure out exactly where they are by blending three sensors: a laser scanner that maps surroundings, a motion sensor that tracks turns and bumps, and GPS. Older systems lock in each laser reading early and then trust it too much, so one bad reading, like a laser seeing a long featureless bridge, can send them permanently off course. GLIO2 keeps all the raw data in play at once and re-checks it against GPS, and it runs on a small, cheap computer chip. On a 5.66-km bridge driven at up to 96 km/h, every competing system got lost while GLIO2 stayed within about 1.6 meters, and it processes about 25 location updates per second on a small onboard chip (a Jetson Orin NX).

Satellites beam 5G signals down to Earth, and those signals bounce off nearby objects, so a quiet listening device can 'see' things like moving drones just by catching the echoes. The hard part is that the satellite's own signal is millions of times stronger than the echoes and is shifting in pitch and timing as the satellite races overhead, so it drowns out the faint reflections. The researcher built gr-ntnisac, a free, open-source testbed that fakes a speeding satellite's signal and sends it through real radios connected by cable, so the answer is known and the receiver can be graded before a real satellite launch is ever needed. Using it, he showed the receiver could erase the satellite's strong direct signal by 34.8 dB on real hardware (37.6 dB in simulation), found that two specific quirks in the fake-satellite setup each cap the erasing at around 40 dB (versus 71 dB without them), and detected a very faint moving object in 76.9 percent of test windows.

Robots that learn tasks by looking through cameras usually get confused if you add, remove, or move a camera after training, because they only learned from one fixed camera setup. The researchers built VersaCamVLA, a system that squeezes any number of camera views, from any positions, into one small, fixed-size summary of the scene, which is then handed to an existing pretrained robot-brain model as extra visual information. To teach it about different viewpoints cheaply, they used a trick called Wrist-Augmented Pose Sampling: as the robot's wrist camera naturally moves around during a task, it provides lots of different viewing angles for free. In tests on the RoboTwin and LIBERO simulation benchmarks and on a real robot, it beat earlier methods and simpler approaches that just feed in multiple camera views, and it kept working when the number of cameras changed or cameras were placed in positions it had never seen. The abstract does not give specific numbers, so the exact size of the improvement is not stated here.

People using AI to write business strategy documents often just accept whatever the AI gives them without thinking hard about it. Researchers built a prototype called Cognistance that makes users answer a few questions first (what's the situation, which direction do you want to take, and why) before the AI writes anything. In a randomised online experiment, documents written with this step scored 32% higher on average, and the number of off-topic, useless documents dropped from 34% to 5%, mostly because it rescued people who had written weak instructions. It cost only about 2.4 extra minutes (roughly 10.5 minutes total), but it didn't improve technical detail, and people still couldn't judge how good their own documents were.

Researchers built PalmSpace, a wristband with infrared sensors that turns your bare palm into a touchpad, so you can control smart glasses without needing a screen or any special gear on your hand. Unlike earlier systems that could only spot simple taps, fixed zones, or a few preset gestures, this one figures out three things at once: whether you're touching your palm, what kind of touch it is (for example one finger versus a pinch), and exactly where on your palm you touched. In tests with 17 people, it pinpointed touches to within about 6.7 millimeters (roughly the width of a pencil eraser), detected touches correctly 98.9% of the time, and identified the type of touch with a 96.7% score, all without having to be re-tuned for each person's hand. People used it to point and drag, type digits without looking, scroll, and zoom a map with a pinch.

Researchers built SpatialHarness, a system that helps a robot controlled by an AI model (GPT-6 Astra) see what it's doing more clearly. Instead of retraining the AI or adding new cameras, they keep a live virtual copy of the robot's workspace that matches what's happening in the real world, then generate extra camera angles from that copy to show the AI the tricky spots, like how close a plug is to its socket. With the exact same AI and no retraining, success on plug insertion jumped from 26.7% to 66.7%, and on the Tower of Hanoi puzzle it went from 0% to 100%. The big idea is that the AI wasn't necessarily bad at the task; it just couldn't see the important details from the cameras it had.

Researchers built LARK, a system that tracks surgical tools using five ordinary color cameras (the kind you'd find in a webcam) instead of the expensive infrared cameras hospitals normally use. Because several cameras watch the same tool from different angles, the system keeps working even when a surgeon's hand or another object blocks the view of some cameras, and a math technique called a Kalman filter smooths out the guesses. On a precision-machined test grid, it located points to within 0.64 mm and followed tool paths to within 0.73 mm, and its accuracy dropped only gradually as cameras were covered up. The whole tracking hardware costs under $1,000, and the team released the designs, software, and data for free.

Robots often need to figure out which part of an object does a job, like which end of a knife you grab or which part of a mug you hold. Most current systems do this by having an AI "think out loud" in words, which is slow and hard to fix when it gets things wrong. The researchers built AffordJEV, which skips the talking: other tools first suggest possible regions, and a fast AI model simply says yes or no to each one in a single quick step, checking from whole object down to part down to tiny sub-part. Trained only on one dataset (InstructPart), it beat the think-out-loud methods on that dataset and on two new ones it had never seen (UMD and IIT-AFF), and it needed fewer checks than other quick-decision models, though the abstract doesn't give exact scores.

Robots powered by vision-language-action (VLA) AI models often mess up when they leave the lab, and teaching them to recover usually means showing them the fix dozens or hundreds of times, with the lessons rarely carrying over to new situations. The researchers built OopsieRecover, a system that watches just a handful of human corrections and figures out the reason behind each one (for example, 'the gripper missed because it grabbed the wrong part of the object') instead of simply memorizing the exact motions. It turns that reasoning into a map of the scene that marks which behaviors are bad and nudges the robot toward better ones. Tested on 6 tasks, a few corrective demonstrations were enough for the robot to recover from failures with new objects, different object positions, and changed scenes, without collecting fresh correction data for each variation. The abstract does not report specific success-rate numbers, so the size of the improvement over older methods is not stated here.

The researcher built VREgo, a system that lets someone teach a robot to do tabletop jobs by wearing a regular consumer VR headset (a PICO 4 Ultra) and simply doing the task with their own hands, instead of using expensive research gear. For putting a cube on a tray, robots trained on just 40 headset demonstrations succeeded in 60 to 74 out of 100 test layouts, roughly in the same range as a pricier research headset (Project Aria), which scored 73 and 78 on two training runs but a total failure (0) on the third. A harder two-step stacking task initially worked only 2 times out of 100 because of problems like the robot's open gripper bumping the cube before grabbing it, but after fixing the training data and adding some hand-written rules, it succeeded 93.8% of the time. One caveat: the same 100 test layouts were used to develop those fixes and to evaluate them, and everything was tested in simulation with one person recording the demonstrations.

When a robot tries to grab something that's moving, like a sliding puck, there's always a delay between when it sees the object and when its hand actually starts moving, and in that gap the best move can change. The researchers built a 'time-indexed' success predictor that, instead of asking 'will this skill work if I start right now?', asks 'will it work if I start after a specific delay?', which lets the robot pick both the right skill and the right moment to launch it. In simulation with a UR5e robot arm catching a puck, this beat the standard approach by 2.8 to 6.2 percentage points at 100 to 300 milliseconds of delay, and its predictions were far more honest (calibration error of 0.009 versus 0.239). On a real robot catching a rolling ball with 0.2 seconds of added delay, the old method predicted 99% success but only 63% of attempts worked, while the new model predicted 56%, much closer to the truth.