Teach it. Watch it learn. Export the proof.

engine: loading WASM…

This page runs the actual compiled NPCoT runtime — the same 130 KB Rust-to-WASM binary that ships to edge devices. Give it input/output examples — including multi-field data points and conditions — and it searches its program space, shows the discovered program in five languages, caches it as a verified skill, and refuses when no program explains your examples. Guard thresholds are mined from your data, never hardcoded.

1 · Teach a new skill from examples

Search space: field-combine × predicate guard × mined thresholds × transform × reduce × post-scale (tens of thousands of candidate programs, exhaustive, milliseconds). Offset fitted in closed form.

→
→

Discovered program appears here — working source in Rust, Python, JavaScript, C, and TypeScript, plus search stats and worst-case error across your examples.

2 · Consult the library

A consult is a cosine-similarity lookup over skill signatures — the production runtime keys on transformer hidden states. Drag the noise slider to corrupt the query and watch the gate refuse below 0.85.

parsed: [3, -1, 4, -1, 5, 9, -2, 6] · 8 points

Result

554.62 µs · js
23.000

rounded to integer: 23

Cached program

fn sum(points: &[[f32; 1]]) -> f32 {
    let mut acc: f32 = 0.0;
    for pt in points {
        let v = pt[0];
        acc += v;
    }
    acc
}

3 · The library is the asset

4 skills (0 taught this session)

  • ○ sum — acc += x
  • ○ mean — acc += x, / n
  • ○ max — acc = max(acc, x)
  • ○ dot_product — Σ x·y over (x,y) points

Exports use the lowest format the library needs: v2 when any skill uses records or guards, v3 when any skill is stateful. Older runtimes reject higher-format files cleanly instead of mis-executing them — a stateful program can never be silently run as a stateless fold.

Why this matters

  • The same loop — miss, synthesize, verify, cache — lifted Qwen3.5-4B to 85.98% HumanEval for $0.39 of GPU time (keyed on hidden states instead of dropdowns).
  • One discovered program → working code in 5 languages. The artifact is an IR, not a string.
  • Guard thresholds and constants are mined from your data — nothing hardcoded.
  • Static verifier proves termination + bounded output before caching.
  • Consults are deterministic, microsecond, zero-GPU.

4 · Teach it a stateful skill

Format v3: a skill is (state, input) → (state', output) — a per-step pipeline plus one persistent state cell. You teach it from a trace: a sequence of (input → expected output) steps, one per row, instead of a single target. This unlocks counters, debouncers, and resettable aggregates — interactive programs, not just stateless folds. Reset rules are mined from the trace data, never hardcoded.

Loading the WASM runtime…