V8 Probe: JavaScript and Electron App State with NSP

The V8 probe is NSP’s highest-accuracy probe and the one you’ll use most often. It connects to any running Chrome or Electron process through the Chrome DevTools Protocol (CDP) and extracts live application state directly from the V8 JavaScript heap — no screenshots, no DOM scraping, no UI automation. Once Chrome is configured and the daemon is running, the probe attaches automatically and begins delivering structured state within seconds.

Supported Applications

The V8 probe covers every application that runs JavaScript in a Chrome or Electron host. This includes:

Web apps in Chrome: Gmail, Slack (web), Salesforce, Shopify, HubSpot, GitHub
Electron desktop apps: VS Code, Slack (desktop), Notion, GitHub Desktop, WhatsApp Desktop, Discord
Any Electron app — if an application is built on Electron, the V8 probe can attach to it automatically

How the V8 Probe Works

NSP uses a two-tier extraction strategy for V8. The fast-path runs on every poll cycle; the fallback runs only when the fast-path is unavailable.

ASO Fast-Path (Primary)
Heap Snapshot Fallback

On every poll cycle, NSP injects a small JavaScript snippet into the running page via a CDP Runtime.evaluate call. This snippet reads the application’s internal data model directly from the V8 heap and returns a compact, structured payload.

Latency: 5–50 ms per poll
Accuracy: >99%
Trigger: Used on every poll once the probe is warmed

Because the snippet runs inside the same V8 context as the application, it can access the application’s live object graph without serialisation overhead or DOM traversal.

When the ASO fast-path is unavailable — for example, on the very first cold attach or when the application does not expose a compatible data model — NSP falls back to a full V8 heap snapshot via CDP.

Latency: ~47 seconds
Accuracy: >99% (same output quality, higher latency)
Trigger: Cold probe and ASO failure recovery

NSP takes a complete heap snapshot, processes the result, and normalises it to SSF JSON. This produces an identical SubstrateState shape — just slower.

Prerequisites

Before the V8 probe can attach, Chrome must be running with its CDP remote debugging port enabled. Standard Chrome installations do not enable this by default.

You must close all existing Chrome windows before relaunching with the debugging flag. Chrome only supports one debugging port per user profile. If Chrome is already open without the flag, the probe cannot connect.

Setup

Follow these steps to configure Chrome for V8 probing.

Close all existing Chrome windows

Quit Chrome completely — closing individual tabs is not enough. Make sure no Chrome processes remain in Task Manager before proceeding.

Relaunch Chrome with the remote debugging flag

Open a new terminal and run one of the following commands:

Command Prompt
PowerShell

"C:\Program Files\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9222

Start-Process "chrome.exe" --ArgumentList "--remote-debugging-port=9222"

Chrome will open normally. The debugging port runs silently in the background — there is no visible indicator that it is active.

Verify that the daemon detects Chrome

Call the apps endpoint to confirm NSP has found the Chrome process and begun probing:

curl http://localhost:7842/substrate/v1/apps

You should see a response similar to this:

{
  "total": 1,
  "apps": [
    {
      "pid": 12847,
      "app_id": "gmail-12847",
      "app_name": "Gmail",
      "runtime": "v8",
      "probe_status": "active",
      "confidence": 0.97,
      "object_count": 23,
      "action_count": 5
    }
  ]
}

If probe_status is "attaching", wait a few seconds and try again. The cold probe typically completes within 3–90 seconds.

Performance Characteristics

Metric	Value
Accuracy	>99%
Fast-path poll latency	~50 ms
Actions per minute	~120
Cold probe duration	3–90 s
Expected confidence range	`0.95 – 0.99`

Reading V8 App State

Once Chrome is configured and the probe is active, you can read state from any detected application using the Python SDK.

import asyncio
import nelieo_nsp as nsp

async def main():
    async with nsp.NSPClient() as client:
        # Attach by app name — no PID needed
        session = await client.attach("Gmail")

        # Read structured state with typed helpers
        unread = session.get_int("inbox.unread_count")
        subject = session.get_str("inbox.emails[0].subject")
        sender = session.get_str("inbox.emails[0].from")

        print(f"Unread: {unread}")
        print(f"Latest email: '{subject}' from {sender}")

asyncio.run(main())

Before deploying an agent to production, work through the Security Guide to enable API key authentication and review the reversibility rules for irreversible_write actions such as send_reply.

Get Started

The Daemon

Runtime Probes

Security

Guides

Supported Applications

How the V8 Probe Works

Prerequisites

Setup

Performance Characteristics

Reading V8 App State

​Supported Applications

​How the V8 Probe Works

​Prerequisites

​Setup

​Performance Characteristics

​Reading V8 App State

Supported Applications

How the V8 Probe Works

Prerequisites

Setup

Performance Characteristics

Reading V8 App State