jupyter-live-kernel

Execute stateful Python code iteratively in a live Jupyter kernel.

1|Updated Apr 14, 2026
One-click install
npx skills add https://github.com/eddielueng/hermes-agent-zh --skill jupyter-live-kernel-eddielueng
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: jupyter-live-kernel
Source: https://github.com/eddielueng/hermes-agent-zh/tree/main/skills/data-science/jupyter-live-kernel
Command: npx skills add https://github.com/eddielueng/hermes-agent-zh --skill jupyter-live-kernel-eddielueng

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

A stateful Python execution workflow removes the friction of rewriting and rerunning code from scratch when exploring data, debugging logic, or iterating on experiments.

Core Features & Use Cases

  • Stateful iterative REPL: Persist variables, imports, and objects across executions for notebook-like development without losing context.
  • Notebook and variable inspection: Discover existing notebooks, list variables, preview variable contents, and edit notebook cells to refine code safely.
  • Verification for reliability: Restart and run all cells to confirm the notebook executes end-to-end when the user requests a clean validation.

Example Use Case: You’re experimenting with an API response schema—run exploratory parsing code, inspect the resulting DataFrame, adjust transformations in a new cell, and re-run only what’s needed while keeping all intermediate objects.

Quick Start

Use the jupyter-live-kernel skill to execute iterative Python in a live Jupyter-backed notebook for stateful exploration and debugging.

Frequently Asked Questions about jupyter-live-kernel

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

FAQPage Schema
How do I run stateful Python execution for iterative data science experiments?

Stateful Python execution persists variables, imports, and objects across executions to enable notebook-like iterative development without losing context. A live Jupyter kernel runs commands sequentially so you can explore data and debug logic step-by-step without restarting.

Can I inspect and edit Jupyter notebook variables during live kernel execution?

Yes, live kernel execution supports notebook and variable inspection. You can discover existing notebooks, list variables, preview variable contents, and edit notebook cells to refine code safely while maintaining all intermediate objects in memory.

What's the best way to validate a Jupyter notebook executes end-to-end after incremental edits?

To validate a Jupyter notebook end-to-end, use the restart and run all cells command. This runs the entire notebook from a clean state to confirm the code executes reliably after making incremental changes or exploratory edits.

Do I need a running Jupyter server with uv and JupyterLab to execute stateful Python?

Yes, stateful Python execution requires a running Jupyter server with uv and JupyterLab available in the tool environment. The workflow operates by running hamelnb kernel commands in a terminal to interact with the live kernel.

Why does my Python REPL lose variables when iterating on API exploration and transformations?

Standard Python REPLs lose variables because they execute statelessly, requiring code to be rewritten and rerun from scratch. A stateful iterative REPL persists data across executions, allowing you to parse API responses, inspect DataFrames, and adjust transformations incrementally.

When do I need a live Jupyter kernel instead of a standard Python script for ML experimentation?

You need a live Jupyter kernel for ML experimentation when iterating on data transformations or debugging logic interactively. It removes the friction of rerunning code from scratch, allowing you to execute step-by-step while keeping intermediate objects and variables persistent.