Why does showing an AI one example that worked and one that failed teach it better than just saying 'do better'?
How does contrastive feedback improve compression guideline quality versus weaker optimization?
This explores why ACON-style compression guidelines get better when the optimizer can compare a run that worked with one that failed, rather than just getting a vague signal to improve, and what the wider corpus says about why comparison makes such a strong teaching signal.
This explores why compression guidelines improve more when the optimizer can compare a success with a failure than when it only gets a vague signal to do better. The clearest case in the collection is Microsoft's ACON. It doesn't retrain the agent. Instead it rewrites a plain-language instruction that tells the model what to keep and what to drop when it shrinks its own history. It refines that instruction by studying failures: it finds cases where the agent succeeded with full context but failed once the context was compressed, then asks what the compression threw away that mattered. That loop cut peak token usage by 26–54% and improved task success, for under $2 per benchmark Can prompt optimization cut agent token usage without retraining?. One caveat: the notes here describe the failure-analysis loop but not a side-by-side ablation against weaker optimizers. The case for contrast comes partly from ACON and partly from patterns elsewhere in the corpus.
Why does a paired comparison help so much? A separate line of work on reinforcement learning gives a useful parallel. When every attempt at a prompt gets roughly the same reward, the learning signal fades and the model drifts toward generic, one-size-fits-all templates. The fix is to train on prompts where outcomes differ sharply Why do language models collapse into generic templates?. A success/failure pair is the same idea in plain language. It turns 'this compression is bad somehow' into 'this specific fact was dropped, and that's why the task failed.' A guideline can only learn from differences it can actually see.
The corpus also suggests why this refinement has to happen in an explicit outer loop and not inside the model's head. LLMs can't reliably carry out step-by-step optimization internally. They tend to recognize a familiar problem shape and produce a plausible-looking answer Do large language models actually perform iterative optimization?. On real constrained optimization tasks they plateau around 55–60% regardless of scale Do larger language models solve constrained optimization better?. Search methods that make the comparison explicit work much better. Mind Evolution keeps a population of candidate solutions and recombines the strongest ones, and it beats both best-of-N sampling and simple repeated revision Can evolutionary search beat sampling and revision at inference time?. In both cases, structured comparison does the work that the model's own judgment can't.
There's also a reason grounded in what compression destroys. LLMs tend to compress aggressively, keeping broad categories while losing the fine distinctions humans hold onto Do LLMs compress concepts more aggressively than humans do?. A compression guideline tuned without feedback will lean the same way. A contrastive failure exposes exactly the small detail that turned out to matter. ACON's own results show that the right level of aggressiveness depends on the environment, not on how strong the model is. Noisy, verbose settings like AppWorld reward heavy pruning, while settings like OfficeBench, where a single subtle fact drives the decision, punish it Should compression be aggressive or conservative in different environments?. LLMLingua reached a similar conclusion for prompts: compress the examples hard, but protect the instructions and the question Can prompts be compressed without losing model performance?.
The takeaway you may not have expected: what makes a good compression guideline isn't really a compression problem. It's a credit-assignment problem, meaning the hard part is finding which dropped piece of information caused the failure. Comparing paired outcomes is the cheapest way to solve that, and because ACON's 'weights' are just a paragraph of English, the whole optimization stays readable. You can open the guideline and see what the agent learned to keep.
Sources 8 notes
Microsoft's ACON method reduces agent token consumption and improves task success by iteratively refining compression guidelines through failure analysis, not weight updates. This approach works across proprietary LLM agents and costs under $2 per benchmark.
When within-prompt reward variance is low, task gradients weaken and regularization dominates, pushing policies toward generic outputs. SNR-Aware Filtering—selecting high-variance prompts before updates—recovers performance across tasks and scales.
Research shows LLMs cannot perform iterative procedures in latent space. They recognize optimization problems as template-similar and emit plausible-looking but incorrect values, a failure mode that persists across model scale and training approaches.
Across constrained-optimization tasks, LLMs converge to ~55–60% constraint satisfaction independent of architecture, parameter count, or training regime. Reasoning models do not systematically outperform standard models, suggesting a fundamental ceiling rather than a scaling gap.
Mind Evolution, an evolutionary search strategy using LLM-generated crossover and mutation with island model diversity, solves 98%+ of planning tasks and significantly outperforms best-of-N and sequential revision strategies while working directly in natural language without task formalization.
Show all 8 sources
Using Rate-Distortion Theory on cognitive datasets, LLMs capture broad category structure but lose fine-grained distinctions humans preserve. LLMs maximize compression efficiency; humans trade compression for contextual meaning that enables situated action.
ACON's guideline optimization shows that aggressive pruning works best in noisy, verbose environments like AppWorld, while conservative retention matters more in high-fidelity tasks like OfficeBench where subtle facts drive decisions. The choice depends on the task's information structure, not the model's capability.
LLMLingua achieves up to 20x prompt compression with only 1.5-point performance drops by allocating less compression to instructions and questions, more to demonstrations, then pruning tokens using a small model's perplexity scoring aligned to the target LLM.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- ACON: Optimizing Context Compression for Long-horizon LLM Agents
- LLMLingua: Compressing Prompts for Accelerated Inference of Large Language Models
- Can Large Language Models Reason and Optimize Under Constraints?
- Branch-Solve-Merge Improves Large Language Model Evaluation and Generation
- A Survey on Test-Time Scaling in Large Language Models: What, How, Where, and How Well?
- Beyond Accuracy: Evaluating the Reasoning Behavior of Large Language Models -- A Survey
- Chain of Thoughtlessness? An Analysis of CoT in Planning
- Thinking as Compression: Your Reasoning Model is Secretly a Context Compressor