Sphinx AI – Jupyter-Native AI Copilot for Data Scientists

TL;DR

TL;DR: Sphinx is a data-native AI copilot built for Jupyter notebooks — it runs an agentic loop cell-by-cell, reads charts to guide its reasoning, and ships with connectors for Snowflake and Databricks.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: sphinx.ai
• Source repository: No public GitHub repo found at time of writing
• License: Not specified in HN announcement
• HN launch thread: news.ycombinator.com/item?id=45181926
• Source last checked: 2026-07-22 (HN API item 45181926)

What Is Sphinx AI?

Sphinx is an AI copilot designed specifically for data scientists who work in Jupyter notebooks. Unlike general-purpose coding assistants such as Cursor or Windsurf, Sphinx is data-native — it understands the exploratory, experimental nature of data science workflows rather than treating notebooks as simply edited code files.

The core differentiator is its cell-by-cell agentic loop. Rather than generating an entire script at once, Sphinx breaks analytical tasks into discrete steps and executes them incrementally inside the notebook. It can also read charts and graphs it generates to inform its next steps — a capability that general-purpose copilots lack.

Key capabilities as described by the founders on HN:

• Fully agentic loop — breaks tasks into discrete steps and implements them cell-by-cell inside the notebook
• Chart-aware reasoning — reads charts and graphs it generates to guide subsequent steps
• Data connectors — built-in support for Snowflake, Databricks, and standard database connectors
• MCP integration — full Model Context Protocol support for extending capabilities
• Programmatic outputs — large outputs can be consumed as data directly in downstream notebook cells
• VSCode extension — available as a VSCode extension with a free tier

Setup Workflow

Prerequisites

• VSCode (desktop)
• Python 3.9+ environment with Jupyter kernel
• Account at sphinx.ai (free tier available)

Step 1: Install the VSCode Extension

The primary way to run Sphinx is as a VSCode extension. There is no self-hosted server component mentioned in the launch announcement — the service operates as a hosted offering with a free tier.

# Search for "Sphinx AI" in the VSCode Marketplace
# Or visit https://www.sphinx.ai/ for the extension link

Step 2: Connect Your Notebook Kernel

After installing the extension, open a Jupyter .ipynb file in VSCode. Sphinx will automatically detect the notebook kernel. The extension communicates with the Sphinx backend to power the AI completions.

Step 3: Configure Data Connectors (Optional)

To connect Snowflake, Databricks, or other database sources:

1. Open the Sphinx extension panel in VSCode
2. Navigate to Connectors → Add data source
3. Select your connector type (Snowflake, Databricks, PostgreSQL, etc.)
4. Enter your credentials — Sphinx stores these locally, not on their servers
5. Test the connection

Step 4: Start an Agentic Session

With a notebook open, describe the analysis you want to perform in natural language. Sphinx will:

1. Break your request into a plan of notebook cells
2. Execute each cell sequentially
3. Read the output of each cell before proceeding
4. Course-correct if intermediate results diverge from expectations

Deeper Analysis

Why Sphinx Exists

General AI coding assistants were built for software engineering — where the primary artifact is a source file, and the workflow is linear (write code, run, debug, commit). Jupyter notebooks break these assumptions in fundamental ways:

• Out-of-order execution — cells can be run in any order, producing state that differs from top-to-bottom execution
• Exploratory workflows — data scientists often do not know the answer before they start; the notebook is a thinking tool, not just an implementation artifact
• Rich outputs — charts, data frames, and printed results are first-class artifacts, not side effects
• Large cell outputs — outputs themselves are data that feed into downstream cells

Sphinx was designed from the ground up for this environment, rather than bolting Jupyter support onto a code-editor paradigm.

Cell-by-Cell Agentic Execution

The most notable feature is Sphinx’s cell-by-cell execution model. Where Cursor or Copilot might generate a complete analysis script in one shot (which then fails when run in a notebook context), Sphinx:

1. Generates one cell at a time
2. Executes it and captures the output
3. Feeds that output back into its reasoning for the next cell
4. Adjusts the plan if outputs diverge from expectations

This mirrors how an experienced data scientist actually works — start with the data, look at results, decide next steps, repeat.

Chart-Aware Reasoning

Sphinx can read the charts it generates. This is a meaningful capability for data science workflows: a chart often reveals the next analytical question better than the code that produced it. By reading chart outputs before proceeding, Sphinx avoids the “blind execution” problem that plagues simpler code-generation tools.

MCP Integration

The mention of full MCP (Model Context Protocol) integration means Sphinx can be extended with custom tools and connectors beyond the built-in data sources. MCP is an emerging standard for connecting AI systems to external tools and data sources.

Practical Evaluation Checklist

• [ ] Extension installs cleanly in VSCode without requiring a separate server process
• [ ] Notebook kernel detection works automatically on .ipynb open
• [ ] Cell-by-cell execution produces correct intermediate state
• [ ] Chart outputs are read and influence subsequent cell generation
• [ ] Snowflake / Databricks connectors authenticate and query successfully
• [ ] MCP tools load and function within the notebook session
• [ ] Free tier provides sufficient usage for evaluation purposes
• [ ] Large outputs are accessible as programmatic data in downstream cells

Security Notes

The HN announcement states that credentials for data connectors are stored locally, not on Sphinx’s servers. However:

• No third-party security audit has been published at time of writing
• The service operates as a hosted (SaaS) product — verify the data processing agreement if connecting production databases
• MCP tool access extends the attack surface — review which MCP tools are enabled before connecting production systems

FAQ

Q: Is Sphinx open source? A: The launch announcement does not specify an open source license or repository. It operates as a hosted SaaS product with a VSCode extension. Check sphinx.ai for the most current licensing information.

Q: How does Sphinx differ from GitHub Copilot or Cursor in notebooks? A: General coding assistants treat notebooks as source files with rich output. They typically generate complete scripts and do not read intermediate cell outputs to inform subsequent steps. Sphinx is built for Jupyter from the ground up, executing cell-by-cell and using chart and data outputs as part of its reasoning loop.

Q: Does Sphinx work with JupyterLab, or only VSCode? A: The current launch centers on a VSCode extension. JupyterLab compatibility was not mentioned in the announcement.

Q: What data sources does Sphinx support beyond Snowflake and Databricks? A: The HN announcement mentions “common data connectors” and “databases” in addition to Snowflake and Databricks, but does not enumerate the full list. The connectors panel in the VSCode extension would show the current supported list.

Q: Is there a self-hosted option? A: No self-hosted option was mentioned in the launch announcement. Sphinx operates as a hosted service.

Conclusion

Sphinx addresses a real gap in the AI coding assistant landscape — data scientists working in Jupyter notebooks have largely been underserved by tools built for software engineers. Its cell-by-cell agentic model and chart-aware reasoning are purpose-built for how analytical work actually unfolds.

The free VSCode extension tier makes it easy to evaluate. If you regularly work with notebooks and find that existing AI tools generate scripts that do not survive contact with the notebook kernel, Sphinx is worth trying.

Next steps:

• Install from sphinx.ai or the VSCode Marketplace
• Open a notebook and describe an analysis in plain English
• Evaluate whether the cell-by-cell execution model fits your workflow