jupyter-live-kernel

Run stateful Python code iteratively through a live Jupyter kernel.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

Gives you a stateful Python REPL via a live Jupyter kernel. Variables persist across executions. Use this instead of execute_code when you need to build up state incrementally, explore APIs, inspect DataFrames, or iterate on complex code.

Core Features & Use Cases

  • Stateful execution across commands for data science experiments.
  • Inspect variables, run iterative code, and interact with notebooks without restarting kernels.
  • Use case: data exploration, ML prototyping, API exploration, and building complex scripts step-by-step.

Quick Start

Start a live Jupyter kernel and run Python code iteratively across cells.

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 persistent across multiple executions for data science experiments?

A live Jupyter kernel provides stateful Python execution where variables persist across commands. This enables iterative code development and incremental state building for data exploration without restarting the kernel between executions.

What's the best way to inspect DataFrames and explore APIs iteratively without losing state?

The best way to inspect DataFrames and explore APIs iteratively is through a stateful Python REPL via a live Jupyter kernel. This approach maintains persistent variables across executions, allowing you to build up state incrementally and interact with notebooks without restarting kernels.

When should I use a live Jupyter kernel instead of standard code execution for ML prototyping?

You should use a live Jupyter kernel instead of standard code execution when you need stateful, iterative Python execution for ML prototyping. It is ideal for tasks requiring persistent state across executions, such as data exploration, API exploration, and building complex scripts step-by-step.

How do I start a live Jupyter kernel and run Python code iteratively across cells?

Start a live Jupyter kernel using the hamelnb script to start servers, create or attach notebooks, and execute code cells. This structured workflow enforces stateful execution, allowing you to run Python code iteratively across cells with persistent state maintained throughout the session.

Can I attach an existing notebook to a live Jupyter kernel and continue executing code with persistent state?

Yes, you can attach an existing notebook to a live Jupyter kernel. The hamelnb script supports creating or attaching notebooks to a running server, enabling continued iterative code execution with persistent state across the session.

What are the limitations of using a stateful Python REPL for complex code development?

A stateful Python REPL via a live Jupyter kernel requires a structured workflow through the hamelnb script to manage servers and notebooks. It is designed for iterative, stateful tasks and depends on maintaining a persistent kernel session, which may not suit stateless or one-off execution workflows.