ProD Teaches Small AI Agents Not to Loop: Tested on 8 Models from 0.6B to 8B

Eight small language models, from 0.6B to 8B parameters, served as the testing ground for a new agent distillation method. It is called Progress-Aware Distillation, or ProD. The authors, whose paper appeared in Hugging Face Daily Papers, target a specific failure: on long tasks, distilled student agents get stuck in loops and repeat strategies that have already failed.

Why small agents loop

Agentic systems built on large LLMs solve complex tasks, but they pay for it in tokens and latency. Every reasoning step, every tool call, and every environment response makes the context longer and the bill larger. That is a serious constraint for production, so the industry is moving agentic skills into small models. The standard route is distillation through supervised fine-tuning: a teacher solves tasks, and a student trains on its trajectories.

The problem is that the longer the trajectory, the worse the student holds its course. Reasoning-action chains stretch out, feedback from the environment piles up, and the model starts going in circles. The authors call this progress stagnation: the agent applies the same non-working approaches again and again and makes no headway toward the goal. According to their systematic analysis, the effect reproduces across different small models and different task types. In other words, it is not the flaw of a single unlucky architecture.

How ProD works

The idea is to make stagnation measurable and punishable directly during training. ProD explicitly detects stagnation in trajectories generated by the student itself and penalizes it. The gap between student and teacher on this measure is encoded into an adaptive margin. The further the student lags behind the teacher in progress, the harsher the penalty. As the gap narrows, the pressure eases.

The procedure is applied iteratively, and the student moves step by step closer to the teacher's behavior. The abstract gives no implementation details, but a structure built on a margin and the student's own trajectories resembles preference-learning methods. That is my guess based on the abstract, not a claim by the authors. What matters more is that training does not rely only on the teacher's "ideal" demonstrations. The student also sees its own failed paths, and the method tells it what exactly went wrong in them.

What the experiments showed

According to the abstract, the testing was broad:

• 8 small language models;
• model sizes from 0.6B to 8B parameters;
• benchmarks inside the training domain (in-domain) and outside it (out-of-domain);
• metrics: task success rate and task execution efficiency.

The authors claim that ProD substantially reduces stagnation while improving both success rate and task execution efficiency. The abstract gives no specific percentages, so it is too early to judge the size of the gain. The full text needs to be checked for benchmark names, baseline methods used for comparison, and the spread of results across models. Another open question is how much the iterative loop costs, with the student generating trajectories and stagnation being labeled.

What teams building agents should do

Engineers building cheap agents on 1–8B-class models should check exactly where quality drops. If success falls as episode length grows, and the logs show repeated actions, that is the stagnation in question. A simple diagnostic step is to count the share of trajectories that repeat the same action or show no progress within N steps. That metric is useful whether or not ProD turns out to suit you.

If you distill agents yourself, it makes sense to include the student's trajectories in the training loop, not just the teacher's. That means paying for extra runs and for progress labeling. In return, you get a chance to cut the number of tokens per task without losing reliability. For now, this is the result of a single paper with no independent verification. But it points to a real bottleneck: a cheap agent breaks not on the first step, but on the twentieth.