Readie:面向 AI Agent 的低延迟代码沙箱
摘要
论文提出了 Readie 系统,该系统为 AI Agent 使用的代码沙箱学习一组紧凑且预热的启动快照,在相同存储预算下,将启动延迟降低 3–22 倍,端到端运行时间缩短 1.3–3.3 倍。
arXiv:2611.22171v1 Announce Type: new
Abstract: From quantitative research to personal assistance, AI agents act by iteratively generating and executing code. To decouple the agent harness from code execution, many agents offload execution to dedicated systems called code sandboxes. However, existing code sandboxes suffer from slow startup. Whether they rely on custom snapshots or a single fat image, the root cause is the same: it is hard to build a compact, pre-warmed snapshot that can be shared across diverse agent-generated code while covering nearly all the artifacts (e.g., packages, datasets) it requires.
In this work, we propose learned startup snapshots for low-latency code sandboxes. Our insight is that while it is hard for a single snapshot to be both compact and cover most workloads, a set of snapshots can achieve both. Each snapshot is small, initializes quickly, and covers a fraction of agent-generated code; together, the set covers most of it. We learn this set from a large training workload by formulating snapshot construction as an optimization problem and solving it with an approximation algorithm. Planned on 15K public and LLM-synthesized scripts, our system, Readie, reduces startup latency by 3-22$\times$ and end-to-end runtime by 1.3-3.3$\times$ compared to existing approaches at the same storage budget.
查看缓存全文
缓存时间: 2026/11/19 03:26
# 1Introduction
Source: [https://arxiv.org/html/2611.22171](https://arxiv.org/html/2611.22171)
marginparsep has been altered\. topmargin has been altered\. marginparwidth has been altered\. marginparpush has been altered\.
The page layout violates the ICML style\.
Please do not change the page layout, or include packages like geometry, savetrees, or fullpage, which change it for you\.
We’re not able to reliably undo arbitrary changes to the style\. Please remove the offending package\(s\), or layout\-changing commands and try again\.
Readie: Low\-Latency Code Sandboxes for AI Agents
Arjun Sivaraman1Zhaoheng Li2Alan Shi1Sanjay Malisetty1Eugene Wu3Yongjoo Park1
††footnotetext:1University of Illinois Urbana\-Champaign2ByteDance3Columbia University\. Correspondence to: Arjun Sivaraman <arjun16@illinois\.edu\>, Yongjoo Park <yongjoo@illinois\.edu\>\.
###### Abstract
From quantitative research to personal assistance, AI agents act by iteratively generating and executing code\. To decouple the agent harness from code execution, many agents offload execution to dedicated systems called*code sandboxes*\. However, existing code sandboxes suffer from slow startup\. Whether they rely on custom snapshots or a single fat image, the root cause is the same: it is hard to build a compact, pre\-warmed snapshot that can be shared across diverse agent\-generated code while covering nearly all the artifacts \(e\.g\., packages, datasets\) it requires\. In this work, we propose*learned startup snapshots*for low\-latency code sandboxes\. Our insight is that while it is hard for a single snapshot to be both compact and cover most workloads, a set of snapshots can achieve both\. Each snapshot is small, initializes quickly, and covers a fraction of agent\-generated code; together, the set covers most of it\. We learn this set from a large training workload by formulating snapshot construction as an optimization problem and solving it with an approximation algorithm\. Planned on 15K public and LLM\-synthesized scripts, our system, Readie, reduces startup latency by 3–22×\\timesand end\-to\-end runtime by 1\.3–3\.3×\\timescompared to existing approaches at the same storage budget\.
## 1Introduction
AI agents rely heavily on code execution\. To give financial advice, an agent may call[DuckDuckGo \(\)](https://arxiv.org/html/2611.22171#bib.bib1)to retrieve current mortgage rates and US Treasury yields\. To perform quantitative political science research, it may use[pandas \(\)](https://arxiv.org/html/2611.22171#bib.bib36)over government datasets\. And to shrink vacation photos before emailing them to family, it may use[Pillow \(\)](https://arxiv.org/html/2611.22171#bib.bib47)to compress hundreds of images\. To run such code at scale, independent of the agent’s development environment, many agents offload execution to dedicated systems called*code sandboxes*[Modal \(\)](https://arxiv.org/html/2611.22171#bib.bib2);[E2B \(\)](https://arxiv.org/html/2611.22171#bib.bib3);[Daytona \(\)](https://arxiv.org/html/2611.22171#bib.bib4)\. Sandbox latency directly affects agents’ task completion time: the faster, the better\.
Existing sandboxes incur long startup times to provision required artifacts such as libraries/packages, datasets, etc\. For example, to run a pandas script, the sandbox must include the pandas package\. Existing approaches address this through: \(i\) custom container images \([Fig1](https://arxiv.org/html/2611.22171#S1.F1)\-bottom left\), \(ii\) custom snapshots \([Fig1](https://arxiv.org/html/2611.22171#S1.F1)\-bottom right\), or \(iii\) a shared fat image \([Fig1](https://arxiv.org/html/2611.22171#S1.F1)\-top left\)\. First, services such as Cloud Run[Google Cloud \(\)](https://arxiv.org/html/2611.22171#bib.bib34)111We use Cloud Run, Modal, and Colab as examples based on their current offerings, without considering their business positioning\. They may develop similar techniques in the future\.let users build custom container images, and others such as Modal[Modal Labs \(\)](https://arxiv.org/html/2611.22171#bib.bib13)let users build snapshots containing useful artifacts\. However, these images or snapshots must be fetched from remote storage unless they are cached from a previous run\. Moreover, hand\-built images or snapshots may miss some artifacts, incurring slow runtime downloads \(e\.g\.,pip install\)\. Second, Colab\-like[Google Colaboratory \(\)](https://arxiv.org/html/2611.22171#bib.bib32)platforms use a single fat image of commonly used packages \(e\.g\.,[NumPy \(\)](https://arxiv.org/html/2611.22171#bib.bib35),[scikit\-learn \(\)](https://arxiv.org/html/2611.22171#bib.bib37)\)\. This image is static: its contents are chosen in advance rather than adapted to usage\. Furthermore, loading artifacts from a file\-based image is relatively slower than memory\-state snapshots\.
FilesMemory\-stateCustomizedShareableA fat image\(e\.g\., Colab\)Custom containerimages\(e\.g\., Cloud Run\)Hand\-craftedSnapshots\(e\.g\., Modal\)LearnedSnapshots\(Ours\)Figure 1:We leverage*learned startup snapshots*to achieve low\-latency code sandboxes\. That is, we create a set of snapshots: each is small in size \(thus clones fast\) while at least one of them likely contains required artifacts, thus offering high coverage\.In this work, we propose*learned startup snapshots*for low\-latency code sandboxes\. The core idea is that while it is hard for a single snapshot to include all required artifacts, it is far easier to ensure that at least one of several snapshots does\. Because each snapshot covers only a subset of artifacts, it stays small \(a few tens of megabytes\) and initializes quickly\. Our system, Readie, serves requests as follows: Given a script, Readie finds the smallest snapshot that contains most required artifacts by evaluating its internal cost function on expected startup time; then, Readie clones an isolated container from the snapshot\. It then executes the script and destroys the container\. Unlike custom snapshots, Readie learns which artifacts to include from usage, so users need not predict them\. Unlike a shared fat image, Readie skips loading artifacts at startup, since they are already in the snapshot’s memory\.
In designing Readie, a core research problem is to build a set of snapshots that minimizes the expected startup cost\. One naive approach is to build a single snapshot from the most popular artifacts \(e\.g\., based on statistics from public scripts\)\. However, to cover most scripts, this snapshot must include many artifacts, which makes it too large to load quickly\. Another naive approach is to mine artifacts that are frequently used together[Agrawal and Srikant \(1994\)](https://arxiv.org/html/2611.22171#bib.bib5);[Han et al\. \(2000\)](https://arxiv.org/html/2611.22171#bib.bib6);[Li et al\. \(2025a\)](https://arxiv.org/html/2611.22171#bib.bib16)\. However, we find that this frequency\-based approach ignores the actual cost of loading each artifact\. Instead, we formulate an optimization problem whose objective models the actual load time of each artifact, considering the dependencies among artifacts\. Its solution is a near\-optimal set of snapshots within a storage budget: the formulation is exact, but we solve it with an approximation algorithm for scalability\.
Readie targets \(i\) fast execution of previously unseen code with \(ii\) container\-level isolation, achieving both efficiency and security\. This differs from existing work\. Per\-function snapshots[Silva et al\. \(2020\)](https://arxiv.org/html/2611.22171#bib.bib11);[Kohli et al\. \(2024\)](https://arxiv.org/html/2611.22171#bib.bib15);[Shin et al\. \(2022\)](https://arxiv.org/html/2611.22171#bib.bib12)are created in advance for each function, so they are not optimized for new code\. State\-sharing systems[Oakes et al\. \(2018\)](https://arxiv.org/html/2611.22171#bib.bib24);[Chai et al\. \(2025\)](https://arxiv.org/html/2611.22171#bib.bib27);[Yang et al\. \(2024\)](https://arxiv.org/html/2611.22171#bib.bib26);[Li et al\. \(2021\)](https://arxiv.org/html/2611.22171#bib.bib28);[Li et al\. \(2025a\)](https://arxiv.org/html/2611.22171#bib.bib16)decide heuristically what to share\. They also let different requests share live in\-memory state, which can weaken isolation between them\. Other cold\-start optimization techniques are orthogonal to ours \([§7](https://arxiv.org/html/2611.22171#S7)\)\.
This work makes the following contributions:
1. 1\.We show why existing approaches are poorly suited for agent workloads, and why learned startup snapshots are effective \([§2](https://arxiv.org/html/2611.22171#S2)\)\.
2. 2\.We present the design of Readie, a practical system that serves requests with learned startup snapshots \([§3](https://arxiv.org/html/2611.22171#S3)\)\.
3. 3\.We formulate snapshot construction as an optimization problem and present an approximation algorithm that finds a near\-optimal set of snapshots \([§4](https://arxiv.org/html/2611.22171#S4)\)\.
4. 4\.We describe the implementation challenges we addressed in building Readie \([§5](https://arxiv.org/html/2611.22171#S5)\)\.
5. 5\.We evaluate our system \(Readie\) on 15K scripts: it reduces both startup latency and end\-to\-end time \([§6](https://arxiv.org/html/2611.22171#S6)\)\.
Finally, we discuss related work \([§7](https://arxiv.org/html/2611.22171#S7)\) and conclude \([§8](https://arxiv.org/html/2611.22171#S8)\)\.
## 2Motivation
This section discusses why existing sandboxes start slowly \([§2\.1](https://arxiv.org/html/2611.22171#S2.SS1)\), our intuition for using only a few snapshots to serve a large number of requests \([§2\.2](https://arxiv.org/html/2611.22171#S2.SS2)\), and the characteristics of agent\-generated workloads that enable it \([§2\.3](https://arxiv.org/html/2611.22171#S2.SS3)\)\.
11223344556677880011223344556677numpy, pandas, matplotlib, seaborn, transformers\+ sentence\-transformers, umap\-learn\+ plotly\+ scikit\-learnTurnNew packages requestedIndividual trajectoriesAverageFigure 2:New packages that each of 10 agent sessions requests for the first time at each turn \(light blue\), and their mean at each turn \(red\), rounded up\. It also shows the actual packages requested in one of the trajectories \(solid blue\)\.### 2\.1Why Are Current Methods Slow?
Pre\-built images or snapshots can be fast if they include the required artifacts\. In practice, however, they often do not, and existing solutions fail to close this gap\. In this section, we support these claims with three empirical studies\. First, by analyzing agent\-generated trajectories, we show that snapshots from previous runs are often not reusable for future runs\. Second, we show that downloading artifacts at request time, with only a base image cached on each VM, results in high startup latency\. Third, we show that the existing image\-sharing approach, a single fat image, also incurs slow startup\.
05101520Start \+ importCustom layer \(pip installs\)Python runtime layerBase layer \(Debian\)0\.5 s \+ 1\.4 s0\.3 s \+ 1\.0 s2\.8 s \+ 12\.2 s2\.1 sMay be cached on the host:saving 0\.5 secsTime since pull request \(s\)DownloadDecompress \+ writeStart \+ import\(a\)Time to initialize and import packages in a custom imageSourceBytecodeRestoreSourceBytecodeRestoreSourceBytecodeRestore02468pandas2\.74 s1\.00 s0\.29 storch5\.12 s2\.80 s0\.31 snltk7\.28 s2\.68 s0\.42 sTime \(s\)Load interpreterSearch & resolve modulesLoad filesCompile to bytecodeLoad bytecodeExecute into memoryRestore from snapshot\(b\)Time to import a package across different methods
Figure 3:Analysis of startup cost\. \(a\) Loading a pre\-built image becomes slower if layers need to be downloaded or artifacts are missing; \(b\) If artifacts reside on disks, cloning/restoring from a memory\-state snapshot is faster than reading artifacts \(i\.e\., Python packages here\) from original source code or cached bytecode\.##### Packages the code needs are not known in advance\.
We study whether the packages an agent needs for an entire session are known from the code executed in its first turn, by recording the packages imported at each turn\. We use 6,833 agent sessions, in which an agent runs code at each turn to work on a task: trajectories recorded on agent benchmarks, general data science tasks, and code debugging sessions \(seeandfor details\)\. In 30\.8% of these sessions, agents import new packages after their first turn, and they keep requesting new packages until turn 3\.7 on average \([Fig2](https://arxiv.org/html/2611.22171#S2.F2)\)\. An agent requests new packages after its first turn because it decides each step only after seeing the previous step’s output[Park et al\. \(2026\)](https://arxiv.org/html/2611.22171#bib.bib67)\. The session drawn in solid\-blue in[Fig2](https://arxiv.org/html/2611.22171#S2.F2)first classifies the sentiment of product reviews with[Transformers \(\)](https://arxiv.org/html/2611.22171#bib.bib41), pandas, and[seaborn \(\)](https://arxiv.org/html/2611.22171#bib.bib39)\. It then embeds the reviews \([Sentence Transformers \(\)](https://arxiv.org/html/2611.22171#bib.bib49),[UMAP \(\)](https://arxiv.org/html/2611.22171#bib.bib50)\), plots them \([Plotly \(\)](https://arxiv.org/html/2611.22171#bib.bib48)\), and finally models their topics \(scikit\-learn\)\.
##### Using a custom image for each execution\.
Services such as Cloud Run[Google Cloud \(\)](https://arxiv.org/html/2611.22171#bib.bib34)and AWS Lambda[Brooker et al\. \(2023\)](https://arxiv.org/html/2611.22171#bib.bib31)initialize each sandbox from a container image that holds the code’s packages\. We measure how long such a sandbox takes to become ready to execute code when its image is not cached on the host\. We pulled an image with a base layer, a runtime layer, and a custom layer that installs pandas,[PyTorch \(\)](https://arxiv.org/html/2611.22171#bib.bib40)and[NLTK \(\)](https://arxiv.org/html/2611.22171#bib.bib43)from a remote registry over a 1 Gbit/s link, with no layer cached\. We then started a container from the downloaded image and ran code that imports the three packages \([Fig3\(a\)](https://arxiv.org/html/2611.22171#S2.F3.sf1)\)\. The sandbox was ready to use after 17\.4 s, of which downloading and extracting the custom layer took 15\.0 s, and starting the container and importing the packages took 2\.1 s\.
##### Using one fat image for all executions\.
Notebook services such as Colab[Google Colaboratory \(\)](https://arxiv.org/html/2611.22171#bib.bib32)reduce request\-time downloads by running every sandbox from a large shared image with common packages installed\. We measure how long a fresh sandbox takes to import packages that the code requires from such an image, and how much of that time a snapshot saves\. On the[Kaggle Python \(\)](https://arxiv.org/html/2611.22171#bib.bib51)image, which contains many commonly used packages, we imported each of pandas, PyTorch and NLTK separately in three ways: from disk with no compiled bytecode, from bytecode compiled ahead of time, and by restoring a snapshot taken after the import \([Fig3\(b\)](https://arxiv.org/html/2611.22171#S2.F3.sf2)\)\. From disk, the imports took 2\.74–7\.28 s, of which 56–70% was bytecode compilation time\. With compiled bytecode, importing still took 1\.00–2\.80 s to load and run the modules\. Restoring the snapshot skipped both steps, and the sandbox was ready in 0\.29–0\.42 s\.
### 2\.2Missed Opportunity: Learned Snapshots
We hypothesize that a*small*number of*compact*snapshots can*cover*a large number of requests \(i\.e\., scripts to execute\)\. This hypothesis rests on three elements: a definition of*coverage*, an effective approach to*compactness*, and a one\-to\-many mapping from snapshots to requests, which keeps the number of snapshots*small*\. This subsection defines coverage, and then argues that compactness requires novel techniques\. The next subsection examines whether a one\-to\-many mapping holds in practice\.
##### Cost\-based coverage\.
In principle, even an empty snapshot can cover any request by downloading required artifacts at request time\. To reflect this, we define coverage through a cost function\. Suppose a snapshotSiS\_\{i\}contains artifactsa1a\_\{1\},a2a\_\{2\}, anda3a\_\{3\}, and a requestRjR\_\{j\}requiresa1a\_\{1\}anda4a\_\{4\}\. Then, servingRjR\_\{j\}withSiS\_\{i\}incurs the cost of loadinga1a\_\{1\}from the snapshot \(fast\) and downloadinga4a\_\{4\}\(slow\)\. We call the missing artifacts,Rj∖Si=\{a4\}R\_\{j\}\\setminus S\_\{i\}=\\\{a\_\{4\}\\\}, the*residuals*\.
R1nppdR2nppdskR3nppdskmplR4nppdskmplsnsR5nppdskxgb\(a\)One snapshot per request: 162 MB total snapshot sizenppdskmplshared snapshotR1nppdskmplR2nppdskmplR3nppdskmplR4nppdskmplsnsR5nppdskmplxgbrestore snapshotcontainerunusedresidual import\(b\)A snapshot shared across requests: 32 MB total snapshot size
Figure 4:Conceptual difference between \(a\) per\-request snapshot vs \(b\) a shareable snapshot for multiple requests\. We take the second approach through learned startup snapshots\.[Fig4](https://arxiv.org/html/2611.22171#S2.F4)contrasts per\-request snapshots \([Fig4\(a\)](https://arxiv.org/html/2611.22171#S2.F4.sf1)\) with a single snapshot shared across requests \([Fig4\(b\)](https://arxiv.org/html/2611.22171#S2.F4.sf2)\)\. With per\-request snapshots, serving five requests, each requiring a different set of artifacts, requires five snapshots\. With our relaxed definition of coverage, a single snapshot can serve all five, though at different startup costs[Xia et al\. \(2026\)](https://arxiv.org/html/2611.22171#bib.bib68);[Wu et al\. \(2025\)](https://arxiv.org/html/2611.22171#bib.bib69)\. For example, a 32 MB snapshot containing NumPy, pandas, scikit\-learn and[Matplotlib \(\)](https://arxiv.org/html/2611.22171#bib.bib38)fully coversR1R\_\{1\}–R3R\_\{3\}, which incur no additional load time\. RequestsR4R\_\{4\}andR5R\_\{5\}must also load their residuals, seaborn and[XGBoost \(\)](https://arxiv.org/html/2611.22171#bib.bib44), which takes 0\.3 s and 0\.7 s, respectively\. Even so, they still skip importing the four shared artifacts, which account for most of their import time\. Overall, one snapshot replaces five, cutting storage by 5×\\timesat the cost of only 1 s of additional load time in total\.
##### Compact snapshot through learning\.
Finding an optimal set of snapshots, one that minimizes the total startup cost across all requests, requires more than simple heuristics\. In[Fig4\(b\)](https://arxiv.org/html/2611.22171#S2.F4.sf2), for example, including NumPy and pandas in a snapshot is an easy choice, sinceR1R\_\{1\}–R5R\_\{5\}all require them\. Whether to also include scikit\-learn, however, depends on the workload\. IfR1R\_\{1\}\-like requests, which do not need scikit\-learn, dominate the workload, including it would increase the snapshot load time for most requests, while saving residual load time for only a few\.
To address it, we take a learning\-based approach: we find optimal snapshots using a training workload[Park et al\. \(2017\)](https://arxiv.org/html/2611.22171#bib.bib65);[Mozafari et al\. \(2023\)](https://arxiv.org/html/2611.22171#bib.bib66)\. While the training workload could be tailored to a specific deployment, we instead collect a large number of scripts from public sources \(e\.g\.,[Kaggle \(\)](https://arxiv.org/html/2611.22171#bib.bib52),[Hugging Face \(\)](https://arxiv.org/html/2611.22171#bib.bib53)\) and synthesize more with frontier large language models[Fang et al\. \(2025b\)](https://arxiv.org/html/2611.22171#bib.bib57)\. Just like a pre\-trained model generalizes to a wide range of tasks, we expect our snapshots to efficiently cover most practical workloads\. We validate this in[§6](https://arxiv.org/html/2611.22171#S6)\.
### 2\.3Characteristics of Workloads
𝒄𝟑\\bm\{c\_\{3\}\}:numpy, pandas,transformersmatplotlib,numpy, pandas,scikit\-learn,seaborn,transformers𝒄𝟏\\bm\{c\_\{1\}\}:matplotlib,numpy, pandas,scikit\-learn,seabornkeras, numpy,pandas,scikit\-learnmatplotlib,numpy, pandas,scikit\-learn,torchmatplotlib,numpy, pillow,scikit\-learn𝒄𝟐\\bm\{c\_\{2\}\}:matplotlib,numpy,opencv\-python,pandas, pillow,scikit\-learn,seabornrequestsnapshotFigure 5:Snapshots and requests have a one\-to\-many mapping: a few snapshots can cover many requests\. A small dot is a code execution request, and a large dot is a candidate snapshot\. An oval around a snapshot encloses the requests it can efficiently cover\.We examine whether one\-to\-many relationships hold between snapshots and requests\. If so, only a few snapshots can cover a large number of requests efficiently\. We represent each of the 15,299 requests in our planning set \(\) by the set of packages it imports, cluster these sets by Jaccard distance[Jaccard \(1901\)](https://arxiv.org/html/2611.22171#bib.bib33)with average linkage\. The clusters hold 11,664 requests with 2,472 distinct package sets, and 75% of which are required by only one request \([Fig5](https://arxiv.org/html/2611.22171#S2.F5)\)\. We pick one request near each cluster’s center as a snapshot and price every request on it with the cost model defined in[§4\.2](https://arxiv.org/html/2611.22171#S4.SS2)\.
##### One snapshot covers multiple requests\.
Each cluster shares a core set of packages: NumPy, pandas and scikit\-learn \(blue, 82% of the requests\); Pillow,[OpenCV \(\)](https://arxiv.org/html/2611.22171#bib.bib45)and torchvision[PyTorch \(\)](https://arxiv.org/html/2611.22171#bib.bib40)\(orange\); and Transformers,[Hugging Face Datasets \(\)](https://arxiv.org/html/2611.22171#bib.bib42)and PyTorch \(green\)\. Of the 9,325 requests in[Fig5](https://arxiv.org/html/2611.22171#S2.F5),c1c\_\{1\}serves 83%, andc2c\_\{2\}andc3c\_\{3\}serve 9% and 7%\. Only 1,731 ofc1c\_\{1\}’s 7,775 requests match it exactly: 2,286 need a subset of its packages, and 1,500 import a few more as residuals\. Snapshots that match requests exactly would instead need 1,306 snapshots and 351 GB to serve 90% of these requests\. The most common set is not always the best center, however\. The orange cluster’s most common set, \{Pillow, OpenCV, Matplotlib, NumPy\}, serves 288 requests, while adding pandas and scikit\-learn to it, asc2c\_\{2\}does, serves 853\.
##### Overlaps create trade\-offs and redundancy\.
The request \{Matplotlib, NumPy, pandas, scikit\-learn, PyTorch\} lies wherec1c\_\{1\}andc3c\_\{3\}overlap\.c1c\_\{1\}holds four of its five packages, but restoring it \(0\.44 s\) requires importing PyTorch from disk, which costs 14\.8 s\.c3c\_\{3\}holds PyTorch, which Transformers imports, so restoring it takes 0\.86 s and serves the rest in 13\.6 s, in a lower time thanc1c\_\{1\}\. Overlaps also make snapshots redundant:c2c\_\{2\}holds all ofc1c\_\{1\}plus Pillow and OpenCV, and restores only 0\.02 s slower, so for 7,954 of the 9,325 requests the two are within 10% of each other\. Choosing snapshots therefore means weighing such overlaps against a storage budget, with a cost model rather than the clusters’ shape alone \([§4](https://arxiv.org/html/2611.22171#S4)\)\.
## 3System Overview
This section covers Readie’s components and the path taken when a code execution is requested \([Fig6](https://arxiv.org/html/2611.22171#S3.F6)\)\.
ClientReadie \(ours\)Exec 1Exec 2Exec 3LearnedsnapshotsOptimizerCloneTraining dataMetadataOptimizeSnapshotsOfflineOur contributionFigure 6:Architecture of our system \(Readie\)\. Our core contribution is to use a small number of learned snapshots\.### 3\.1Readie Components
The client, router, and executors serve incoming requests, while the optimizer runs offline and produces the learned snapshots from which executors are cloned\.*\(Client\)*The client sends the code to Readie and receives its response\.*\(Router\)*The router selects a snapshot for the request based on the requirements of the code\.*\(Executor\)*Each executor is a sandbox that runs the code\. It is cloned from a learned snapshot \(a checkpoint taken after importing the planned packages\), so it starts with those packages already in memory\.*\(Optimizer\)*Offline, the optimizer derives metadata \([§5\.1](https://arxiv.org/html/2611.22171#S5.SS1)\) from historical requests \(the training data\), solves an optimization problem \([§4\.4](https://arxiv.org/html/2611.22171#S4.SS4)\) to select a small set of snapshots, and builds and stores them on disk\.
### 3\.2Readie Workflow
A request goes through three steps, from the client to its execution on Readie \([Fig6](https://arxiv.org/html/2611.22171#S3.F6)\)\.*\(Client analysis and serialization\)*The client finds the modules the code imports and sends the serialized code and its arguments to the router\.*\(Snapshot selection and provisioning\)*The router selects the snapshot that minimizes the request’s initialization time \([§4\.2](https://arxiv.org/html/2611.22171#S4.SS2)\), clones it into a new executor sandbox, and streams the payload to the executor over a socket\.*\(Code execution\)*The executor deserializes the code and imports the needed modules; those held by the snapshot are already in memory, so only the rest are loaded from disk\. It then runs the code and returns the serialized result \(or exception\) to the client along the same path\.
## 4Determining Ideal Snapshots
This section discusses how Readie determines which packages to include in each snapshot, how many snapshots to build, and which snapshot to restore for each request\. The objective is to find snapshot sets which minimize the overall initialization time of all requests, while staying within a storage budget[Li et al\. \(2025c\)](https://arxiv.org/html/2611.22171#bib.bib62);[Li et al\. \(2023b\)](https://arxiv.org/html/2611.22171#bib.bib63)\.
0010010020020030030040040050050060060070070080080000112233α=0\.0031\\alpha=0\.0031s/MBtbase=0\.32t\_\{\\mathrm\{base\}\}=0\.32sSnapshot sizeS\(c\)S\(c\)\(MB\)Restore time \(s\)SnapshotLinear fittbase\+αS\(c\)t\_\{\\mathrm\{base\}\}\+\\alpha S\(c\)Figure 7:Restore time against snapshot size for 50 snapshots, each holding a different set of packages\. Each point is the median of 5 restores\. The slope of the fitted line isα\\alphaand its intercept istbaset\_\{\\mathrm\{base\}\}\.### 4\.1Serving a Request with a Snapshot
##### Packages and their properties\.
LetPPbe the union of all packages requested in the historical requests\. Each packagep∈Pp\\in Phas three properties that are required for planning snapshots: its dependencies, import time from disk \(tpt\_\{p\}\), and size in memory \(mpm\_\{p\}\)\. The process of measuring each of these properties is explained in[§5\.1](https://arxiv.org/html/2611.22171#S5.SS1)\. For a set of packagesXX, we writeX¯\\overline\{X\}for its*closure*, i\.e\.,XXtogether with all its transitive dependencies\.
##### Request\.
A request is a function call, whererris a set of packages it imports\. Importingrrloads its closure, so in practice the request needs the packagesDr=r¯D\_\{r\}=\\overline\{r\}\.
##### Snapshot\.
A snapshot represents a sandbox which was checkpointed after importing a set of packagescc[Li et al\. \(2023a\)](https://arxiv.org/html/2611.22171#bib.bib58);[Li et al\. \(2024a\)](https://arxiv.org/html/2611.22171#bib.bib59)\. Again, importingccloads its closure, so in practice the snapshot contains the packagesDc=c¯D\_\{c\}=\\overline\{c\}\. The size of a snapshot is the total memory that the packagesDcD\_\{c\}hold,S\(c\)=∑p∈DcmpS\(c\)=\\sum\_\{p\\in D\_\{c\}\}m\_\{p\}\.
### 4\.2Initialization Time
#### 4\.2\.1Restore Time for a Snapshot
Restoring a snapshot takes \(1\) a constant timetbaset\_\{\\mathrm\{base\}\}to create the sandbox, plus \(2\) time to restore its memory, which grows with its size:Trestore\(c\)=tbase\+αS\(c\)T\_\{\\mathrm\{restore\}\}\(c\)=t\_\{\\mathrm\{base\}\}\+\\alpha\\,S\(c\)[Chockchowwat et al\. \(2023b\)](https://arxiv.org/html/2611.22171#bib.bib64), whereα\\alphais the restore time in seconds per megabyte of memory and represents how the snapshot’s memory state restoration time changes with its size\.
To test our modeling of the restore time, we restore 50 snapshots, each holding a different set of packages, and time each restore \([Fig7](https://arxiv.org/html/2611.22171#S4.F7)\)\. The slope of the fitted line isα\\alpha, and the Y\-intercept istbaset\_\{\\mathrm\{base\}\}\. In our experiment, the fitted line has slopeα=0\.0031\\alpha=0\.0031s/MB and intercepttbase=0\.32t\_\{\\mathrm\{base\}\}=0\.32s, which is consistent with the restore time having a constant component and a component that grows linearly with the snapshot size\.
#### 4\.2\.2Residual Import Time
The residual import time accounts for the import time of the packages that a requestrrneeds and a snapshotcclacks\. Since package dependencies are not mutually exclusive, it is possible that the snapshot closureDcD\_\{c\}already contains some of the dependencies from the request closureDrD\_\{r\}\. The residual import time is then:Tresidual\(r,c\)=∑p∈Dr∖DctpT\_\{\\mathrm\{residual\}\}\(r,c\)=\\sum\_\{p\\in D\_\{r\}\\setminus D\_\{c\}\}t\_\{p\}\.
nppdskmplRequestrrNo snapshots:6\.5 snppdc1c\_\{1\}αS\(c1\)=0\.6\\alpha S\(c\_\{1\}\)=0\.6sTotal 1\.8 snppdskmpltorchc2c\_\{2\}αS\(c2\)=3\.0\\alpha S\(c\_\{2\}\)=3\.0sTotal 3\.0 snppdsksnsc3c\_\{3\}αS\(c3\)=0\.9\\alpha S\(c\_\{3\}\)=0\.9sTotal 1\.7 sskmpl\+1\.2 s\+0 smpl\+0\.8 sSelectedFigure 8:Selecting a snapshot for a requestrr\. Beside each snapshot are its restore timeαS\(c\)\\alpha S\(c\)and its total time\. Each arrow shows the residual packages and their import time\. Snapshotc2c\_\{2\}needs no residual imports, but it holds PyTorch, whichrrdoes not use, and is the slowest to restore\. Snapshotc3c\_\{3\}lacks Matplotlib yet has the lowest total time, so it is selected\.Thus, the total initialization time of a requestrrserved from snapshotccis the restore time plus the residual import time\.T\(r,c\)=tbase\+α∑p∈Dcmp\+∑p∈Dr∖DctpT\(r,c\)=t\_\{\\mathrm\{base\}\}\+\\alpha\\,\\sum\_\{p\\in D\_\{c\}\}m\_\{p\}\+\\sum\_\{p\\in D\_\{r\}\\setminus D\_\{c\}\}t\_\{p\}\. The two terms in this equation pull in opposite directions\. A snapshot that holds more packages leaves a smaller residual but takes more time to restore, including for the packages the request does not use\. With a sparse snapshot, the residual time increases as more packages are imported from disk\. When a new requestrrarrives, the snapshotccwith the lowest initialization time \(T\(r,c\)T\(r,c\)\) among all planned snapshots is selected to serve the request, as shown in[Fig8](https://arxiv.org/html/2611.22171#S4.F8)\.tbaset\_\{\\mathrm\{base\}\}is left out since it is the same for every snapshot\.
### 4\.3Defining the Optimization Problem
The objective is to select a set of snapshotsCCsubject to the storage budgetBB\(MB\), which minimizes the total initialization time on a set of requestsRR, when each request inRRis served by exactly one of the snapshots inCC:
ℱ\(C\)=∑r∈Rminc∈CT\(r,c\)s\.t\.∑c∈CS\(c\)≤B\\mathcal\{F\}\(C\)=\\sum\_\{r\\in R\}\\;\\min\_\{c\\in C\}T\(r,c\)\\qquad s\.t\.\\quad\\sum\_\{c\\in C\}S\(c\)\\leq B\(1\)
##### Assumptions\.
The cost model only considers the packages present in the planning set and assumes that they are available on disk, treating each package’s size in memory and import time as additive once its dependencies are loaded\.
### 4\.4Solving the Optimization Problem
The space of possible snapshots, which is every closed set of packages, grows exponentially with the number of packages, making the problem𝖭𝖯\\mathsf\{NP\}\-hard[Kariv and Hakimi \(1979\)](https://arxiv.org/html/2611.22171#bib.bib9)\. To limit the candidate space, we restrict the snapshot candidates to the distinct closures of the planning requests\.
By limiting the candidate space,[Eq\.1](https://arxiv.org/html/2611.22171#S4.E1)becomes a budgeted facility location problem where the distinct request closures are the customers as well as candidates for the facilities \(snapshots\)\. The distance from a customerrrto a facilityccisT\(r,c\)T\(r,c\), which is the asymmetric distance that we want to minimize\. The cost to open a facility isS\(c\)S\(c\), and the total cost of all open facilities must not exceed the budgetBB\. Every customer \(request\) is assigned to an open facility \(snapshot\)\. Readie solves it with a greedy algorithm for facility location[Cornuéjols et al\. \(1977\)](https://arxiv.org/html/2611.22171#bib.bib8)which, at each step, adds the candidate that fits in the remaining budget and reduces the weighted total of[Eq\.1](https://arxiv.org/html/2611.22171#S4.E1)the most\. It stops when no candidate fits the budget or lowers the total\. The time complexity of the algorithm isO\(KN2\)O\(KN^\{2\}\)with a space complexity ofO\(N2\+NP\)O\(N^\{2\}\+NP\), whereNNis the number of candidates \(here requests\),PPthe number of packages andKKthe number of snapshots chosen\.
##### Alternative algorithm considerations\.
The budgeted facility locationMILPprovides an optimal solution, but its solve time grows exponentially with the number of distinct sets and packages in the worst case\.Greedy knapsackranks candidates once by the import time they save and takes them while they fit in the budget, ignoring what earlier picks already cover\.kk\-medoids[Kaufman and Rousseeuw \(1990\)](https://arxiv.org/html/2611.22171#bib.bib10)starts with the greedy facility location solution and a few random starts and refines it by swapping and adding snapshots under the budget, so it is never worse than greedy facility location itself\.Agglomerative Jaccard[Jaccard \(1901\)](https://arxiv.org/html/2611.22171#bib.bib33)clusters the request sets by Jaccard distance with average linkage and marks the union of each cluster as a snapshot, ignoring import time and size\.evaluates all the above algorithms on the planning and validation sets\.
## 5Implementation and Discussion
This section describes Readie’s implementation \([§5\.1](https://arxiv.org/html/2611.22171#S5.SS1)\) and design considerations \([§5\.2](https://arxiv.org/html/2611.22171#S5.SS2)\)\.
### 5\.1Implementation
##### Metadata generation\.
For each package, Readie imports it in a fresh interpreter and records the modules the import adds tosys\.modules, which gives its dependencies and submodules\. In a second fresh interpreter, it imports the dependencies first and then imports the package itself\. The import time is the time this import takes, and the memory size is the growth of the interpreter’s anonymous resident memory \(RssAnon\)\. Importing the dependencies first makes the measurements additive, so no package’s memory or import time is counted more than once\. The page cache is cleared before every run, so cached pages cannot shorten the import time\.
##### Integrating with Python\.
A@remotedecorator serializes the function and its arguments with cloudpickle[cloudpickle \(\)](https://arxiv.org/html/2611.22171#bib.bib46);[Chockchowwat et al\. \(2025\)](https://arxiv.org/html/2611.22171#bib.bib60);[Chockchowwat et al\. \(2023a\)](https://arxiv.org/html/2611.22171#bib.bib61), finds the modules it imports from the code’s abstract syntax tree, and sends both to the router and deserializes the response received after the execution\.
##### Isolation\.
Each sandbox is a gVisor[Google \(\)](https://arxiv.org/html/2611.22171#bib.bib30)container with its own network stack, which places a user\-space kernel between the code and the host for security and isolation\.
##### Sessions\.
Readie keeps containers warm with a TTL so that requests with the same session ID go to the same sandbox and are able to reuse its imported modules and share global variables across executions[Li et al\. \(2024b\)](https://arxiv.org/html/2611.22171#bib.bib54);[Li et al\. \(2025b\)](https://arxiv.org/html/2611.22171#bib.bib55);[Fang et al\. \(2025a\)](https://arxiv.org/html/2611.22171#bib.bib56)\.
### 5\.2Design Considerations
##### Using a fat image for the rootfs\.
The root file system of every sandbox is a copy\-on\-write overlay, held in the sandbox’s memory, over a read\-only root file system which is the[Kaggle Python \(\)](https://arxiv.org/html/2611.22171#bib.bib51)image that all sandboxes share\.
##### File system support\.
A sandbox does not share the host’s file system\. This isolates users from each other and from the host, and keeps the root file system identical to the one the snapshots were checkpointed on, which a restore requires\. File data can still be used by loading it into memory as a variable and passing it to the remote function, or it can be reused across multiple executions using sessions\.
##### Packages with import side effects\.
The cost model \([§4\.2](https://arxiv.org/html/2611.22171#S4.SS2)\) assumes that the packages inDc∖DrD\_\{c\}\\setminus D\_\{r\}do not affect a request’s execution\. This does not hold for packages that modify other modules on import, such as by monkey\-patching\. A request served from a snapshot that contains one executes with the modified modules even if the request does not import it\. Such packages can be excluded from the snapshots in the planning stage and imported after restore when a request requires them\.
## 6Experimental Evaluation
In this section, we evaluate Readie on a variety of data science workloads, use it as a sandbox for agents on different agent benchmarks, and compare it with existing sandbox provisioning methods\. We make the following claims:
1. 1\.Low initialization time:At the same storage budget of 15 GB, Readie initializes a sandbox 3×\\timesfaster than using per\-request snapshots with caching and 6\.3×\\timesfaster than using a fat image \(\)\.
2. 2\.Per\-request latency at a fraction of the storage:Readie matches the initialization time of using per\-request snapshots, with 14×\\timesless storage \(\)\.
3. 3\.Robust to unseen workloads:In an out\-of\-distribution set, generated without knowledge of the requests Readie plans on, Readie still initializes 2×\\timesfaster than its per\-request snapshots \(\)\.
4. 4\.Faster agent sandbox execution:In agent sandbox executions tested on different agent benchmarks, Readie cuts initialization time by 9\.1×\\timesand end\-to\-end time by 1\.3×\\timesagainst each benchmark’s provided sandbox environment \(\)\.
5. 5\.Optimized for data science workflows:In each of the 8 domain groups, Readie’s initialization times are 4\.6–5\.6% of the cold start time, of which residual imports account for only 9\.8% of the initialization time \(\)\.
6. 6\.Near\-optimal snapshot sets in less time:The total latency of serving requests calculated from the output of the greedy facility location algorithm used by Readie is 22×\\timeslower, compared to the 12\.7×\\timesreduction by agglomerative Jaccard clustering against having no snapshots at all \(\)\.
## 7Related Work
Our system \(Readie\) takes a different approach compared to existing techniques for faster code execution\.
##### Per\-function snapshots\.
Readie targets unseen code using learned snapshots\. Per\-function snapshot techniques instead require the code in advance: they create a snapshot for each function and restore it when the function is invoked[Silva et al\. \(2020\)](https://arxiv.org/html/2611.22171#bib.bib11)\. Commercial platforms offer such snapshots[Modal Labs \(\)](https://arxiv.org/html/2611.22171#bib.bib13);[Amazon Web Services \(\)](https://arxiv.org/html/2611.22171#bib.bib14), and later work improves their performance[Kohli et al\. \(2024\)](https://arxiv.org/html/2611.22171#bib.bib15);[Shin et al\. \(2022\)](https://arxiv.org/html/2611.22171#bib.bib12)\. Since every function needs its own snapshot, these techniques cannot speed up new code, and their footprint grows with the number of functions\.
##### Sharing states across executions\.
We propose optimized snapshots for container\-level isolation, balancing efficiency and security\. Existing systems share live processes in more heuristic ways\. SOCK[Oakes et al\. \(2018\)](https://arxiv.org/html/2611.22171#bib.bib24)and AFaaS[Chai et al\. \(2025\)](https://arxiv.org/html/2611.22171#bib.bib27)fork requests from live pre\-initialized processes, and SOCK creates these processes greedily for the current invocation\. Forklift[Yang et al\. \(2024\)](https://arxiv.org/html/2611.22171#bib.bib26)organizes such processes into a tree, but builds it greedily by usage frequency\. Pagurus[Li et al\. \(2021\)](https://arxiv.org/html/2611.22171#bib.bib28)reuses idle containers from other functions, sharing whatever happens to be available\. HotSwap[Li et al\. \(2025a\)](https://arxiv.org/html/2611.22171#bib.bib16)keeps dependency images in RAM, built from popular dependency combinations\.
##### Restore time optimizations\.
Readie is orthogonal to other work that speeds up restoration time itself\. SEUSS[Cadden et al\. \(2020\)](https://arxiv.org/html/2611.22171#bib.bib20), Catalyzer[Du et al\. \(2020\)](https://arxiv.org/html/2611.22171#bib.bib21)and Sabre[Lazarev et al\. \(2024\)](https://arxiv.org/html/2611.22171#bib.bib22)accelerate sandbox snapshot restoration, and MITOSIS[Wei et al\. \(2023\)](https://arxiv.org/html/2611.22171#bib.bib23)enables fast distributed forking\. Snapshots are often restored lazily, which causes page faults during execution[Ustiugov et al\. \(2021\)](https://arxiv.org/html/2611.22171#bib.bib17), and REAP[Ustiugov et al\. \(2021\)](https://arxiv.org/html/2611.22171#bib.bib17), FaaSnap[Ao et al\. \(2022\)](https://arxiv.org/html/2611.22171#bib.bib18)and PASS[Pang et al\. \(2024\)](https://arxiv.org/html/2611.22171#bib.bib19)reduce these page faults\.
##### Other cold start optimizations\.
Container runtimes such as SOCK[Oakes et al\. \(2018\)](https://arxiv.org/html/2611.22171#bib.bib24)and RunD[Li et al\. \(2022\)](https://arxiv.org/html/2611.22171#bib.bib25), and Firecracker[Agache et al\. \(2020\)](https://arxiv.org/html/2611.22171#bib.bib7)reduce the overhead of starting and running isolated environments, and could further improve Readie\. Pagurus[Li et al\. \(2021\)](https://arxiv.org/html/2611.22171#bib.bib28)shares warm containers across functions by repacking them based on function similarity, and FaaSLight[Liu et al\. \(2023\)](https://arxiv.org/html/2611.22171#bib.bib29)prunes and lazily loads code that is unlikely to run\. Neither restores imported library state from snapshots, as Readie does\.
## 8Conclusion
We propose Readie, a code sandbox system for agents that significantly reduces the startup latency using a small set of learned memory snapshots\. Readie’s contributions include \(1\) a mathematical model for the sandbox initialization, \(2\) an algorithm that chooses the optimal snapshots under a storage budget, and \(3\) a practical system implementation\. At the same storage budget, Readie initializes sandboxes 6\.3×\\timesfaster than a fat image and 3×\\timesfaster than per\-request snapshots\. The same snapshots are able to reduce initialization time by 18–22×\\timesacross requests in various domains such as data preparation, machine learning, computer vision, and natural language processing\.
## Acknowledgements
This project is supported in part by the NSF grants \#2312561 and \# 2440498, and by resources from the Advanced Cyberinfrastructure Coordination Ecosystem: Services & Support \(ACCESS\) program, which is supported by NSF grants \#2138259, \#2138286, \#2138307, \#2137603, and \#2138296\. Eugene Wu is partially supported by DAPLab corporate support in the form of funding and/or compute from Amazon, IntellectAI, Infosys, Tidalwave, Veris, shopify, Microsoft, Thinking Machines, Dandy, Perplexity, and Daytona\. The views and conclusions presented here are those of the authors and should not be interpreted as representing the official positions of the funding organizations\.
## References
- A\. Agache, M\. Brooker, A\. Iordache, A\. Liguori, R\. Neugebauer, P\. Piwonka, and D\. PopaFirecracker: lightweight virtualization for serverless applications\.In17th USENIX Symposium on Networked Systems Design and Implementation \(NSDI\),Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px4.p1.1)\.
- Agrawal and Srikant \(1994\)R\. Agrawal and R\. SrikantFast algorithms for mining association rules\.InProceedings of the 20th International Conference on Very Large Data Bases \(VLDB\),pp\. 487–499\.Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p4.1)\.
- \[3\]Amazon Web ServicesImproving Startup Performance with Lambda SnapStart\.Note:[https://docs\.aws\.amazon\.com/lambda/latest/dg/snapstart\.html\#snapstart\-runtimes](https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html#snapstart-runtimes)AWS Lambda Developer Guide\. Accessed: 2026\-10\-28Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px1.p1.1)\.
- Aoet al\.\(2022\)L\. Ao, G\. Porter, and G\. M\. VoelkerFaaSnap: faas made fast using snapshot\-based vms\.InProceedings of the Seventeenth European Conference on Computer Systems,EuroSys ’22,New York, NY, USA,pp\. 730–746\.External Links:ISBN 9781450391627,[Link](https://doi.org/10.1145/3492321.3524270),[Document](https://dx.doi.org/10.1145/3492321.3524270)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px3.p1.1)\.
- Brookeret al\.\(2023\)M\. Brooker, M\. Danilov, C\. Greenwood, and P\. PiwonkaOn\-demand container loading in AWS Lambda\.In2023 USENIX Annual Technical Conference \(USENIX ATC\),pp\. 315–328\.Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px2.p1.1)\.
- Caddenet al\.\(2020\)J\. Cadden, T\. Unger, Y\. Awad, H\. Dong, O\. Krieger, and J\. AppavooSEUSS: skip redundant paths to make serverless fast\.InProceedings of the Fifteenth European Conference on Computer Systems,EuroSys ’20,New York, NY, USA\.External Links:ISBN 9781450368827,[Link](https://doi.org/10.1145/3342195.3392698),[Document](https://dx.doi.org/10.1145/3342195.3392698)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px3.p1.1)\.
- Chaiet al\.\(2025\)X\. Chai, T\. Zhou, K\. Hu, J\. Tan, T\. Bie, A\. Shen, D\. Shen, Q\. Xing, S\. Song, T\. Yang, L\. Gao, F\. Yu, Z\. He, D\. Du, Y\. Xia, K\. Chen, and Y\. ChenFork in the road: reflections and optimizations for cold start latency in production serverless systems\.In19th USENIX Symposium on Operating Systems Design and Implementation \(OSDI 25\),Boston, MA, USA,pp\. 499–518\.External Links:ISBN 978\-1\-939133\-47\-2,[Link](https://www.usenix.org/conference/osdi25/presentation/chai-xiaohu)Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p5.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px2.p1.1)\.
- Chockchowwatet al\.\(2023a\)S\. Chockchowwat, Z\. Li, and Y\. ParkTransactional Python for durable machine learning: vision, challenges, and feasibility\.InProceedings of the Seventh Workshop on Data Management for End\-to\-End Machine Learning,pp\. 1–5\.External Links:[Document](https://dx.doi.org/10.1145/3595360.3595855)Cited by:[§5\.1](https://arxiv.org/html/2611.22171#S5.SS1.SSS0.Px2.p1.1)\.
- Chockchowwatet al\.\(2023b\)S\. Chockchowwat, W\. Liu, and Y\. ParkAirIndex: versatile index tuning through data and storage\.Proceedings of the ACM on Management of Data1\(3\),pp\. 1–26\.External Links:[Document](https://dx.doi.org/10.1145/3617308)Cited by:[§4\.2\.1](https://arxiv.org/html/2611.22171#S4.SS2.SSS1.p1.1)\.
- Chockchowwatet al\.\(2025\)S\. Chockchowwat, S\. Thakurdesai, Z\. Li, M\. S\. Krafczyk, and Y\. ParkChipmink: efficient delta identification for massive object graphs\.Proceedings of the VLDB Endowment19\(4\),pp\. 603–616\.External Links:[Document](https://dx.doi.org/10.14778/3785297.3785303)Cited by:[§5\.1](https://arxiv.org/html/2611.22171#S5.SS1.SSS0.Px2.p1.1)\.
- \[11\]cloudpicklecloudpickle: extended pickling support for Python objects\.Note:[https://github\.com/cloudpipe/cloudpickle](https://github.com/cloudpipe/cloudpickle)Accessed: 2026\-10\-30Cited by:[§5\.1](https://arxiv.org/html/2611.22171#S5.SS1.SSS0.Px2.p1.1)\.
- Cornuéjolset al\.\(1977\)G\. Cornuéjols, M\. L\. Fisher, and G\. L\. NemhauserLocation of bank accounts to optimize float: an analytic study of exact and approximate algorithms\.Management Science23\(8\),pp\. 789–810\.Cited by:[§4\.4](https://arxiv.org/html/2611.22171#S4.SS4.p2.1)\.
- \[13\]DaytonaDaytona: secure infrastructure for running AI\-generated code\.Note:[https://www\.daytona\.io](https://www.daytona.io/)Accessed: 2026\-10\-29Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p1.1)\.
- Duet al\.\(2020\)D\. Du, T\. Yu, Y\. Xia, B\. Zang, G\. Yan, C\. Qin, Q\. Wu, and H\. ChenCatalyzer: sub\-millisecond startup for serverless computing with initialization\-less booting\.InProceedings of the Twenty\-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems,ASPLOS ’20,New York, NY, USA,pp\. 467–481\.External Links:ISBN 9781450371025,[Link](https://doi.org/10.1145/3373376.3378512),[Document](https://dx.doi.org/10.1145/3373376.3378512)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px3.p1.1)\.
- \[15\]DuckDuckGoDuckDuckGo\.Note:[https://duckduckgo\.com](https://duckduckgo.com/)Accessed: 2026\-10\-29Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p1.1)\.
- \[16\]E2BE2B: open\-source cloud sandboxes for AI agents\.Note:[https://e2b\.dev](https://e2b.dev/)Accessed: 2026\-10\-29Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p1.1)\.
- Fanget al\.\(2025a\)H\. Fang, S\. Chockchowwat, H\. Sundaram, and Y\. ParkEnhancing computational notebooks with code\+data space versioning\.InProceedings of the 2025 CHI Conference on Human Factors in Computing Systems,pp\. 1–17\.External Links:[Document](https://dx.doi.org/10.1145/3706598.3714141)Cited by:[§5\.1](https://arxiv.org/html/2611.22171#S5.SS1.SSS0.Px4.p1.1)\.
- Fanget al\.\(2025b\)H\. Fang, S\. Chockchowwat, H\. Sundaram, and Y\. ParkLarge\-scale evaluation of notebook checkpointing with AI agents\.InExtended Abstracts of the CHI Conference on Human Factors in Computing Systems,pp\. 1–8\.External Links:[Document](https://dx.doi.org/10.1145/3706599.3719928)Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px2.p2.1)\.
- \[19\]Google CloudWhat is Cloud Run\.Note:[https://docs\.cloud\.google\.com/run/docs/overview/what\-is\-cloud\-run](https://docs.cloud.google.com/run/docs/overview/what-is-cloud-run)Google Cloud Documentation\. Accessed: 2026\-10\-30Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p2.1),[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px2.p1.1)\.
- \[20\]Google ColaboratoryColab backend info: packages installed in the Colab runtime\.Note:[https://github\.com/googlecolab/backend\-info](https://github.com/googlecolab/backend-info)Accessed: 2026\-10\-28Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p2.1),[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px3.p1.1)\.
- \[21\]GooglegVisor: The Container Security Platform\.Note:[https://gvisor\.dev](https://gvisor.dev/)Accessed: 2026\-10\-28Cited by:[§5\.1](https://arxiv.org/html/2611.22171#S5.SS1.SSS0.Px3.p1.1)\.
- Hanet al\.\(2000\)J\. Han, J\. Pei, and Y\. YinMining frequent patterns without candidate generation\.InProceedings of the 2000 ACM SIGMOD International Conference on Management of Data,pp\. 1–12\.Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p4.1)\.
- \[23\]Hugging Face DatasetsDatasets\.Note:[https://huggingface\.co/docs/datasets](https://huggingface.co/docs/datasets)Accessed: 2026\-10\-30Cited by:[§2\.3](https://arxiv.org/html/2611.22171#S2.SS3.SSS0.Px1.p1.1)\.
- \[24\]Hugging FaceHugging Face\.Note:[https://huggingface\.co](https://huggingface.co/)Accessed: 2026\-10\-30Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px2.p2.1)\.
- Jaccard \(1901\)P\. JaccardÉtude comparative de la distribution florale dans une portion des alpes et des jura\.Bulletin de la Société Vaudoise des Sciences Naturelles37\(142\),pp\. 547–579\.Cited by:[§2\.3](https://arxiv.org/html/2611.22171#S2.SS3.p1.1),[§4\.4](https://arxiv.org/html/2611.22171#S4.SS4.SSS0.Px1.p1.1)\.
- \[26\]Kaggle PythonKaggle Python docker image\.Note:[https://github\.com/Kaggle/docker\-python](https://github.com/Kaggle/docker-python)Accessed: 2026\-10\-30Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px3.p1.1),[§5\.2](https://arxiv.org/html/2611.22171#S5.SS2.SSS0.Px1.p1.1)\.
- \[27\]KaggleKaggle\.Note:[https://www\.kaggle\.com](https://www.kaggle.com/)Accessed: 2026\-10\-30Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px2.p2.1)\.
- Kariv and Hakimi \(1979\)O\. Kariv and S\. L\. HakimiAn algorithmic approach to network location problems\. II: the p\-medians\.SIAM Journal on Applied Mathematics37\(3\),pp\. 539–560\.Cited by:[§4\.4](https://arxiv.org/html/2611.22171#S4.SS4.p1.1)\.
- Kaufman and Rousseeuw \(1990\)L\. Kaufman and P\. J\. RousseeuwFinding groups in data: an introduction to cluster analysis\.John Wiley & Sons\.Cited by:[§4\.4](https://arxiv.org/html/2611.22171#S4.SS4.SSS0.Px1.p1.1)\.
- Kohliet al\.\(2024\)S\. Kohli, S\. Kharbanda, R\. Bruno, J\. Carreira, and P\. FonsecaPronghorn: effective checkpoint orchestration for serverless hot\-starts\.InProceedings of the Nineteenth European Conference on Computer Systems,EuroSys ’24,New York, NY, USA,pp\. 298–316\.External Links:ISBN 9798400704376,[Link](https://doi.org/10.1145/3627703.3629556),[Document](https://dx.doi.org/10.1145/3627703.3629556)Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p5.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px1.p1.1)\.
- Lazarevet al\.\(2024\)N\. Lazarev, V\. Gohil, J\. Tsai, A\. Anderson, B\. Chitlur, Z\. Zhang, and C\. DelimitrouSabre: Hardware\-Accelerated snapshot compression for serverless MicroVMs\.In18th USENIX Symposium on Operating Systems Design and Implementation \(OSDI 24\),Santa Clara, CA,pp\. 1–18\.External Links:ISBN 978\-1\-939133\-40\-3,[Link](https://www.usenix.org/conference/osdi24/presentation/lazarev)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px3.p1.1)\.
- Liet al\.\(2025a\)R\. Li, D\. Tiwari, and G\. CoopermanHotSwap: Enabling Live Dependency Sharing in Serverless Computing\.In2025 IEEE 18th International Conference on Cloud Computing \(CLOUD\),Vol\.,Los Alamitos, CA, USA,pp\. 152–162\.External Links:ISSN,[Document](https://dx.doi.org/10.1109/CLOUD67622.2025.00025),[Link](https://doi.ieeecomputersociety.org/10.1109/CLOUD67622.2025.00025)Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p4.1),[§1](https://arxiv.org/html/2611.22171#S1.p5.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px2.p1.1)\.
- Liet al\.\(2025b\)Z\. Li, S\. Chockchowwat, H\. Fang, and Y\. ParkDemo of Kishu: time\-traveling for computational notebooks\.InCompanion of the 2025 International Conference on Management of Data,pp\. 167–170\.External Links:[Document](https://dx.doi.org/10.1145/3722212.3725095)Cited by:[§5\.1](https://arxiv.org/html/2611.22171#S5.SS1.SSS0.Px4.p1.1)\.
- Liet al\.\(2024a\)Z\. Li, S\. Chockchowwat, H\. Fang, R\. Sahu, S\. Thakurdesai, K\. Pridaphatrakun, and Y\. ParkDemonstration of ElasticNotebook: migrating live computational notebook states\.InCompanion of the 2024 International Conference on Management of Data,pp\. 540–543\.External Links:[Document](https://dx.doi.org/10.1145/3626246.3654752)Cited by:[§4\.1](https://arxiv.org/html/2611.22171#S4.SS1.SSS0.Px3.p1.1)\.
- Liet al\.\(2024b\)Z\. Li, S\. Chockchowwat, R\. Sahu, A\. Sheth, and Y\. ParkKishu: time\-traveling for computational notebooks\.Proceedings of the VLDB Endowment18\(4\),pp\. 970–985\.External Links:[Document](https://dx.doi.org/10.14778/3717755.3717759)Cited by:[§5\.1](https://arxiv.org/html/2611.22171#S5.SS1.SSS0.Px4.p1.1)\.
- Liet al\.\(2023a\)Z\. Li, P\. Gor, R\. Prabhu, H\. Yu, Y\. Mao, and Y\. ParkElasticNotebook: enabling live migration for computational notebooks\.Proceedings of the VLDB Endowment17\(2\),pp\. 119–133\.External Links:[Document](https://dx.doi.org/10.14778/3626292.3626296)Cited by:[§4\.1](https://arxiv.org/html/2611.22171#S4.SS1.SSS0.Px3.p1.1)\.
- Liet al\.\(2025c\)Z\. Li, S\. Huang, W\. Ding, Y\. Park, and J\. ChenSIEVE: effective filtered vector search with collection of indexes\.Proceedings of the VLDB Endowment18\(11\),pp\. 4723–4736\.External Links:[Document](https://dx.doi.org/10.14778/3749646.3749725)Cited by:[§4](https://arxiv.org/html/2611.22171#S4.p1.1)\.
- Liet al\.\(2023b\)Z\. Li, X\. Pi, and Y\. ParkS/C: speeding up data materialization with bounded memory\.In2023 IEEE 39th International Conference on Data Engineering \(ICDE\),External Links:[Link](https://ieeexplore.ieee.org/document/10184758)Cited by:[§4](https://arxiv.org/html/2611.22171#S4.p1.1)\.
- Liet al\.\(2021\)Z\. Li, Q\. Chen, and M\. GuoPagurus: eliminating cold startup in serverless computing with inter\-action container sharing\.arXiv preprint arXiv:2108\.11240\.External Links:[Link](https://arxiv.org/abs/2108.11240),[Document](https://dx.doi.org/10.48550/arXiv.2108.11240)Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p5.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px2.p1.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px4.p1.1)\.
- Liet al\.\(2022\)Z\. Li, J\. Cheng, Q\. Chen, E\. Guan, Z\. Bian, Y\. Tao, B\. Zha, Q\. Wang, W\. Han, and M\. GuoRunD: a lightweight secure container runtime for high\-density deployment and high\-concurrency startup in serverless computing\.In2022 USENIX Annual Technical Conference \(USENIX ATC 22\),Carlsbad, CA,pp\. 53–68\.External Links:ISBN 978\-1\-939133\-29\-8,[Link](https://www.usenix.org/conference/atc22/presentation/li-zijun-rund)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px4.p1.1)\.
- Liuet al\.\(2023\)X\. Liu, J\. Wen, Z\. Chen, D\. Li, J\. Chen, Y\. Liu, H\. Wang, and X\. JinFaaSLight: general application\-level cold\-start latency optimization for function\-as\-a\-service in serverless computing\.ACM Transactions on Software Engineering and Methodology32\(5\)\.External Links:[Document](https://dx.doi.org/10.1145/3585007),[Link](https://doi.org/10.1145/3585007)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px4.p1.1)\.
- \[42\]MatplotlibMatplotlib: visualization with Python\.Note:[https://matplotlib\.org](https://matplotlib.org/)Accessed: 2026\-10\-30Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px1.p2.1)\.
- \[43\]Modal LabsMemory Snapshots\.Note:[https://modal\.com/docs/guide/memory\-snapshots](https://modal.com/docs/guide/memory-snapshots)Accessed: 2026\-10\-28Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p2.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px1.p1.1)\.
- \[44\]ModalModal: high\-performance AI infrastructure\.Note:[https://modal\.com](https://modal.com/)Accessed: 2026\-10\-29Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p1.1)\.
- Mozafariet al\.\(2023\)B\. Mozafari, R\. A\. Burcuta, A\. Cabrera, A\. Constantin, D\. Francis, D\. Grömling, A\. Jindal, M\. Konkolowicz, V\. M\. Spac, Y\. Park, R\. R\. Carranzo, N\. Richardson, A\. Roy, A\. Srivastava, I\. Tarte, B\. Westphal, and C\. ZhangMaking data clouds smarter at Keebo: automated warehouse optimization using data learning\.InCompanion of the 2023 International Conference on Management of Data,pp\. 239–251\.External Links:[Document](https://dx.doi.org/10.1145/3555041.3589681)Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px2.p2.1)\.
- \[46\]NLTKNLTK: natural language toolkit\.Note:[https://www\.nltk\.org](https://www.nltk.org/)Accessed: 2026\-10\-30Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px2.p1.1)\.
- \[47\]NumPyNumPy\.Note:[https://numpy\.org](https://numpy.org/)Accessed: 2026\-10\-30Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p2.1)\.
- Oakeset al\.\(2018\)E\. Oakes, L\. Yang, D\. Zhou, K\. Houck, T\. Harter, A\. C\. Arpaci\-Dusseau, and R\. H\. Arpaci\-DusseauSOCK: rapid task provisioning with serverless\-optimized containers\.In2018 USENIX Annual Technical Conference \(USENIX ATC 18\),Boston, MA,pp\. 57–70\.External Links:ISBN 978\-1\-939133\-02\-1,[Link](https://www.usenix.org/conference/atc18/presentation/oakes)Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p5.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px2.p1.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px4.p1.1)\.
- \[49\]OpenCVOpenCV: open source computer vision library\.Note:[https://opencv\.org](https://opencv.org/)Accessed: 2026\-10\-30Cited by:[§2\.3](https://arxiv.org/html/2611.22171#S2.SS3.SSS0.Px1.p1.1)\.
- \[50\]pandaspandas: Python data analysis library\.Note:[https://pandas\.pydata\.org](https://pandas.pydata.org/)Accessed: 2026\-10\-30Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p1.1)\.
- Panget al\.\(2024\)X\. Pang, Y\. Zhang, L\. Liu, D\. Cheng, C\. Xu, and X\. ZhouExpeditious High\-Concurrency MicroVM SnapStart in persistent memory with an augmented hypervisor\.In2024 USENIX Annual Technical Conference \(USENIX ATC 24\),Santa Clara, CA,pp\. 985–998\.External Links:ISBN 978\-1\-939133\-41\-0,[Link](https://www.usenix.org/conference/atc24/presentation/pang)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px3.p1.1)\.
- Parket al\.\(2026\)D\. Park, H\. Franke, D\. G\. Waddington, S\. Sundararaman, and Y\. ParkEfficient iterative retrieval with heterogeneous batching\.InProceedings of the 2026 Conference on Empirical Methods in Natural Language Processing,pp\. 612–626\.External Links:[Link](https://aclanthology.org/2026.emnlp-main.28/)Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px1.p1.1)\.
- Parket al\.\(2017\)Y\. Park, A\. S\. Tajik, M\. Cafarella, and B\. MozafariDatabase learning: toward a database that becomes smarter every time\.InProceedings of the 2017 ACM International Conference on Management of Data,pp\. 587–602\.External Links:[Document](https://dx.doi.org/10.1145/3035918.3064013)Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px2.p2.1)\.
- \[54\]PillowPillow: the friendly PIL fork\.Note:[https://python\-pillow\.org](https://python-pillow.org/)Accessed: 2026\-10\-29Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p1.1)\.
- \[55\]PlotlyPlotly: open source Python graphing library\.Note:[https://plotly\.com/python](https://plotly.com/python)Accessed: 2026\-10\-30Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px1.p1.1)\.
- \[56\]PyTorchPyTorch\.Note:[https://pytorch\.org](https://pytorch.org/)Accessed: 2026\-10\-30Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px2.p1.1),[§2\.3](https://arxiv.org/html/2611.22171#S2.SS3.SSS0.Px1.p1.1)\.
- \[57\]scikit\-learnscikit\-learn: machine learning in Python\.Note:[https://scikit\-learn\.org](https://scikit-learn.org/)Accessed: 2026\-10\-30Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p2.1)\.
- \[58\]seabornseaborn: statistical data visualization\.Note:[https://seaborn\.pydata\.org](https://seaborn.pydata.org/)Accessed: 2026\-10\-30Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px1.p1.1)\.
- \[59\]Sentence TransformersSentence Transformers\.Note:[https://sbert\.net](https://sbert.net/)Accessed: 2026\-10\-30Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px1.p1.1)\.
- Shinet al\.\(2022\)W\. Shin, W\. Kim, and C\. MinFireworks: a fast, efficient, and safe serverless framework using vm\-level post\-jit snapshot\.InProceedings of the Seventeenth European Conference on Computer Systems,EuroSys ’22,New York, NY, USA,pp\. 663–677\.External Links:ISBN 9781450391627,[Link](https://doi.org/),[Document](https://dx.doi.org/10.1145/3492321.3519581)Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p5.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px1.p1.1)\.
- Silvaet al\.\(2020\)P\. Silva, D\. Fireman, and T\. E\. PereiraPrebaking functions to warm the serverless cold start\.InProceedings of the 21st International Middleware Conference,Middleware ’20,New York, NY, USA,pp\. 1–13\.External Links:ISBN 9781450381536,[Link](https://doi.org/10.1145/3423211.3425682),[Document](https://dx.doi.org/10.1145/3423211.3425682)Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p5.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px1.p1.1)\.
- \[62\]TransformersTransformers\.Note:[https://huggingface\.co/docs/transformers](https://huggingface.co/docs/transformers)Accessed: 2026\-10\-30Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px1.p1.1)\.
- \[63\]UMAPUMAP: uniform manifold approximation and projection for dimension reduction\.Note:[https://umap\-learn\.readthedocs\.io](https://umap-learn.readthedocs.io/)Accessed: 2026\-10\-30Cited by:[§2\.1](https://arxiv.org/html/2611.22171#S2.SS1.SSS0.Px1.p1.1)\.
- Ustiugovet al\.\(2021\)D\. Ustiugov, P\. Petrov, M\. Kogias, E\. Bugnion, and B\. GrotBenchmarking, analysis, and optimization of serverless function snapshots\.InProceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems,ASPLOS ’21,New York, NY, USA,pp\. 559–572\.External Links:ISBN 9781450383172,[Link](https://doi.org/10.1145/3445814.3446714),[Document](https://dx.doi.org/10.1145/3445814.3446714)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px3.p1.1)\.
- Weiet al\.\(2023\)X\. Wei, F\. Lu, T\. Wang, J\. Gu, Y\. Yang, R\. Chen, and H\. ChenNo provisioned concurrency: fast RDMA\-codesigned remote fork for serverless computing\.In17th USENIX Symposium on Operating Systems Design and Implementation \(OSDI 23\),Boston, MA,pp\. 497–517\.External Links:ISBN 978\-1\-939133\-34\-2,[Link](https://www.usenix.org/conference/osdi23/presentation/wei-rdma)Cited by:[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px3.p1.1)\.
- Wuet al\.\(2025\)M\. Wu, J\. Jiang, H\. Zheng, M\. Li, Z\. Li, B\. Tian, B\. Chen, Y\. Park, M\. Zhang, C\. Zhai, and K\. NahrstedtCache\-of\-Thought: master\-apprentice framework for cost\-effective vision language model reasoning\.InProceedings of the 2025 Conference on Empirical Methods in Natural Language Processing,pp\. 1895–1909\.External Links:[Document](https://dx.doi.org/10.18653/v1/2025.emnlp-main.97)Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px1.p2.1)\.
- \[67\]XGBoostXGBoost: scalable and flexible gradient boosting\.Note:[https://xgboost\.ai](https://xgboost.ai/)Accessed: 2026\-10\-30Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px1.p2.1)\.
- Xiaet al\.\(2026\)H\. Xia, M\. Pamnani, H\. Fang, S\. Chockchowwat, and Y\. ParkLazyAttention: efficient retrieval\-augmented generation with deferred positional encoding\.InProceedings of the 43rd International Conference on Machine Learning,Proceedings of Machine Learning Research, Vol\.306,pp\. 138219–138238\.External Links:[Link](https://proceedings.mlr.press/v306/xia26f.html)Cited by:[§2\.2](https://arxiv.org/html/2611.22171#S2.SS2.SSS0.Px1.p2.1)\.
- Yanget al\.\(2024\)Y\. Yang, K\. Choi, K\. Chen, and T\. Caraza\-HarterForklift: fitting zygote trees for faster package initialization\.In10th International Workshop on Serverless Computing,WoSC ’24,New York, NY, USA,pp\. 6 pages\.External Links:[Document](https://dx.doi.org/10.1145/3702634.3702952),[Link](https://doi.org/10.1145/3702634.3702952)Cited by:[§1](https://arxiv.org/html/2611.22171#S1.p5.1),[§7](https://arxiv.org/html/2611.22171#S7.SS0.SSS0.Px2.p1.1)\.相似文章
@HowToPrompt__:中国开源了一个沙盒,它:→ 启动只需60毫秒(Docker需要200毫秒)→ 每个实例仅用5MB内存→ 可运行数千…
中国开源了 CubeSandbox,这是一个用于AI智能体的硬件隔离沙盒,冷启动时间低于60毫秒,每个实例仅需5MB内存开销,只需替换一个URL即可替代Docker和E2B。它可以在硬件层面在一台机器上运行数千个智能体。
@TencentAI_News:我们刚刚开源了 Cube Sandbox!一款秒级、并发、安全且轻量的 AI Agent 沙箱运行时。
腾讯开源 Cube Sandbox,一款基于 Rust/KVM 的轻量级 AI Agent 沙箱运行时,冷启动低于 60 ms,单实例内存开销 <5 MB。
适用于智能体的安全沙箱(4分钟阅读)
Perplexity AI 的 SPACE 为AI智能体提供安全的临时沙箱,确保在处理敏感任务时的凭证隔离和加密存储。
高扇出智能体沙箱的内存压缩
AgentZip 是一种专为 AI 智能体沙箱设计的内存压缩系统,通过利用沙箱间的冗余并结合 LLM 等待期进行压缩,可将内存使用量最多减少 8.7 倍。
@Saboo_Shubham_: 沙盒如此出色,你的智能体暂停和恢复的速度比打字还快。兼容 ADK、LangChain、Claude Code、Cod…
重点介绍一个开源沙盒,它能让 AI 智能体快速暂停和恢复,兼容 ADK、LangChain、Claude Code、Codex 及其他框架。