Datalayer Runtimes vs Jupyter Kernel Gateway
Choose Datalayer Runtimes for agents that need a stateful, snapshot-able Jupyter kernel (CPU or GPU) rather than a one-shot run; choose Jupyter Kernel Gateway for teams already on Jupyter and Kubernetes who want to run their own stateful kernels-as-a-service. Datalayer Runtimes uses Not documented isolation; Jupyter Kernel Gateway uses Process (KG) / pod (EG) isolation and is open source.
Key differences between Datalayer Runtimes and Jupyter Kernel Gateway
- Type: Datalayer Runtimes is a hosted platform; Jupyter Kernel Gateway is an open-source project you run yourself.
- Session length: Minutes (set per runtime) (Datalayer Runtimes) versus Unbounded (culling optional) (Jupyter Kernel Gateway).
- SDKs and interfaces: Only Datalayer Runtimes lists JavaScript/TypeScript, CLI and MCP server.
What they have in common
- Both list Python and REST API.
Datalayer Runtimes vs Jupyter Kernel Gateway at a glance
| Attribute | Datalayer Runtimes | Jupyter Kernel Gateway |
|---|---|---|
| What it is | Remote Jupyter kernels as a service for AI agents: stateful CPU or GPU runtimes created on demand from Python or TypeScript, with snapshots of installed packages, files and variables, and a hosted Jupyter MCP Server. | BSD-licensed headless web server that exposes Jupyter kernels over REST and WebSockets; on its own it runs kernels as local processes, while the sibling Enterprise Gateway launches each kernel in its own Kubernetes pod and namespace. |
| Type | Hosted platform | Open-source project |
| Isolation | Not documented; the SDK describes each runtime as "a clean, isolated Python environment" on cloud machines and the agent-runtimes README refers to a pod's egress boundary, but no hypervisor or container technology is named | Not documented for Kernel Gateway itself, which launches kernels in its own local process and filesystem space; the docs say it "can be containerized and scaled out". Enterprise Gateway launches each kernel as a Kubernetes pod (or on YARN, Docker Swarm or IBM Spectrum Conductor), by default in a per-kernel namespace with the baseline Pod Security Standard and root prohibited |
| Open source | Not documented | Yes (BSD-3-Clause) |
| Self-host / BYOC | Not documented / Not documented | Yes / No |
| SDKs | Python, JavaScript/TypeScript, CLI, MCP server, REST API | REST API, Python |
| Cold start (vendor claim) | Not documented | Enterprise Gateway kernel launch timeout defaults to 60 seconds on Kubernetes |
| Max session | Runtimes are created with a timeout in minutes (SDK example: 30); the default and maximum are not stated on the SDK docs | No limit by default; Enterprise Gateway idle culling is off by default (cull_idle_timeout 0, with 43,200 s recommended) and the Kubernetes Helm chart defaults to 3,600 s |
| Persistence | Stateful kernel: variables persist across execute() calls within a runtime session and are lost on termination; snapshots capture installed packages, files and variables and can seed a new runtime | Stateful kernel: variables and files persist for the life of the kernel; Kernel Gateway can seed every kernel from a notebook (seed_uri) and prespawn kernels; no snapshots |
| Snapshots / pause | Yes / Not documented | Not documented / Not documented |
| GPU | Yes: an "AI Environment" GPU environment alongside the Python CPU environment; the pricing page lists A100 (80 GB) and T4 (16 GB) environments, shown as "Unavailable" when checked | Enterprise Gateway accepts KERNEL_GPUS / KERNEL_GPUS_LIMIT requests on Kubernetes; GPU handling is not documented for Kernel Gateway itself |
| Networking | Not documented | Not restricted by the gateways; whatever the host or pod allows |
| Pricing | Plans on datalayer.ai/pricing: Free (50 wallet credits and 500 runs per month), Team $49/month (500 wallet credits and 5,000 runs per month, plus $15 per active seat for organisations) and Enterprise (custom). Sandboxes consume wallet credits while running; the 1 CPU environment (1 vCPU, 1 GiB) is listed at 0.3 USD per hour | Free (BSD-3-Clause) |
| Free tier | Free plan: 50 wallet credits and 500 runs per month | Free to self-host |
| Compliance | Trust page states SOC 2 Type II, ISO/IEC 27001:2022 and ISO/IEC 42001:2023 | Not documented |
| Regions | Available environments "may vary based on your account tier and region"; regions not listed | Not documented |
| Company headquarters | Not documented | Not documented |
| Good fit for | Agents that need a stateful, snapshot-able Jupyter kernel (CPU or GPU) rather than a one-shot run | Teams already on Jupyter and Kubernetes who want to run their own stateful kernels-as-a-service |
Verified November 14, 2026 from each provider’s documentation. Cold-start figures are vendor claims, not our measurements.
Which should you choose?
Reasons to choose Datalayer Runtimes
- You want a stateful Jupyter kernel an agent can call repeatedly, with GPU environments
- You need to snapshot an environment (packages, files, variables) and restore it later
- You are driving notebooks from an MCP client and want a hosted MCP server
Reasons to choose Jupyter Kernel Gateway
- You want stateful Jupyter kernels (Python, R, Scala) under your own control, free of licence cost
- You run Kubernetes and want one pod per kernel with per-kernel namespaces and resource limits
- You are building on the standard Jupyter protocol so any kernel language and client works
Trade-offs to check first
- Datalayer Runtimes: Isolation technology and regions are not documented on the pages checked
- Datalayer Runtimes: Runtimes are time-boxed in minutes and environments are stateless without snapshots
- Jupyter Kernel Gateway: Kernel Gateway launches kernels in its own process and filesystem space; isolation between kernels is not documented
- Jupyter Kernel Gateway: Enterprise Gateway warns that KERNEL_USERNAME comes from the client, so per-user namespaces are not a full access control
Both are worth piloting with your own image and region. See the full Datalayer Runtimes profile and Jupyter Kernel Gateway profile, or the complete comparison.
Frequently asked questions
Is Datalayer Runtimes or Jupyter Kernel Gateway better for AI agents?
What is the difference between Datalayer Runtimes and Jupyter Kernel Gateway?
Which is open source, Datalayer Runtimes or Jupyter Kernel Gateway?
How do Datalayer Runtimes and Jupyter Kernel Gateway isolate code?
How does Datalayer Runtimes pricing compare with Jupyter Kernel Gateway?
Do Datalayer Runtimes and Jupyter Kernel Gateway support GPUs?
Can you self-host Datalayer Runtimes or Jupyter Kernel Gateway?
How long can sessions run on Datalayer Runtimes and Jupyter Kernel Gateway?
Do Datalayer Runtimes and Jupyter Kernel Gateway support snapshots or pause and resume?
Sources
- datalayer.ai
- core.datalayer.tech/python/
- core.datalayer.tech/python/Runtimes
- core.datalayer.tech/python/Environments
- github.com/jupyter-server/kernel_gateway
- jupyter-kernel-gateway.readthedocs.io/en/latest/
- jupyter-kernel-gateway.readthedocs.io/en/latest/config-options.html
- jupyter-kernel-gateway.readthedocs.io/en/latest/websocket-mode.html
Check before you rely on it. Products change quickly, and this page reflects public documentation as of November 14, 2026. Confirm anything that matters in the provider’s own documentation.
Cite this page
Agent Sandboxes. (2026). Datalayer Runtimes vs Jupyter Kernel Gateway. agentsandboxes.org. Last reviewed November 14, 2026. https://agentsandboxes.org/compare/datalayer-vs-jupyter-kernel-gateway/