Pack Light, CarryOn: Building Object-Oriented Context for Long-Horizon Agents
Yuchen Lu, Julian McAuley, Lei Zhang
University of California San Diego
Published October 13, 2026 · on the feed October 19, 2026 · ▲ 119 · arXiv 2610.18784
The abstract
Long-horizon agents accumulate progress in persistent task state, yet repeatedly process interaction histories describing how that progress was achieved. This raises a natural question: can long-horizon context instead be organized around reusable progress rather than the history that produced it? In this paper, we introduce CarryOn, an object-oriented context runtime that organizes continuation around reusable task objects. Rather than treating compressed histories or reconstructed accounts of progress as the primary basis for continuation, CarryOn builds a context view from continuation carriers, complementary execution context, and a live tail of recent interactions. A core challenge is keeping this reusable basis valid after its surrounding history is retired: how can CarryOn update the basis without reconstructing the full representation at every fold? CarryOn maintains carrier records across folds, revising affected records against bound evidence and applicable environment checks while carrying forward unaffected records and jointly updating execution context. Experiments on OSWorld 2.0 and BrowseComp-Plus show improved gains of 5.8% and 7.0% while reducing total token usage by 51.9% and 22.9%, respectively. Project page: https://ethannju.github.io/carryon
The Brief
2:15A short podcast summary of the paper. Written and voiced by AI.
Transcript
Pack Light, CarryOn. Building Object-Oriented Context for Long-Horizon Agents. By Yuchen Lu and two others, from the University of California San Diego. Published on the thirteenth of October. Its code repository is a placeholder: a readme, and nothing to run yet.
Long-horizon agents store their progress in persistent task state. Even so, they keep re-reading interaction histories that describe how that progress came about. The progress is already there, yet the agent pays again and again for the story of how it got there, and the story only grows as the task goes on. That raises a natural question: could long-horizon context be organised around reusable progress, rather than around the history that produced it?
CarryOn is an object-oriented context runtime built on that premise. It organises continuation around reusable task objects. Compressed histories, or reconstructed accounts of progress, are no longer the primary basis for carrying on. What the agent continues from is the progress itself, held as objects, rather than a retelling of the steps behind it.
Concretely, CarryOn assembles a context view from three sources: continuation carriers, complementary execution context, and a live tail of recent interactions. That design creates its own difficulty. The reusable basis has to stay valid once the history around it has been retired. How can it be updated without rebuilding the whole representation at every fold?
CarryOn answers by maintaining carrier records across folds. Records that are affected get revised against bound evidence and against applicable environment checks. Unaffected records are simply carried forward as they are, and the execution context is updated jointly with them. Work is spent only where something has actually changed.
Experiments use OSWorld 2.0 and BrowseComp-Plus. On the first, CarryOn reports improved gains of five point eight percent while reducing total token usage by fifty-one point nine percent. On the second, the gain is seven point zero percent, with token usage down by twenty-two point nine percent. Better results and less context arrive together, in both settings.
Pack light, as the title puts it. Carry the progress, not the diary of how it was made, and revise only the pieces that the latest evidence touches. On both benchmarks that trade bought better scores and a smaller bill at once.
Paper Quest · 7 chapters · about 39 min
Play this paper
Learn it by doing: make the calls the authors made, guess the result before you see it, and defend it in a viva graded on your own words. Chapter 1 is right here.
Chapter 1 🧩 · The problem
Long tasks drown agents in their own history. Here is where the trouble starts.
You are running an agent on a long desktop task: editing a presentation, filling in a report. The finished slides and tables already sit in files the agent can open.
The road ahead
- 1 · The problem ~6 min A long-running agent keeps re-reading the growing history of how it made its progress, even though that progress already sits in files it can open.
- 2 · What came before ~3 min
- 3 · The key idea ~8 min CarryOn lets the agent continue from its reusable progress, held as task objects, instead of from the history that produced it.
- 4 · Choose your own research ~3 min
- 5 · Build the method ~8 min Each fold tracks reusable progress, binds it to evidence, revises only affected records, then assembles the new context view.
- 6 · The experiment ~6 min You’ll guess: On OSWorld 2.0, by how much did CarryOn reduce total token usage?
- 7 · The viva ~5 min Three questions from the examiners, answered in your own words. Win it for the paper’s trophy.
Free, with Google or an email address. Your stars and progress are kept.