One-sentence Summary

Researchers at the University of California San Diego introduce CarryOn, an object-oriented context runtime that organizes long-horizon agent continuation around reusable task objects, maintains carrier records via bound evidence and environment checks without full reconstruction, and improves gains by $5.8\%$5.8% on OSWorld2.0 and $7.0\%$7.0% on BrowseComp-Plus while reducing total token usage by $51.9\%$51.9% and $22.9\%$22.9%, respectively.

Key Contributions

• CarryOn is an object-oriented context runtime that organizes long-horizon agent continuation around reusable task objects rather than raw or compressed interaction history. It combines continuation carriers, execution context for goals, constraints, and unresolved issues, and a live tail of recent interactions.
• CarryOn maintains carrier records across folds, revising only affected records against bound evidence and applicable environment checks, carrying forward unaffected records, and jointly updating execution context without reconstructing the full representation at every fold.
• Evaluation on OSWorld 2.0 and BrowseComp-Plus shows that CarryOn lifts Claude Opus 4.7 from 43.9% to 49.7% and from 49% to 56%, respectively, while reducing total token usage by 51.9% and 22.9% and total cost by 35.9% and 7.1%.

Introduction

Long-horizon agents often accumulate redundant context because interaction history repeats information already present in persistent task state, raising token cost and making continuation depend on selective reconstructions that can drift from the actual state. Prior methods address this through compression, summarization, retrieval, pruning, or externalized state, but they may still organize continuation around compressed history rather than reusable results. The authors introduce CarryOn, an object-oriented context runtime that combines continuation carriers for reusable task objects and explicit conditions of use, execution context for active goals and unresolved issues, and a live tail of recent interactions. A fold operation progressively replaces covered history with an updated object-oriented context view, preserving what the agent still needs to continue.

Method

The authors propose CarryOn, a framework designed to organize long-horizon agent continuation around reusable task objects rather than the raw interactions that produced them. This approach allows established progress to be carried forward for subsequent inspection and use, while explicit context retains complementary continuation information.

The framework structures the agent's active context into three complementary components, forming the Context View. Continuation Carriers expose reusable progress to subsequent execution. These carriers maintain a stable identity and record reusable content or its location, along with conditions for reuse. CarryOn supports three forms of carriers: External Objects, which are work products existing independently in the environment such as code files; Information Products, which capture reusable findings obtained through interaction; and Situated State, which captures progress available only within a particular application or session. Execution Context complements these carriers by retaining information needed for execution but not encoded in reusable task objects, such as current focus, unresolved constraints, and pending work. Finally, the Live Tail contains the original agent-environment interactions accumulated since the most recent fold.

At interaction step $t$t, let $k$k denote the most recent fold and $b_k$bk​ the last interaction step covered by that fold. The fold establishes a maintained set of continuation carrier records $A_k$Ak​ and execution context $E_k$Ek​, while interactions occurring afterward remain in the live tail $L_t = (h_{b_k + 1}, \ldots, h_t)$Lt​=(hbk​+1​,…,ht​). The context view is therefore defined as:

$$V_t = (A_k, E_k, L_t).$$Vt​=(Ak​,Ek​,Lt​).

To maintain this context view during execution, CarryOn periodically folds accumulated interactions in the live tail into the maintained representation. This update process proceeds in four distinct stages: tracking candidates, preparing evidence, joint compilation, and validation and commitment.

First, in the Tracking Candidates stage, a Tracker identifies progress that may become reusable in subsequent execution. It maintains candidates representing potential new carriers or updates to existing ones. Once a candidate reaches a state that can support continuation, the Tracker requests its compilation, specifying what should be compiled and the evidence needed to support it.

Next, during Preparing Evidence, the system gathers the evidence authorized for each selected candidate. For information products, it checks that the selected material is consistent with recorded sources. For external objects and situated state, it binds the request to the corresponding environment object, and a Grounder performs read-only checks of relevant conditions. The resulting input package $U_t$Ut​ contains the selected candidates, applicable carrier records, authorized source material, object references, and available check results.

In the Joint Compilation stage, a Compiler jointly updates continuation carriers and execution context to preserve the information needed for subsequent execution. The Compiler receives the prepared input package $U_t$Ut​, the current execution context $E_k$Ek​, and a chronological text projection $\Pi(L_t)$Π(Lt​) of the live tail. It proposes carrier edits $\Delta A_t$ΔAt​ and a revised execution context $\widehat{E}_{k+1}$Ek+1​:

$$(\Delta A_t, \widehat{E}_{k+1}) = \mathrm{Compile}(U_t, E_k, \Pi(L_t)).$$(ΔAt​,Ek+1​)=Compile(Ut​,Ek​,Π(Lt​)).

The Compiler proposes edits only for the selected candidates, grounding each edit in its authorized evidence, while revising the execution context against the entire live tail to preserve continuation-relevant information.

Finally, in the Validation and Commitment stage, CarryOn checks that the proposed carrier edits still refer to the current candidate and carrier versions and are consistent with the authorized evidence. It also verifies required identity, reference, and output constraints. If these checks pass, CarryOn atomically applies the carrier edits and commits the revised execution context, advancing the fold through the covered interactions. The resulting carrier set and execution context define the folded portion of the next context view, while subsequent interactions begin a new live tail. If the checks fail, the existing context view and live tail remain unchanged.

Experiment

The experiments evaluate CarryOn on OSWorld 2.0 and BrowseComp-Plus using Claude Opus 4.7, measuring task performance, token usage, and cost across long-horizon computer-use and information-seeking tasks. CarryOn improves task scores while reducing token consumption and cost in both settings, and its context remains compact even as execution length grows. Comparisons with sliding-window and summary-based compression show that aggressive history reduction alone harms performance, whereas CarryOn’s object-oriented organization preserves useful task state and supports better continuation. Ablations further show that continuation carriers and execution context provide complementary information, helping the agent resume from established progress rather than repeating prior work.

CarryOn improves both binary and partial task completion on OSWorld 2.0 relative to its Claude Opus host agent, with partial score rising from 43.9% to 49.7% and binary score from 15.7% to 19.4%. These gains exceed the other evaluated frontier models while also reducing total token usage by 51.9% and cost per task by 35.9%, indicating lower long-horizon execution cost without sacrificing task performance. CarryOn adds 5.8 percentage points to partial score and 3.7 points to binary score over the same host agent. The improved scores surpass other frontier models while cost per task drops by about a third and token usage falls by more than half.

CarryOn reduces resource usage per task on both OSWorld 2.0 and BrowseComp-Plus relative to baseline. The largest savings appear on OSWorld 2.0, where total token usage falls by more than half and total cost by about a third, while BrowseComp-Plus shows smaller but consistent reductions. These improvements align with lower context-processing overhead without sacrificing task performance. CarryOn lowers total token usage per task on both benchmarks, with a larger relative reduction on OSWorld 2.0 than on BrowseComp-Plus. Total cost per task also declines, mainly reflecting reduced agent token usage and agent cost rather than added runtime overhead.

On the 100-question BrowseComp-Plus subset, adding CarryOn to Claude Opus 4.7 improves accuracy from 49.0% to 56.0%, surpassing the compared frontier models. This gain is accompanied by lower token usage and cost relative to the Claude Opus baseline. CarryOn raises Claude Opus 4.7 accuracy from 49.0% to 56.0% on this BrowseComp-Plus subset, moving it ahead of GPT-5, o3, GPT-OSS-120B, and the standalone Claude Opus baseline. The same CarryOn configuration reduces total token usage by 22.9% and total cost by 7.1% compared with the Claude Opus baseline.

On a shared OSWorld 2.0 subset, aggressive context compression alone lowers both binary and partial scores relative to an uncompressed baseline. Applying object-oriented organization within a textual summary recovers much of that loss, but the full CarryOn runtime reaches the highest partial score while matching the baseline binary score. CarryOn also achieves this with less retained text than the guided summary approach. Sliding Window and Generic Summary retain the shortest contexts but reduce both binary and partial scores relative to the baseline. CarryOn-Guided Summary recovers much of the lost partial score, while full CarryOn improves partial score by 5 percentage points with about 10 percent shorter post-fold text. CarryOn matches the baseline binary score and achieves the highest partial score without retaining the most text.

An ablation on the shared OSWorld 2.0 subset shows that both execution context and continuation carriers contribute to CarryOn's partial score. Removing execution context lowers binary and partial scores without substantially changing agent calls, while removing continuation carriers lowers partial score and increases agent calls and cost. The two components appear to provide complementary information for continuing tasks. Removing execution context caused a substantial drop in binary and partial scores while agent calls remained nearly unchanged. Removing continuation carriers increased agent calls and cost while partial score fell, suggesting the agent had to recover or reproduce prior progress.

CarryOn is evaluated on OSWorld 2.0 task completion and a 100-question BrowseComp-Plus subset using a Claude Opus host, where it improves partial and binary task scores or accuracy over the baseline while reducing total token usage and cost per task. Ablations show that aggressive context compression alone hurts performance, whereas the full runtime with object-oriented organization and both execution context and continuation carriers recovers or improves scores. The two carrier components provide complementary support, with execution context mainly preserving task success and continuation carriers reducing agent calls and helping the agent avoid reproducing prior progress.