jupyter-live-kernel

Execute stateful Python code through a live Jupyter kernel with persistent variables.

6|1|Updated May 11, 2026
One-click install
npx skills add https://github.com/yakeworld/Synthos --skill jupyter-live-kernel-yakeworld
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: jupyter-live-kernel
Source: https://github.com/yakeworld/Synthos/tree/main/skills/extended/external-automation/automation-skills/productivity/jupyter-live-kernel
Command: npx skills add https://github.com/yakeworld/Synthos --skill jupyter-live-kernel-yakeworld

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires uv, jupyterlab, and includes references (resource) components.

What problem does it solve? One-shot code execution loses all variables between runs, forcing you to re-import libraries and reload data on every step. This Skill provides a stateful Python REPL backed by a live Jupyter kernel, so variables, imports, and objects persist across executions for iterative exploration. ## Core Features & Use Cases - Stateful Code Execution: Run Python code against a live kernel where DataFrames, models, and variables survive across calls. - Live Variable Inspection: List and preview variables currently held in the kernel without re-running code. - Notebook Cell Editing: Insert, replace, and delete cells in a notebook, plus restart-and-run-all verification for clean top-to-bottom runs. - Use Case: While exploring a CSV dataset, load it into a pandas DataFrame once, then iteratively filter, transform, and plot it across multiple executions without reloading, and finally verify the whole notebook runs cleanly. ## Quick Start Start a JupyterLab server, create a scratch notebook session, then ask the agent to run your Python code through the live kernel so state persists between steps.

Frequently Asked Questions about jupyter-live-kernel

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I keep Python variables alive between code executions?

Use a live Jupyter kernel as a stateful REPL: each execute call runs against the same kernel, so imports, DataFrames, and objects persist. Create a scratch notebook session via the Jupyter REST API, then send code with the execute command.

When should I use a Jupyter kernel instead of one-shot code execution?

Use a live kernel for iterative exploration, data science, and ML work where you build state incrementally. Use one-shot execution for stateless scripts that need tool access, and the terminal for shell commands, installs, and process management.

How do I inspect variables in a running Jupyter kernel?

Run the variables command with the notebook path to list all live variables, or preview a specific variable by name. Place global flags like --path before the sub-subcommand, for example: variables --path scratch.ipynb list.

Why does the first Jupyter kernel execution time out?

The kernel needs time to initialize after the server starts or after a restart, so the first execution may exceed the default 30-second timeout. Retry once before escalating, and pass an explicit --timeout of 60 or 120 seconds for heavy operations.

How do I install packages for the Jupyter kernel environment?

Packages must be installed into the JupyterLab tool environment, since the kernel uses JupyterLab's Python interpreter. Installing into the system global environment will not make packages importable inside kernel executions.

How do I verify a Jupyter notebook runs top to bottom?

Use the restart-run-all command with --save-outputs to restart the kernel and execute every cell in order. If it fails, parse the returned JSON ename and evalue fields to identify the exact exception.