Most edge compute evaluations start in the wrong place. Someone measures time-to-first-byte from a few cities, sees a smaller number than their single-region origin produced, and concludes the platform works. Then they try to deploy the actual application and discover that the image resizing library will not load, the Postgres driver cannot open a socket, and the PDF generator needs a filesystem that does not exist.
The useful question is not which edge platform is fastest. Latency differences between the serious networks are real but small, and they are swamped by whether your request has to cross an ocean to reach a database anyway. The useful question is which subset of your code the runtime will actually execute, because the edge is not a smaller server. It is a different execution model with a different set of things missing, and every platform below draws the missing line in a slightly different place.
There are really two families here. One runs V8 isolates: a single JavaScript engine process hosting thousands of tenant sandboxes, started in the time it takes to parse your bundle, with no process, no filesystem and no native code. The other runs WebAssembly modules, which is a stricter sandbox with an even narrower syscall surface and a different set of language options. A third thing gets marketed as edge and is not: full container or microVM workloads pinned to several regions, which is regional compute with good placement and belongs in a different article.
This piece is mostly about the constraints. If you know precisely what each runtime refuses to run, choosing between them takes an afternoon rather than a quarter.
Key takeaways
- Isolate runtimes have no filesystem, no child processes, no raw TCP by default, and no native modules. Any npm package with a compiled
.nodebinary is out, permanently, not pending a compatibility flag.- Cloudflare Workers limits and bills CPU time, not wall-clock time. Waiting on a slow upstream costs nothing. A tight loop over a large array costs everything. Lambda and most container platforms are the opposite.
node:builtin coverage is the real compatibility metric. Ask which builtins are present and whether the present ones are complete or a shim, because a partialnode:cryptobreaks libraries in ways a missing one does not.- WebAssembly widens the language choice and narrows the API surface. It is a compilation target available on several of these platforms, not a platform you buy.
The four constraints that decide everything
Every rejection you will hit at the edge traces back to one of four properties. Learn these and you can predict compatibility without deploying.
There is no filesystem. Not a read-only one, not a small one. In an isolate runtime there is no fs module that does anything useful, no /tmp, and no way to write a temporary file and shell out to something that reads it. This kills an entire category of library: anything that writes scratch files, anything that loads fonts or ICU data from disk at runtime, anything that unpacks a bundled binary on first use. Your static assets are served by the platform, not read by your code. Your uploads go straight to object storage. Templates and data files must be bundled into the JavaScript module graph at build time, which works fine until a library expects to readFileSync a path it computed at runtime.
There is no process. No child_process, so no invoking ImageMagick, no git, no ffmpeg, no Python script. No worker_threads in the Node sense. No long-running background work after the response unless the platform gives you an explicit hook for it, and that hook is bounded. Signals, process.exit, and anything that assumes an operating system underneath are absent or stubs. This one surprises people the most, because “just shell out to the tool” is the normal answer to half the problems in web development, and here it does not exist.
There is no native code. An isolate runs JavaScript and WebAssembly. A compiled Node addon is a shared library with a specific ABI loaded by the Node binary, and there is no Node binary. That rules out the heavy hitters by name: image pipelines built on libvips, native password hashing builds, embedded SQLite bindings, headless browser drivers, native protobuf and compression accelerators, and any database driver that ships a compiled engine. Some of these have pure-JS or Wasm replacements that are genuinely good. Some have replacements that are much slower. Some have nothing.
Networking is HTTP-shaped. fetch exists and works. Raw TCP usually does not, or exists only through a platform-specific API rather than node:net. This is why connecting to Postgres from an isolate is a project rather than a connection string: the wire protocol wants a socket, and you need either the platform’s socket primitive, a connection-pooling proxy that speaks HTTP, or a driver built for exactly this. UDP is absent everywhere. Long-lived outbound connections generally cannot be held across requests because the isolate serving the next request may be a different one on a different machine.
Two more properties are not constraints so much as different physics, and they change how you write code.
Isolates start fast and die quietly. There is no container to boot. The platform loads your script into a fresh isolate, and the expensive part is evaluating your module graph, which scales with bundle size and top-level work. This is why edge platforms have small bundle limits and why “import the whole SDK at module scope” is a worse habit here than anywhere else. The other half is that an isolate can be evicted between any two requests, so in-memory caches are best-effort and nothing you keep in a module-scope variable is guaranteed to survive.
Global state is per-isolate, per-location. A counter in a module variable counts requests that happened to hit one isolate in one city. Rate limiting, deduplication and session affinity all need a real coordination primitive, which is why every mature edge platform ships one: a durable single-threaded object, a consistent KV store, or an external service. Building on module-scope state and discovering this in production is a rite of passage worth skipping.
Needs first-hand data: Take your actual application’s dependency tree and run it through each candidate platform’s build step, recording which packages fail and why. Group failures into three buckets: native binding, missing
node:builtin, and bundle size. The distribution across those three tells you whether the port is a week or a rewrite, and no vendor compatibility page will tell you this for your specific tree.
CPU time versus wall-clock time, and why the meter shape matters
This is the single most misunderstood difference between edge isolates and conventional serverless, and it has consequences for both your bill and your architecture.
A conventional function platform measures the time your invocation occupies its slot. If your handler calls a payment API that takes two seconds to respond, you are billed for two seconds and your timeout budget is consumed by two seconds, even though your code did nothing during them. That model is why people write elaborate step functions to avoid paying for waiting, and why a slow third-party API is a cost problem as well as a latency problem.
An isolate platform that meters CPU time bills only the time the JavaScript engine actually spent executing your code. Waiting on a fetch is free. Ten concurrent upstream calls are roughly as cheap as one. The limit that will stop you is a compute limit: sorting a large array, parsing a large JSON payload, running a cryptographic key derivation, doing image manipulation in pure JavaScript. Work that is trivially cheap on a server is exactly what exceeds an edge CPU budget.
The practical consequences:
- Fan-out and aggregation are the ideal edge workload. A handler that calls four upstreams, merges the results and returns them spends nearly all of its life waiting, which is free, and almost none of it computing.
- Transformation of large payloads is the worst edge workload. Parsing megabytes of JSON to reshape it is pure CPU. It will hit the limit before you expect it to.
- Startup work counts. Module evaluation is CPU time. An SDK that builds a large lookup table at import time spends your budget before your handler runs.
- Streaming changes the calculus. If you can stream a transformation rather than buffering it, you convert a large CPU burst into a series of small ones and stay inside the budget.
When a platform’s docs say “50 milliseconds” or “5 minutes,” always establish which clock. The same number means completely different things under the two meters, and comparison tables that mix them are worse than useless. The same distinction drives the cost model in serverless function platforms, where memory, CPU and duration are coupled in ways the edge model avoids entirely.
npm compatibility, honestly
“Supports npm” is the most oversold claim in this category. Every platform below can install packages. What differs is what happens when a package reaches for something that is not there.
Sort your dependencies into four groups and the picture clarifies:
Pure JavaScript with only web APIs. Works everywhere. Date libraries, validators, routers, templating engines, JWT libraries built on WebCrypto. This is most of the modern ecosystem and it is why the edge is viable at all.
Pure JavaScript that imports node: builtins. This is the contested middle and where most of your time will go. A library importing node:buffer and node:util is usually fine. One importing node:crypto might be fine, might be fine for hashing and broken for key generation, depending on whether the platform implements that builtin natively or shims it. One importing node:fs, node:net, node:dgram, node:cluster or node:child_process is not going to work no matter what the flag says, because the capability genuinely is not there. Ask vendors for the builtin coverage list and read it for the specific modules your tree imports, not for the headline percentage.
Packages with native bindings. Out. Look for binding.gyp, a prebuilds/ directory, or a .node file in the published tarball. There is no flag for this.
Packages that ship a WebAssembly build. Increasingly common and the genuine good news. Several previously native-only capabilities now have Wasm builds that load in an isolate: compression, some image decoding, SQLite, regular expression engines, cryptography. The cost is bundle size, because the .wasm binary counts against your deployment limit, and instantiation time on cold start.
A practical trick: the packages that break are rarely your direct dependencies. They are three levels down, pulled in by a telemetry SDK or an ORM. Run the build early and often, and prefer dependencies with a stated edge or Workers build over ones that merely “should work.”
WebAssembly: a compilation target, not a platform
WebAssembly appears on several platforms below and is sometimes discussed as if it were a vendor you could buy. It is not a product and there is no bill for it. It is a bytecode format and an execution model, and what matters here is which platforms let you use it and what it buys you when they do.
Two quite different uses show up at the edge. One is Wasm as a library format inside a JavaScript runtime: you import a .wasm module from your Worker or Deno script and call into it for the CPU-heavy part. The other is Wasm as the entire application format, where the platform runs no JavaScript engine at all and your Rust, Go or JavaScript is compiled ahead of time into a module the platform instantiates per request.
What it gives you
- Language choice beyond JavaScript at the edge. Rust, Go, C and others compile to it, which is the only way to run a serious existing codebase in these sandboxes.
- Predictable, near-native CPU performance for the hot path, which is the thing edge CPU budgets are stingiest about.
- A sandbox with no ambient authority. A module can do nothing except what the host explicitly passes in, which is a stronger isolation story than a JavaScript sandbox and the reason several platforms chose it.
- Extremely fast instantiation, since a compiled module can be snapshotted and started without a JIT warmup phase.
What it does not do
- It does not give you a filesystem, sockets, or threads. Everything comes from host imports, so the platform still decides what your code can reach, and platforms differ.
- Binary size is your problem. A garbage-collected language compiled to Wasm carries its runtime in the module, which eats the deployment budget and lengthens instantiation.
- Passing data across the JavaScript-Wasm boundary means copying through linear memory. For small, frequent calls the marshalling can cost more than the computation saves.
- The component model and the system interface around Wasm have been moving for years. Portability between hosts is better than it was and is still not a guarantee, so a module built for one platform’s host imports is not automatically deployable on another.
Cloudflare Workers

Workers is the most complete implementation of the isolate model and the platform the rest of the category is measured against. Your code runs in a V8 isolate on every location in Cloudflare’s network, with no region to pick and no concept of a deployment target beyond the account. The surrounding primitives are what make it an application platform rather than a request rewriter: Durable Objects give you a single-threaded, addressable coordination point, KV gives you eventually consistent global reads, R2 gives you object storage, and there is a first-party SQL store and a socket API for reaching conventional databases.
Pros
- The runtime is open source, so the compatibility surface is inspectable rather than a support ticket, and you can run the same engine locally instead of a mock
- CPU-time metering makes I/O-bound handlers extremely cheap, and fan-out to several upstreams costs roughly what one upstream costs
- Durable Objects solve the coordination problem that every other isolate platform leaves to you, which is the difference between an edge cache layer and an edge application
- Node compatibility is implemented as real builtins rather than a bundler polyfill for a growing set of modules, so failures are honest and early instead of subtle and late
Cons
- The CPU budget is real and a pure-JavaScript transformation of a large payload will exceed it, which usually means a Wasm module or moving that work off the edge
- Bundle size limits force attention to dependency weight, and a Wasm blob plus an SDK can push you over before your own code is significant
- The storage primitives are Cloudflare’s own, so an application built on Durable Objects and KV is genuinely hard to move, which is the coupling you accept in exchange for the coordination
Best for: Teams building request-path logic, API gateways and personalisation that runs everywhere by default, and who are willing to adopt Cloudflare storage primitives to get coordination.
Pricing: Metered on requests plus CPU milliseconds, with a free tier and a paid plan that raises the CPU ceiling. Because the meter is CPU rather than wall-clock, waiting on upstream services is not billed, and storage and durable coordination are separately metered products.
Deno Deploy

Deno Deploy runs the Deno runtime as isolates across a global network, and its defining choice is that web standards are the API surface rather than a compatibility layer bolted onto one. TypeScript executes without a build step, permissions are explicit, and npm: and jsr: specifiers let you import packages without a node_modules directory. It is the platform where writing to the standard and writing to the runtime are the same activity.
Pros
- TypeScript is first class with no build configuration, which removes an entire class of toolchain problem from the deployment path
- Web-standard APIs throughout mean code written for Deploy usually runs unchanged in a browser-shaped test harness and often in other isolate runtimes
- Built-in KV and queue primitives cover the common stateful cases without adding a second vendor on day one
- The same runtime runs locally, so the gap between
deno runand production is smaller than on platforms with a bespoke edge build
Cons
- The npm compatibility path is genuine but not total, and packages assuming a
node_moduleslayout or deep Node internals still fail - A smaller ecosystem of first-party integrations than Cloudflare or Vercel, so more of the surrounding infrastructure is yours to assemble
- Deno-specific APIs are the price of the good parts, and code written against them is not portable back to Node without work
Best for: TypeScript-first teams who want standards-based APIs and are happy to treat Deno as the runtime rather than as a Node replacement.
Pricing: Request-and-compute metering with a free tier, plus separate metering for the KV and queue primitives. The compute dimension is measured against the isolate model rather than provisioned memory.
Vercel Edge Functions
Vercel’s edge runtime is a restricted V8 environment positioned mainly for the request path around a framework application: middleware, rewrites, auth checks, A/B assignment and personalised headers before a request reaches the rendering function. Its strength is that it is wired into the framework rather than sitting beside it, so middleware, caching and revalidation are one system. Note that Vercel has been steering general application code back toward its Node.js runtime, with the edge runtime narrowing toward the pre-render layer, so treat it as a middleware tier rather than as a place to run your whole backend.
Pros
- Framework integration is the tightest in the category, with middleware, caching and revalidation designed as one mechanism rather than three products
- Deployment, preview environments and rollback are a single well-built workflow, which removes most of the operational work from shipping
- The edge runtime API surface is documented explicitly enough that incompatibility is a build-time error rather than a runtime surprise
- Running personalisation and auth checks before the rendering tier keeps cacheable responses cacheable, which is the actual latency win
Cons
- The edge runtime is a deliberately restricted subset and the platform’s own guidance pushes substantial work to the Node runtime, so it is not a general compute target
- Framework coupling runs deep, and the further you get from the framework’s conventions the less of the platform’s value you receive
- Multiple metered dimensions across functions, edge middleware, bandwidth and image handling make cost modelling harder than a single compute meter
Best for: Teams already building on Vercel who want the pre-render request path, auth and experimentation to run close to the user without adding a second platform.
Pricing: Plan tiers plus usage metering across several dimensions including invocations, compute duration and bandwidth, with edge middleware metered separately from the function tier.
Fastly Compute
Fastly Compute takes the other architectural route: WebAssembly modules rather than a shared JavaScript engine, instantiated per request and torn down afterwards. That design deliberately removes cross-request state, which removes a class of isolation concern, and it means the language choice is whatever compiles to Wasm rather than whatever V8 runs. It sits alongside a mature CDN with a configuration language most of the industry has encountered, which makes it the natural upgrade path for teams who have outgrown edge config rules.
Pros
- Per-request instantiation gives a clean isolation story with no state leaking between requests by construction rather than by policy
- Rust, Go and JavaScript all compile to the same deployment artifact, so an existing non-JavaScript codebase has a path here that isolate platforms do not offer
- Sits on a CDN with deep cache-control features, so the compute tier and the caching tier are genuinely one product rather than two bolted together
- Local testing runs the same Wasm engine, so behaviour differences between dev and production are small
Cons
- No cross-request in-process state at all, so anything resembling a warm cache has to be an explicit store, and the JavaScript ecosystem experience is thinner than on V8 platforms
- The npm story is the weakest of the JavaScript-capable options here, because the runtime is a Wasm host rather than a Node-shaped environment
- The product is aimed at the CDN buyer, so evaluation tends to involve a sales conversation rather than a credit card and a deploy
Best for: Teams already running Fastly for delivery who want programmable request handling in Rust or Go, with caching and compute configured as one system.
Pricing: Usage-based on requests and compute duration, typically alongside a CDN delivery contract, with enterprise agreements rather than a self-serve tier being the common shape.
AWS Lambda@Edge
Lambda@Edge runs conventional Lambda functions at CloudFront’s regional edge caches, triggered at four points in the request lifecycle. It is the odd one out here: a container-based function runtime placed nearer the user rather than an isolate runtime, which means you keep Node and Python semantics and inherit container cold starts. AWS also offers CloudFront Functions, a much lighter JavaScript-only runtime restricted to viewer events, which is closer to the isolate model and the right choice for header manipulation and redirects.
Pros
- A real Node or Python runtime, so libraries that fail on isolate platforms generally work here without a port
- Four distinct trigger points mean you can act on the cache key before a lookup or on the response after an origin fetch, which is precise control over caching behaviour
- Deep integration with the rest of AWS, so IAM, logging and deployment tooling are the ones your team already operates
- CloudFront Functions covers the cheap, ultra-light cases in the same product family, so you can split work between the two by weight
Cons
- Deployment is a replication to every edge location and is slow enough that iteration feels nothing like the other platforms here
- Restrictions are numerous and unevenly documented across trigger types, covering environment variables, VPC access, payload sizes and timeouts, and you discover them one at a time
- Logs land in the region nearest the execution, so debugging means looking in many places at once rather than one
- You inherit container cold starts, which is exactly the problem the isolate model exists to remove
Best for: Teams already committed to CloudFront and AWS who need real Node or Python semantics at the edge and can tolerate slow deployment cycles.
Pricing: Per-request and per-duration metering in the Lambda style, billed on wall-clock duration and memory, on top of CloudFront request and data transfer charges.
Netlify Edge Functions
Netlify Edge Functions run on the Deno runtime deployed across Netlify’s network, positioned as the request-path layer for sites built on the platform. The model is deliberately narrow: intercept, rewrite, personalise, transform the response stream, then hand off. For a team already deploying a site to Netlify it is the least additional machinery of anything here, because it is the same repository, the same build and the same deploy.
Pros
- Web-standard and Deno APIs, so the code is close to portable and the mental model matches other isolate platforms
- Nothing new to operate for an existing Netlify site, since edge functions live in the same repo and ship in the same deploy
- Response streaming and transformation are first class, which covers the personalise-a-cached-page case cleanly
- Atomic deploys and instant rollback apply to edge functions the same way they apply to the rest of the site
Cons
- Scoped to the request path for sites hosted on Netlify, so it is not a general compute platform and is not useful independently of that hosting
- Fewer stateful primitives than Cloudflare, so coordination and durable state mean bringing an external service
- The Deno runtime here is a subset shaped by the platform, so not everything that runs on Deno locally runs here
Best for: Teams already hosting on Netlify who need personalisation, auth checks or redirects in front of otherwise cacheable pages.
Pricing: Included in Netlify plan tiers with invocation allowances, metered beyond them, and bundled with the wider site hosting rather than sold as standalone compute.
Bun
Bun belongs on this list as the honest counterweight. It is a JavaScript runtime rather than an edge network: a single binary built on JavaScriptCore with a bundler, test runner and package manager inside it, and a much broader Node compatibility surface than any isolate runtime because it is a real process on a real operating system. You deploy it on a container platform or a VM and get none of the edge constraints, which is frequently the correct answer once you have priced the port.
Pros
- Node compatibility is far wider than any isolate platform, including filesystem, child processes, sockets and a good deal of the native addon surface
- The bundler, test runner and package manager in one binary remove a large amount of toolchain from the repository
- Fast process startup makes it a strong fit for scale-to-zero container platforms, where the boot time is what you are paying for
- No edge constraints at all, so the compatibility investigation that dominates the rest of this article simply does not happen
Cons
- There is no Bun edge network, so global distribution means running it in several regions yourself with all the data locality work that implies
- Native addon compatibility is broad rather than complete, and the failures land in exactly the heavy native packages you adopted Bun to keep
- You are back to managing instances, health checks and scaling, which is the operational cost the edge model removes
Best for: Teams who evaluated the edge, found their dependency tree incompatible, and want fast startup on a conventional container platform instead.
Pricing: Open source and free to use; your cost is whatever container or VM platform you run it on, metered by that platform rather than by Bun.
Needs first-hand data: Deploy the same fan-out handler, one that calls three upstreams and merges the results, to each candidate platform and record latency at the median and the tail from several continents, alongside the platform’s own reported CPU or duration figure. The gap between wall-clock latency and metered compute is the number that decides your bill, and it is workload-specific.
How to choose
Work through these in order. The first three eliminate more candidates than any benchmark.
Run the dependency audit before anything else. Search your lockfile for packages with native bindings and list every node: builtin imported anywhere in the tree. If that list contains fs, net, child_process or worker_threads in code you cannot remove, the isolate platforms are out and you are choosing between Lambda@Edge and a container platform with good regional placement. This takes an hour and saves a quarter.
Establish where your data lives. Compute at the edge in front of a database in one region means every request still crosses the same distance, and you have added a hop. Either the handler must be genuinely independent of origin data, or the data has to be distributed too, which is its own decision covered in edge databases and serverless databases. Getting this backwards is the most common reason an edge migration produces no measurable improvement.
Work out which meter you are on. If your handlers are I/O-bound, CPU metering is dramatically cheaper and you should weight it heavily. If they are compute-bound, CPU metering is a limit you will fight and a wall-clock platform with more memory may be both simpler and cheaper.
Decide whether you need coordination. Rate limiting, locks, sequence numbers, session state and anything requiring a single writer need a real primitive. If you need one, that narrows the field sharply, because not every platform here has one.
Then, and only then, compare latency. By this point there will be one or two candidates left, and the difference between them is usually smaller than the difference your caching strategy makes.
| Runtime model | Filesystem | Native modules | Meter | Built-in coordination | |
|---|---|---|---|---|---|
| Cloudflare Workers | V8 isolate | None | No, Wasm only | CPU time | Durable Objects |
| Deno Deploy | V8 isolate, Deno | None | No, Wasm only | Request and compute | Built-in KV and queues |
| Vercel Edge Functions | V8 isolate, restricted | None | No | Invocations and duration | External |
| Fastly Compute | Wasm per request | None | Compiled to Wasm | Requests and compute | External |
| AWS Lambda@Edge | Container, Node or Python | Writable temp space | Yes | Wall-clock and memory | External |
| Netlify Edge Functions | V8 isolate, Deno | None | No | Plan allowance, then metered | External |
| Bun | Full OS process | Yes | Mostly yes | Whatever hosts it | External |
| WebAssembly (standard, not a product) | Sandboxed bytecode | Host-provided only | Compilation target | None | None |
If you are running a request path in front of cacheable content and want one platform to own both, Cloudflare Workers or Fastly Compute, depending on whether your team writes JavaScript or Rust. If you are already on a framework host and need personalisation before rendering, use that host’s edge tier and do not add a vendor. If your dependency audit came back ugly, stop trying and put the workload on a container platform with multi-region placement, which the hosting platforms overview walks through alongside the rest of the category.
Frequently asked questions
Why does my npm package fail on Cloudflare Workers or Deno Deploy when it works locally?
Almost always one of three reasons. It ships a compiled native binding, which cannot load in an isolate at all. It imports a node: builtin the runtime does not implement, most often fs, net or child_process. Or it pushes your bundle past the deployment size limit. Check for a binding.gyp or a prebuilds/ directory in the package tarball to identify the first case immediately, and read the build error carefully for the second, because the failing import is usually in a transitive dependency rather than one you chose.
Can I connect to Postgres or MySQL from an edge function?
Not with a conventional driver, because those speak a binary protocol over a TCP socket and isolate runtimes do not give you one through node:net. Three workable routes exist: use the platform’s own socket API where it has one, put an HTTP-speaking connection pooler in front of the database, or use a driver built specifically to talk over HTTP or WebSocket. All three have a further problem worth planning for, which is that a globally distributed compute tier in front of a single-region database still pays the round trip on every query.
Is the edge actually faster for my application?
Only if the work can be completed without going back to an origin. Serving a cached response, making a routing decision, validating a token, assigning an experiment bucket and rewriting a header are all genuinely faster because they finish at the edge. A handler that reaches a database in one region has moved the compute closer and left the data where it was, and it will often be slower than running the compute next to the data. Decide data locality first, which is the argument in multi-region deployment.
What is the difference between CPU time and wall-clock time limits?
Wall-clock time counts every millisecond from invocation to response, including time spent waiting for a network call to return. CPU time counts only the milliseconds the engine spent running your code. Under a CPU meter, awaiting a slow upstream is free and a tight loop is expensive; under a wall-clock meter, both are billed identically. This is why a handler that fans out to five services is cheap on one model and expensive on the other, and why comparing a “50ms limit” on one platform to a “10 second limit” on another is meaningless without knowing which clock each uses.
Related reading
- Best hosting platforms for developers — the whole category, and where edge compute sits relative to containers and PaaS.
- Cloudflare Workers vs Vercel vs Deno Deploy — the same three runtimes compared by porting one application to each.
- Best serverless function platforms — the wall-clock side of the meter, and where memory and CPU are coupled.
- Best edge databases — the other half of the edge decision, and usually the harder half.
- Best CDN providers for developers — when caching gets you the win without any compute at all.
- Best APM for serverless and edge functions — how to get telemetry out of a runtime with no filesystem and no agent.