betaFeedback

WorksComputer Science

Readie: Low-Latency Code Sandboxes for AI Agents

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.

Introduction

AI agents rely heavily on code execution. To give financial advice, an agent may call DuckDuckGo to retrieve current mortgage rates and US Treasury yields. To perform quantitative political science research, it may use pandas over government datasets. And to shrink vacation photos before emailing them to family, it may use Pillow 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; E2B; Daytona). 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 (Figure 1-bottom left), (ii) custom snapshots (Figure 1-bottom right), or (iii) a shared fat image (Figure 1-top left). First, services such as Cloud Run (Google Cloud)1 let users build custom container images, and others such as Modal (Modal Labs) 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) platforms use a single fat image of commonly used packages (e.g., NumPy, scikit-learn). 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.

A comparison of code sandbox approaches, with files and memory-state on the horizontal axis and shareable and customized on the vertical axis

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 [2, 23] (Li et al. 2025a). 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 [64, 33, 63] are created in advance for each function, so they are not optimized for new code. State-sharing systems [51, 7, 72] (Li et al. 2021; Li et al. 2025a) 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 (§ 9).

This work makes the following contributions:

  1. We show why existing approaches are poorly suited for agent workloads, and why learned startup snapshots are effective (§ 2).

  2. We present the design of Readie, a practical system that serves requests with learned startup snapshots (§ 3).

  3. We formulate snapshot construction as an optimization problem and present an approximation algorithm that finds a near-optimal set of snapshots (§ 4).

  4. We describe the implementation challenges we addressed in building Readie (§ 5).

  5. We evaluate our system (Readie) on 15K scripts: it reduces both startup latency and end-to-end time (§ 6).

Finally, we discuss related work (§ 9) and conclude (§ 10).

Motivation

This section discusses why existing sandboxes start slowly (§ 2.1), our intuition for using only a few snapshots to serve a large number of requests (§ 2.2), and the characteristics of agent-generated workloads that enable it (§ 2.3).

Why 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.

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 (see § 6.1 and § 8.2 for 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 (Figure 2). An agent requests new packages after its first turn because it decides each step only after seeing the previous step’s output [55]. The session drawn in solid-blue in Figure 2 first classifies the sentiment of product reviews with Transformers, pandas, and seaborn. It then embeds the reviews (Sentence Transformers, UMAP), plots them (Plotly), and finally models their topics (scikit-learn).

New packages requested by agent sessions

Figure 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).

Using a custom image for each execution. Services such as Cloud Run (Google Cloud) and AWS Lambda [5] 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 and NLTK 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 (Figure 3a). 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.

Time to initialize and import packages in a custom image. Download, Decompress + write, and Start + import times are shown for the Base layer (Debian), Python runtime layer, Custom layer (pip installs), and Start + import.

(a) Time to initialize and import packages in a custom image

Time to import a package across different methods. Source, Bytecode, and Restore are compared for pandas, torch, and nltk.

(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.

Using one fat image for all executions. Notebook services such as Colab (Google Colaboratory) 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 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 (Figure 3b). 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.

Missed 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 snapshot SiS_i contains artifacts a1a_1, a2a_2, and a3a_3, and a request RjR_j requires a1a_1 and a4a_4. Then, serving RjR_j with SiS_i incurs the cost of loading a1a_1 from the snapshot (fast) and downloading a4a_4 (slow). We call the missing artifacts, Rj∖Si={a4}R_j \setminus S_i = \{a_4\}, the residuals.

Figure 4 contrasts per-request snapshots (Figure 4a) with a single snapshot shared across requests (Figure 4b). 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., [71]; Wu et al. (2025)). For example, a 32 MB snapshot containing NumPy, pandas, scikit-learn and Matplotlib fully covers R1R_1–R3R_3, which incur no additional load time. Requests R4R_4 and R5R_5 must also load their residuals, seaborn and XGBoost, 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×5\times at the cost of only 1 s of additional load time in total.

One snapshot per request: five requests R1–R5 use progressively larger snapshots containing package layers; 162 MB total snapshot size.

(a) One snapshot per request: 162 MB total snapshot size

A snapshot shared across requests: a shared snapshot is reused by requests R1–R5, with residual imports for packages not present in the shared snapshot; 32 MB total snapshot size.

(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.

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 Figure 4b, for example, including NumPy and pandas in a snapshot is an easy choice, since R1R_1–R5R_5 all require them. Whether to also include scikit-learn, however, depends on the workload. If R1R_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 [56, 48]. 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, Hugging Face) and synthesize more with frontier large language models [18]. 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.

Characteristics of Workloads

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 (§ 6.1) by the set of packages it imports, cluster these sets by Jaccard distance [27] 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 (Figure 5). 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.

Figure 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.

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 and torchvision (PyTorch) (orange); and Transformers, Hugging Face Datasets and PyTorch (green). Of the 9,325 requests in Figure 5, c1c_1 serves 83%, and c2c_2 and c3c_3 serve 9% and 7%. Only 1,731 of c1c_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, as c2c_2 does, serves 853.

Overlaps create trade-offs and redundancy. The request {Matplotlib, NumPy, pandas, scikit-learn, PyTorch} lies where c1c_1 and c3c_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 than c1c_1. Overlaps also make snapshots redundant: c2c_2 holds all of c1c_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).

System Overview

This section covers Readie’s components and the path taken when a code execution is requested (Figure 6).

Architecture of our system (Readie)

Figure 6. Architecture of our system (Readie). Our core contribution is to use a small number of learned snapshots.

Readie 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) from historical requests (the training data), solves an optimization problem (§ 4.4) to select a small set of snapshots, and builds and stores them on disk.

Readie Workflow

A request goes through three steps, from the client to its execution on Readie (Figure 6). (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), 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.

Determining 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; 2023b).

Serving a Request with a Snapshot

Packages and their properties. Let PP be the union of all packages requested in the historical requests. Each package p∈Pp \in P has 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. For a set of packages XX, we write X‾\overline{X} for its closure, i.e., XX together with all its transitive dependencies.

Request. A request is a function call, where rr is a set of packages it imports. Importing rr loads its closure, so in practice the request needs the packages Dr=r‾D_r = \overline{r}.

Snapshot. A snapshot represents a sandbox which was checkpointed after importing a set of packages cc (Li et al., 2023a; 2024a). Again, importing cc loads its closure, so in practice the snapshot contains the packages Dc=c‾D_c = \overline{c}. The size of a snapshot is the total memory that the packages DcD_c hold, S(c)=∑p∈DcmpS(c) = \sum_{p \in D_c} m_p.

Initialization Time

Restore Time for a Snapshot

Restoring a snapshot takes (1) a constant time tbaset_{\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), where α\alpha is 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 (Figure 7). The slope of the fitted line is α\alpha, and the YY-intercept is tbaset_{\mathrm{base}}. In our experiment, the fitted line has slope α=0.0031\alpha= 0.0031 s/MB and intercept tbase=0.32t_{\mathrm{base}} = 0.32 s, which is consistent with the restore time having a constant component and a component that grows linearly with the snapshot size.

Restore time against snapshot size for 50 snapshots

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 α\alpha and its intercept is tbaset_{\mathrm{base}}.

Residual Import Time

The residual import time accounts for the import time of the packages that a request rr needs and a snapshot cc lacks. Since package dependencies are not mutually exclusive, it is possible that the snapshot closure DcD_c already contains some of the dependencies from the request closure DrD_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. Thus, the total initialization time of a request rr served from snapshot cc is 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 request rr arrives, the snapshot cc with the lowest initialization time (T(r,c)T(r,c)) among all planned snapshots is selected to serve the request, as shown in Figure 8. tbaset_{\mathrm{base}} is left out since it is the same for every snapshot.

Selecting a snapshot for a request

Figure 8. Selecting a snapshot for a request rr. 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. Snapshot c2c_2 needs no residual imports, but it holds PyTorch, which rr does not use, and is the slowest to restore. Snapshot c3c_3 lacks Matplotlib yet has the lowest total time, so it is selected.

Defining the Optimization Problem

The objective is to select a set of snapshots CC subject to the storage budget BB (MB), which minimizes the total initialization time on a set of requests RR, when each request in RR is served by exactly one of the snapshots in CC:

F(C)=∑r∈Rmin⁡c∈CT(r,c)s.t.∑c∈CS(c)≤B(1)\mathcal{F}(C) = \sum_{r \in R} \min_{c \in C} T(r,c) \qquad\text{s.t.} \qquad\sum_{c \in C} S(c) \le B \tag*{(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.

Solving 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 NP-hard ([31]). 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) 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 customer rr to a facility cc is T(r,c)T(r,c), which is the asymmetric distance that we want to minimize. The cost to open a facility is S(c)S(c), and the total cost of all open facilities must not exceed the budget BB. Every customer (request) is assigned to an open facility (snapshot). Readie solves it with a greedy algorithm for facility location ([12]) which, at each step, adds the candidate that fits in the remaining budget and reduces the weighted total of Eq. (1) the most. It stops when no candidate fits the budget or lowers the total. The time complexity of the algorithm is O(KN2)O(KN^2) with a space complexity of O(N2+NP)O(N^2 + NP), where NN is the number of candidates (here requests), PP the number of packages and KK the number of snapshots chosen.

Alternative algorithm considerations. The budgeted facility location MILP provides an optimal solution, but its solve time grows exponentially with the number of distinct sets and packages in the worst case. Greedy knapsack ranks candidates once by the import time they save and takes them while they fit in the budget, ignoring what earlier picks already cover. k-medoids ([32]) 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 ([27]) 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. § 8.4 evaluates all the above algorithms on the planning and validation sets.

Implementation and Discussion

This section describes Readie’s implementation (§ 5.1) and design considerations (§ 5.2).

Implementation

Metadata generation. For each package, Readie imports it in a fresh interpreter and records the modules the import adds to sys.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 remote decorator serializes the function and its arguments with cloudpickle ((cloudpickle; Chockchowwat et al., 2025; 2023a)), 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)) 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 ([17] (Li et al. 2024b; Li et al. 2025b)).

Design 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 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) assumes that the packages in Dc∖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 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.

Experimental 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. Low initialization time: At the same storage budget of 15 GB, Readie initializes a sandbox 3×3\times faster than using per-request snapshots with caching and 6.3×6.3\times faster than using a fat image (§ 7).

  2. Per-request latency at a fraction of the storage: Readie matches the initialization time of using per-request snapshots, with 14×14\times less storage (§ 8).

  3. Robust to unseen workloads: In an out-of-distribution set, generated without knowledge of the requests Readie plans on, Readie still initializes 2×2\times faster than its per-request snapshots (§ 8.1).

  4. Faster agent sandbox execution: In agent sandbox executions tested on different agent benchmarks, Readie cuts initialization time by 9.1×9.1\times and end-to-end time by 1.3×1.3\times against each benchmark’s provided sandbox environment (§ 8.2).

  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 (§ 8.3).

  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×22\times lower, compared to the 12.7×12.7\times reduction by agglomerative Jaccard clustering against having no snapshots at all (§ 8.4).

Experiment Setup

Data. We have constructed our dataset using requests from seven sources (Table 1): code snippets and notebooks generated by LLMs, sessions in which an agent debugs failing code, and snippets and notebooks from Kaggle and Hugging Face. They span 16 data science domains, such as exploratory data analysis, machine learning, computer vision, natural language processing, etc., each having an equal weight. (Planning set) Only the planning set is used by Readie to plan the ideal snapshots. (Validation set) The validation set is used to compare algorithms (§ 8.4) and to choose the storage budget for snapshots, past which more storage brings little further reduction in initialization time. (Test set) This is a held-out set from the same distribution as the planning and validation sets on which evaluations

SourcePlanValTest
LLM generated snippets2,890110601
LLM generated notebooks2,794218457
Agent debugging sessions2,947531177
Kaggle snippets2,108332140
Kaggle notebooks3,350492145
Hugging Face snippets7226828
Hugging Face notebooks4887011
Total15,2991,8211,559

Table 1. Count of requests from each source in each dataset. The out-of-distribution set is randomly generated and does not contain any source information.

are run. (Out-of-distribution set) Another set used for evaluations with the difference being that it is generated by a different agent with random sources and no knowledge of the requests in the other sets.

Metrics. Each request runs in a fresh sandbox. A request’s initialization time is the time from provisioning until its sandbox has loaded every module the request imports. Without a snapshot, it is the total time to provision the sandbox, start the interpreter and import every module from disk, after first installing any missing packages, which is also the cold start time. With a snapshot, it is the time to provision the sandbox, fetch the snapshot from a local disk or remote cache, restore the snapshot, and install and import the residual modules the snapshot lacks. The end-to-end time is the initialization time plus the time to run the request’s code, step by step, in that sandbox.

Methods. We compare Readie with three commonly used methods to initialize a sandbox:

  • No snapshots: The environment is built on demand, as installing a request’s dependencies at startup. Every sandbox starts from a python:3.12 image, which has Python and no installed packages. When a request arrives, the required packages are installed using pip in its sandbox and then imported. Nothing is stored for a request, and every request pays both installation and import.

  • Fat image: One large image with the packages of almost every request pre-installed, which every sandbox shares, as notebook services do. We use the Kaggle Python 3.12 image (Kaggle Python). A request does not install anything, but its new interpreter still imports every package it needs from disk.

  • Per-request snapshots: Each snapshot is a sandbox that has imported exactly one distinct set of modules, so a request restores the snapshot of its own set and has nothing left to import. Covering the test and out-of-distribution sets takes 1,308 snapshots and 279 GB.

  • Readie (ours): A set of snapshots planned by our greedy facility location algorithm (§ 4.4) on the planning set and at runtime the router picks the snapshot with the lowest T(r,c)T(r,c) to serve each request and imports the residual.

Environment. Experiments run on an Ubuntu server with 2 AMD EPYC 7552 48-core processors and 1 TB RAM. Each sandbox is run using gVisor and is provided with 8 GB RAM and runs on its own 8 cores. Readie keeps every snapshot on the host, because the 33 shared snapshots fit in the storage budget while all of the 1,308 per-request snapshots do not. Readie also cuts down end-to-end time to 2.96 h against 9.85 h, 4.73 h and 3.88 h.

Low Initialization Time

This section compares the time taken by each method to initialize a sandbox, at the same storage budget of 15 GB, on the test set. Per-request at a 15 GB budget keeps an LRU cache of 8 GB of snapshots on the host, next to the 7 GB of packages they load on disk. The other snapshots live in an object store, and a miss fetches one with 20 ms of latency at 100 MB/s. Readie plans with a 10 GB budget, which gives 33 snapshots on the python:3.12 image, next to the 5 GB of packages they load on disk, 15 GB in all.

We report results in Figure 9 and Table 2. Readie spends 0.33 h initializing the 1,535 requests, which is 22× less than installing packages per request and importing them (7.31 h), 6.3× less than the fat image (2.07 h) and 3× less than per-request snapshots (0.98 h). The fat image avoids installation costs but still imports every package from disk. Per-request snapshots skip the imports, but the 8 GB cache holds a small share of their 279 GB, so most requests first fetch their snapshot from the object store.

Distribution of initialization and end-to-end time for the test set

Figure 9. Distribution of (a) the initialization time and (b) the end-to-end time of the 1,535 requests in the test set, with every method under the same 15 GB storage budget. Each histogram shows the percentage of requests in each time bin on a log scale, and the table beside it gives each method’s p50 and p99. Most requests initialize in under a second with Readie, against a few seconds with the fat image and per-request snapshots and over ten seconds with no snapshots, and the gap carries over to the end-to-end time.

MethodTotal init (h)Total E2E (h)
No snapshots7.319.85
Fat image2.074.73
Per-request0.983.88
Readie (ours)0.332.96

Table 2. Total initialization and end-to-end time on the test set. The storage budget is set to 15 GB for all methods.

Per-Request Latency at a Fraction of the Storage

This section compares the two methods on the test set without any storage constraints: Readie with 61 snapshots planned at a 20 GB storage budget against per-request snapshots with every snapshot on the host (279 GB).

We report results in Table 3. With every snapshot on the host, per-request snapshots give the lowest initialization time any snapshot can, since each request restores exactly the packages it needs. Readie matches it, 0.22 h against 0.23 h, at 14× less storage.

MethodTotal init (h)Total E2E (h)
Per-request0.233.13
Readie (ours)0.222.48

Table 3. Total initialization and end-to-end time on the test set without any storage constraints.

Robust to Unseen Workloads

This section compares the same methods as in § 7 on the out-of-distribution set, generated without the knowledge of the requests Readie plans on. Readie serves it with the snapshots it planned using the planning set, and installs or imports any residual packages. We give each unseen request its own snapshot, a hypothetical case (Per-request in § 7), since a platform cannot snapshot code before it sees it. We report results in Figure 10 and Table 4. Readie initializes the 832 requests in 0.43 h, which is 2× less than even the per-request snapshots (0.87 h), 3.3× less than the fat image and 10.7× less than having no snapshots or packages installed. Its end-to-end time is 1.07 h, against 1.69 h, 3.74 h and 6.28 h. Readie’s mean initialization grows from 0.77 s on the test set to 1.86 s on the out-of-distribution set, and its p95 from 1.57 s to 7.07 s on the same sets.

Distribution of initialization and end-to-end time for the out-of-distribution set

Figure 10. Distribution of (a) the initialization time and (b) the end-to-end time of the 832 requests in the out-of-distribution set, which Readie did not see when it planned its snapshots. Each histogram shows the percentage of requests in each time bin on a log scale, and the table beside it gives each method’s p50 and p99. Per-request snapshots are an optimistic, hypothetical baseline here, as each unseen request is given its own snapshot. Readie still initializes most requests in under a second and has the lowest p50 and p99 for both metrics.

MethodTotal init (h)Total E2E (h)
No snapshots4.596.28
Fat image1.403.74
Per-request0.871.69
Readie (ours)0.431.07

Table 4. Total initialization and end-to-end time on the out-of-distribution set.

Faster Agent Sandbox Execution

This section measures how much faster an agent can complete the tasks of a benchmark by executing its code on Readie compared to the sandbox environment its benchmark provides. Every turn in which an agent runs code waits for its sandbox, so a faster sandbox shortens each task.

Benchmarks. DA-Code (Huang et al., [25]) tests an agent on data analysis tasks, from data wrangling to machine learning. DSBench (Jing et al., [28]) contains data processing and analysis questions and Kaggle-style modeling tasks. InfiAgent (Hu et al., 2024) asks closed-form questions about a CSV file, which involve short code snippets.

Each benchmark provides a sandbox environment, which we reproduce on a python 3.12 image with the packages it lists pre-installed: 16 for DA-Code, 12 for DSBench and 5 for InfiAgent. We record one trajectory per task with Claude Haiku 5.5 as the agent on 419 of DA-Code’s, 408 of DSBench’s, and 257 of InfiAgent’s tasks and then replay its code step by step in both sandboxes. Since the replay runs the same code, the outputs and the pass rate are unaffected. We report results in Figure 11. Across the three benchmarks, Readie reduces initialization from 1.23 h to 0.14 h (9.1×) and end-to-end time from 4.40 h to 3.35 h (1.3×). The gain is largest on InfiAgent, 16× in initialization and 13× end-to-end, where the initialization time dominates due to shorter tasks. On DA-Code and DSBench, the agent runs longer code, so the initialization times of 0.45 h and 0.28 h that Readie saves shorten the end-to-end times by 1.2×.

Total end-to-end time over the tasks of each agent benchmark in its provided sandbox and in Readie

Figure 11. Total end-to-end time over the tasks of each agent benchmark, in its provided sandbox and in Readie (ours).

Optimized for Data Science Workflows

This section shows how Readie’s planned snapshots serve every data science domain with minimal residual import time. We classify the 16 domains in the test set into eight groups, and for each group, visualize the theoretical latency savings and residual import times on Readie against a cold start based on the cost model in § 4.2. All restore and import times are derived from the metadata generated in § 5.1. We report results in Figure 12. Readie reduces the initialization time of requests in each group by 18–22×, and of the test set as a whole from 52,882 s to 2,596 s (20×). Restoring the snapshot and importing the residual together take 4.6–5.6% of cold start time. The residual import time is 255 s of the 2,596 s initialization time over the whole test set.

Total initialization time of the requests for each benchmark group

Figure 12. Total initialization time of the requests (using the cost model) for each group on the test set: cold start times against the times of Readie (ours), split into snapshot restore/clone time and residual import time.

Near-Optimal Snapshot Sets in Less Time

This section compares the greedy facility location algorithm of Readie with other algorithms (§ 4.4) to select snapshot sets, in terms of the overall latency reduction across requests and time taken by the algorithm with increasing requests. For the latency reduction, each algorithm runs on the planning set at budgets from 1 GB to 20 GB and generates snapshot sets. The same snapshot sets are then priced on both the planning and validation sets according to the cost model in § 4.2. MILP, which provides the optimal solution, did not resolve within a time limit of 1 hour even for 100 data points when using a CBC solver (Forrest & Lougee-Heimer, [19]) and hence is not considered in this comparison.

We report results for the latency reduction in Figure 13a and Figure 13b. The total cold start time is 128 h on the planning set and 16.4 h on the validation set. At a 10 GB budget, the greedy facility location algorithm brings this to 5.5 h and 0.74 h respectively, which is 23×23 \times and 22×22 \times less. The kk-medoids local search improves on the greedy algorithm by at most 7% on the planning set, and on the validation set the greedy plan is within 9% of the kk-medoids plan at every budget and better at the 1 GB and 4 GB budgets. Greedy knapsack spends its budget on closures that overlap the ones it already holds, so its latency does not fall steadily as the budget grows. Agglomerative Jaccard groups sets that share packages, but its unions carry packages that only a few members import, which it pays to restore.

Total time to serve requests and planning time

Figure 13. Total time to serve the requests of (a) the planning set and (b) the validation set at different storage budgets and (c) the increase in planning time as the number of data points grows.

The greedy facility location algorithm is also fast to run (Figure 13c). It plans all 15,299 requests in the planning set in 139 s, 2.1×2.1 \times faster than kk-medoids (299 s) and agglomerative Jaccard clustering (295 s). kk-medoids’ improvement of at most 7% does not justify twice the runtime, and only greedy knapsack is faster (66 s), but outputs 2.2×2.2 \times more latency than the greedy facility location.

Related 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 ([64]). Commercial platforms offer such snapshots (Modal Labs; Amazon Web Services), and later work improves their performance (Kohli et al., [33]; Shin et al., [63]). 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., [51]) and AFAas (Chai et al., [7]) fork requests from live pre-initialized processes, and SOCK creates these processes greedily for the current invocation. Forklift (Yang et al., [72]) organizes such processes into a tree, but builds it greedily by usage frequency. Pagurus (Li et al., 2021) reuses idle containers from other functions, sharing whatever happens to be available. HotSwap (Li et al., 2025a) 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., [6]), Catalyzer (Du et al., 2020) and Sabre (Lazarev et al., [34]) accelerate sandbox snapshot restoration, and MITOSIS (Wei et al., [68]) enables fast distributed forking. Snapshots are often restored lazily, which causes page faults during execution (Ustiugov et al., [67]), and REAP (Ustiugov et al., [67]), FaaSnap (Ao et al., 2022) and PASS (Pang et al., [54]) reduce these page faults.

Other cold start optimizations. Container runtimes such as SOCK (Oakes et al., [51]) and RunD (Li et al., 2022), and Firecracker (Agache et al., [1]) reduce the overhead of starting and running isolated environments, and could further improve Readie. Pagurus (Li et al., 2021) shares warm containers across functions by repacking them based on function similarity, and FaaSLight (Liu et al., [44]) prunes and lazily loads code that is unlikely to run. Neither restores imported library state from snapshots, as Readie does.

Conclusion

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×6.3\times faster than a fat image and 3×3\times faster than per-request snapshots. The same snapshots are able to reduce initialization time by 18–22× across 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

  1. [1]Agache, A., Brooker, M., Iordache, A., Liguori, A., Neugebauer, R., Piwonka, P., and Popa, D.-M. Firecracker: Lightweight virtualization for serverless applications. In 17th USENIX Symposium on Networked Systems Design and Implementation (NSDI), 2020.
  2. [2]Agrawal, R. and Srikant, R. Fast algorithms for mining association rules. In Proceedings of the 20th International Conference on Very Large Data Bases (VLDB), pp. 487–499, 1994.
  3. [5]Brooker, M., Danilov, M., Greenwood, C., and Piwonka, P. On-demand container loading in AWS Lambda. In 2023 USENIX Annual Technical Conference (USENIX ATC), pp. 315–328, 2023.arxiv.org/abs/2305.13162
  4. [6]Cadden, J., Unger, T., Awad, Y., Dong, H., Krieger, O., and Appavoo, J. Seuss: skip redundant paths to make serverless fast. In Proceedings of the Fifteenth European Conference on Computer Systems, EuroSys ’20, New York, NY, USA, 2020. Association for Computing Machinery. ISBN 9781450368827. doi: 10.1145/3342195.3392698. URL https://doi.org/10.1145/3342195.3392698.
  5. [7]Chai, X., Zhou, T., Hu, K., Tan, J., Bie, T., Shen, A., Shen, D., Xing, Q., Song, S., Yang, T., Gao, L., Yu, F., He, Z., Du, D., Xia, Y., Chen, K., and Chen, Y. Fork in the road: Reflections and optimizations for cold start latency in production serverless systems. In 19th USENIX Symposium on Operating Systems Design and Implementation (OSDI 25), pp. 499–518, Boston, MA, USA, 2025. USENIX Association. ISBN 978-1-939133-47-2. URL https://www.usenix.org/conference/osdi25/presentation/chai-xiaohu.
  6. [12]Cornuéjols, G., Fisher, M. L., and Nemhauser, G. L. Location of bank accounts to optimize float: An analytic study of exact and approximate algorithms. Management Science, 23(8):789–810, 1977.
  7. [17]Fang, H., Chockchowwat, S., Sundaram, H., and Park, Y. Enhancing computational notebooks with code+data space versioning. In Proceedings of the 2025 CHI Conference on Human Factors in Computing Systems, pp. 1–17, 2025a. doi: 10.1145/3706598.3714141.DOI
  8. [18]Fang, H., Chockchowwat, S., Sundaram, H., and Park, Y. Large-scale evaluation of notebook checkpointing with AI agents. In Extended Abstracts of the CHI Conference on Human Factors in Computing Systems, pp. 1–8, 2025b. doi: 10.1145/3706599.3719928.DOI
  9. [19]Forrest, J. and Lougee-Heimer, R. CBC user guide. INFORMS Tutorials in Operations Research, 2005.
  10. [23]Han, J., Pei, J., and Yin, Y. Mining frequent patterns without candidate generation. In Proceedings of the 2000 ACM SIGMOD International Conference on Management of Data, pp. 1–12, 2000.
  11. [25]Huang, Y., Luo, J., Yu, Y., Zhang, Y., Lei, F., Wei, Y., He, S., Huang, L., Liu, X., Zhao, J., and Liu, K. DA-Code: Agent data science code generation benchmark for large language models. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2024.
  12. [27]Jaccard, P. Étude comparative de la distribution florale dans une portion des alpes et des jura. Bulletin de la Société Vaudoise des Sciences Naturelles, 37(142):547–579, 1901.
  13. [28]Jing, L., Huang, Z., Wang, X., Yao, W., Yu, W., Ma, K., Zhang, H., Du, X., and Yu, D. DSBench: How far are data science agents from becoming data science experts? In The Thirteenth International Conference on Learning Representations (ICLR), 2025.arxiv.org/abs/2409.07703
  14. [31]Kariv, O. and Hakimi, S. L. An algorithmic approach to network location problems. II: The p-medians. SIAM Journal on Applied Mathematics, 37(3):539–560, 1979.DOI
  15. [32]Kaufman, L. and Rousseeuw, P. J. Finding Groups in Data: An Introduction to Cluster Analysis. John Wiley & Sons, 1990.
  16. [33]Kohli, S., Kharbanda, S., Bruno, R., Carreira, J., and Fonseca, P. Pronghorni: Effective checkpoint orchestration for serverless hot-starts. In Proceedings of the Nineteenth European Conference on Computer Systems, EuroSys ’24, pp. 298–316, New York, NY, USA, 2024. Association for Computing Machinery. ISBN 9798400704376. doi: 10.1145/3627703.3629556. URL https://doi.org/10.1145/3627703.3629556.
  17. [34]Lazarev, N., Gohil, V., Tsai, J., Anderson, A., Chitlur, B., Zhang, Z., and Delimitrou, C. Sabre: Hardware-Accelerated snapshot compression for serverless MicroVMs. In 18th USENIX Symposium on Operating Systems Design and Implementation (OSDI 24), pp. 1–18, Santa Clara, CA, July 2024. USENIX Association. ISBN 978-1-939133-40-3. URL https://www.usenix.org/conference/osdi24/presentation/lazarev.
  18. [44]Liu, X., Wen, J., Chen, Z., Li, D., Chen, J., Liu, Y., Wang, H., and Jin, X. Faaslight: General application-level cold-start latency optimization for function-as-a-service in serverless computing. ACM Transactions on Software Engineering and Methodology, 32(5), 2023. doi: 10.1145/3585007. URL https://doi.org/10.1145/3585007.
  19. [48]Mozafari, B., Burcuta, R. A., Cabrera, A., Constantin, A., Francis, D., Grömling, D., Jindal, A., Konkolowicz, M., Spac, V. M., Park, Y., Carranzo, R. R., Richardson, N., Roy, A., Srivastava, A., Tarte, I., Westphal, B., and Zhang, C. Making data clouds smarter at Keebo: Automated warehouse optimization using data learning. In Companion of the 2023 International Conference on Management of Data, pp. 239–251, 2023. doi: 10.1145/3555041.3589681.DOI
  20. [51]Oakes, E., Yang, L., Zhou, D., Houck, K., Harter, T., Arpaci-Dusseau, A. C., and Arpaci-Dusseau, R. H. SOCK: Rapid task provisioning with serverless-optimized containers. In 2018 USENIX Annual Technical Conference (USENIX ATC 18), pp. 57–70, Boston, MA, July 2018. USENIX Association. ISBN 978-1-939133-02-1. URL https://www.usenix.org/conference/atc18/presentation/oakes.
  21. [54]Pang, X., Zhang, Y., Liu, L., Cheng, D., Xu, C., and Zhou, X. Expeditious High-Concurrency MicroVM SnapStart in persistent memory with an augmented hypervisor. In 2024 USENIX Annual Technical Conference (USENIX ATC 24), pp. 985–998, Santa Clara, CA, July 2024. USENIX Association. ISBN 978-1-939133-41-0. URL https://www.usenix.org/conference/atc24/presentation/pang.
  22. [55]Park, D., Franke, H., Waddington, D. G., Sundararaman, S., and Park, Y. Efficient iterative retrieval with heterogeneous batching. In Proceedings of the 2026 Conference on Empirical Methods in Natural Language Processing, pp. 612–626, 2026. URL https://aclanthology.org/2026.emnlp-main.28/.arxiv.org/abs/2609.25405
  23. [56]Park, Y., Tajik, A. S., Cafarella, M., and Mozafari, B. Database learning: Toward a database that becomes smarter every time. In Proceedings of the 2017 ACM International Conference on Management of Data, pp. 587–602, 2017. doi: 10.1145/3035918.3064013.DOI
  24. [63]Shin, W., Kim, W.-H., and Min, C. Fireworks: A fast, efficient, and safe serverless framework using vm-level post-jit snapshot. In Proceedings of the Seventeenth European Conference on Computer Systems, EuroSys ’22, pp. 663–677, New York, NY, USA, 2022. Association for Computing Machinery. ISBN 9781450391627. doi: 10.1145/3492321.3519581. URL https://doi.org/10.1145/3492321.3519581.
  25. [64]Silva, P., Fireman, D., and Pereira, T. E. Prebaking functions to warm the serverless cold start. In Proceedings of the 21st International Middleware Conference, Middleware ’20, pp. 1–13, New York, NY, USA, 2020. Association for Computing Machinery. ISBN 9781450381536. doi: 10.1145/3423211.3425682. URL https://doi.org/10.1145/3423211.3425682.
  26. [67]Ustiugov, D., Petrov, P., Kogias, M., Bugnion, E., and Grot, B. Benchmarking, analysis, and optimization of serverless function snapshots. In Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS ’21, pp. 559–572, New York, NY, USA, 2021. Association for Computing Machinery. ISBN 9781450383172. doi: 10.1145/3445814.3446714. URL https://doi.org/10.1145/3445814.3446714.
  27. [68]Wei, X., Lu, F., Wang, T., Gu, J., Yang, Y., Chen, R., and Chen, H. No provisioned concurrency: Fast RDMAdesigned remote fork for serverless computing. In 17th USENIX Symposium on Operating Systems Design and Implementation (OSDI 23), pp. 497–517, Boston, MA, July 2023. USENIX Association. ISBN 978-1-939133-34-2. URL https://www.usenix.org/conference/osdi23/presentation/wei-rdma.arxiv.org/abs/2203.10225
  28. [71]Xia, H., Pamnani, M., Fang, H., Chockchowwat, S., and Park, Y. LazyAttention: Efficient retrieval-augmented generation with deferred positional encoding. In Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research, pp. 138219–138238. PMLR, 2026. URL https://proceedings.mlr.press/v306/xia26f.html.arxiv.org/abs/2606.04302
  29. [72]Yang, Y., Choi, K., Chen, K., and Caraza-Harter, T. Forklift: Fitting zygote trees for faster package initialization. In 10th International Workshop on Serverless Computing, WoSC ’24, pp. 6 pages, New York, NY, USA, 2024. Association for Computing Machinery. doi: 10.1145/3702634.3702952. URL https://doi.org/10.1145/3702634.3702952.

Paper details

vlnc:W_banjqekv
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents