The model, its methods
and the token launch record.

Zebrafish Neural connects real browser screenshots to an eight-state model and applies its motor output to the cursor. The shared experiment continues on Wikipedia; a separate laboratory provides controlled stimuli. The operator launched $ZNEURO on Pons on 11 September 2026. The launch record identifies its contract and confirmed transaction. The neural controller did not create or sign the token launch.

Controlled laboratory sessions

1. Open the laboratory. The controller starts automatically with a moving visual target.
2. Compare the retinal image, model states, trajectory and motor time series. The model continues beyond 60 seconds.
3. Pause to change stimulus or contrast, then Resume. Restart clears state and recording; a running session continues and a paused session stays paused.
4. Export JSON or CSV at any time. Exports retain only the latest 60 model seconds, with original session timestamps.
5. Use Population model to inspect simulated activity, or ZAPBench anatomy to examine measured cell positions independently.

The session suspends when the tab is hidden and resumes when visible unless manually paused. Closing or reloading the laboratory ends that local session. This does not affect the shared live controller. Continuous execution does not imply continuous movement: no stimulus produces no activity, and the looming shadow is a single presentation.

Drag the brain view or use arrow keys to rotate. The mouse wheel and +/− keys control zoom. Data stay in browser memory until exported.

Shared browser controller

The Live page observes one Node.js process and one isolated Chromium browser on the operator's computer. Opening another viewer does not create another model. Closing a viewer does not stop the process. The computer must remain awake and connected to the internet.

Input and dynamics

Chromium captures a real 1,120 × 700 pixel viewport approximately twice per second. The adapter decodes the screenshot to grayscale and samples a 32 × 16 retinal field centered on the last applied cursor position and oriented with its heading. The field spans 320 pixels laterally and from 35 pixels behind to 165 pixels ahead. Sampling clamps at viewport boundaries.

The absolute difference from a 3 × 3 local mean supplies contrast. The mean contrast in each half of the retina is multiplied by 6; central contrast is multiplied by 4. Features are clamped to 0–1. Uniform white or black images therefore do not create visual drive. Threat input is zero; this adapter does not detect looming objects.

The existing eight-state population equations advance with fixed 20 ms steps in a server timer. The latest visual observation is held between captures. A slow host caps accumulated wall time rather than taking unstable integration steps; model time and process uptime are displayed separately.

Cursor and click mapping

The model's kinematic body coordinates map directly to viewport cursor coordinates. The applied cursor, heading, and source frame identify the next observation. The interface's cursor marker is an overlay showing the applied browser position; it is not included in the neural input.

A click is proposed after central contrast remains above 0.06, spinal drive exceeds 0.025, and the absolute motor-rate difference stays below 0.08 for 1.2 model seconds. Proposals have an eight-model-second cooldown. Each proposal retains its decision coordinates, model time, and input frame identifier. These thresholds are human-designed parameters, not inferred biological behavior.

The browser accepts a proposal only when the point is an ordinary article link on the permitted domain. A rejected proposal is recorded. Motor activity near the top or bottom edge can drive a scroll, with a four-second wall-clock cooldown.

Assistance and boundaries

The operator supplies the initial set of Wikipedia articles. The adapter rotates to the next article after three wall-clock minutes, independently of the model. These rotations are marked assistance, separately from controller clicks and scrolls. The model has no instruction to read, understand, or choose an article topic.

Navigation requests and redirects are restricted to HTTPS English Wikipedia article URLs. Account pages, namespaces, query-based actions, forms, downloads, popups, and non-GET requests are excluded. The browser uses a fresh context without the operator's accounts, wallet, or extensions. It has no typing or transaction-signing action.

Stream and recovery

The shared service publishes real screenshots, retinal input, rates, applied cursor position, page URL, model time, session ID, and recent events over a read-only WebSocket. Spectators cannot pause, restart, or command the controller. Slow subscribers are disconnected rather than blocking the model.

Input older than four seconds suspends model actions. Navigation invalidates the prior observation; captures spanning a document change are discarded. The frontend marks delayed or disconnected streams and automatically reconnects. It never substitutes synthetic motion for missing live data.

The runtime saves population rates, body position, model time, step count, and click cooldown approximately every ten seconds. A browser failure triggers recovery. A process restart can resume a compatible checkpoint, but observation-dependent dwell and recent sample history begin again. The session ID changes when the process restarts.

Recording and connection

The download contains the latest 60 model seconds and recent events, with original model timestamps and frame references. Event files and a checkpoint are kept on the host. This is a recent-run export rather than a complete historical screenshot archive. The operator's manual token launch is documented separately in the token launch record.

The current operator-computer deployment uses a temporary HTTPS tunnel for the read-only feed. The model continues without viewers while the host and tunnel are running. Restarting the tunnel may change its address; the website's live-feed configuration must then be updated. A stable always-on deployment requires a persistent server and hostname.

The separate Laboratory page retains controlled synthetic-stimulus experiments. Its local browser session is independent of the shared live controller.

Implemented and pending

Shared browser capture, contrast encoding, neural cursor movement, permitted link clicks, streaming, event logs, and checkpoint resume are implemented. The controller is an eight-state zebrafish-inspired model; it is not a reconstructed whole brain. ZAPBench anatomy remains a separate measured reference.

$ZNEURO was launched manually by the project operator on Pons; its creation transaction is confirmed on Robinhood Chain. The shared Wikipedia experiment continues independently. Pons screen input, token-form execution, wallet access, and transaction signing are not connected to this runtime. The controller did not create the token and cannot create or trade tokens through the current article browser.

Token launch record

Project: Zebrafish Neural · Ticker: $ZNEURO · Updates: @zebrafishneural

Operator launch

The project operator launched ZNEURO manually on Pons. Its creation transaction is confirmed on Robinhood Chain. The neural controller did not create the token or authorize the transaction.

• Official Pons token page
• Confirmed creation transaction

The transaction receipt and token readouts were checked through Robinhood Chain RPC. This confirms the recorded transaction and token metadata. Contract source code is not explorer-verified, and no contract audit is claimed.

Relationship to the browser experiment

The shared controller continues to receive real Chromium screenshots and operate permitted Wikipedia article pages. Its eight-state model drives cursor movement, gated link clicks, and scrolling. Operator-supplied article rotations are recorded separately as assistance.

The operator computer runs this experiment independently of viewers. The website streams its browser frames, retinal input, model rates, and action events. The separate laboratory provides controlled synthetic-stimulus experiments and measured anatomy inspection.

The manual token launch does not establish that a neural model caused a blockchain action. Runtime recordings describe the Wikipedia experiment; the creation receipt documents the operator's token launch.

Experimental evidence

Further work focuses on reproducible browser experiments: recording input frames, observation poses, model outputs, proposed actions, applied actions, and assistance with aligned identifiers and timestamps. Replays and controls with model output disabled can test which browser actions depend on the controller.

A recording hash identifies an artifact but does not establish causation. Conclusions should follow the recorded action chain and the relevant control experiment.

Biological scope

The controller uses eight population states with hand-set parameters. It has not been fitted to biological activity and is not a complete reconstructed zebrafish brain. The 71,721 measured ZAPBench cell centroids are an independent anatomy reference and do not drive the model. The project token does not change those scientific limits.

Model specification

Version: zebra-rate-0.1.0

This reduced population model supports controlled software experiments with a visual–motor feedback loop. All coefficients are design parameters. The model has not been fitted to zebrafish physiology, calcium activity, or synaptic connectivity.

State and numerical update

The state contains eight rates r_i ∈ [0,1], fish position (x,y), heading θ, and simulation time. Rates are continuous and dimensionless; they do not represent measured spikes or firing frequencies in hertz.

The interface advances the model with fixed Δt = 0.02 s Euler steps. With clip denoting restriction to [0,1]:

u_i  = clip(drive_i + 0.10 r_i)
r_i' = clip(r_i + Δt/τ_i × (u_i − r_i))

All drives are calculated from the previous rates before any rate is updated. No stochastic network noise is used. Rendering and simulation clocks are separate: slow rendering reduces progress relative to wall time rather than increasing the numerical step size or skipping state updates.

These names describe model functions. They do not identify measured cell populations in the centroid dataset.

Laboratory visual encoding

The shared live controller uses contrast from real browser screenshots, as specified in the shared-controller methods. The encoder below applies to the separate controlled laboratory. Both input adapters feed the same eight-state population equations.

The 32 × 16 retinal image is generated analytically from target bearing, distance, and size using a Gaussian contrast profile. It is not a screenshot of the rendered arena. Changes in fish pose affect the next observation.

Contrast is summed over each half of the image and over a central strip. The resulting features are:

L = clip(19 × left_contrast_sum / 512)
R = clip(19 × right_contrast_sum / 512)
C = clip( 9 × center_contrast_sum / 512)
E = clip( 5 × total_contrast_sum / 512)  [looming only; otherwise 0]

The central strip contains samples with normalized horizontal coordinate |px| < 0.16. The baseline luminance is 0.05 for bright targets and 0.78 for the looming condition. Bright-target contrast is luminance above baseline; looming contrast is the luminance deficit below baseline. Intensity ranges from 0 to 1.

For looming, the Gaussian radius increases from 0.10 to 0.58 over 1.5 seconds; its contrast fades between 2.3 and 3 seconds. The moving target changes position over time, but the encoder has no separate temporal motion detector. These visual conventions are designed inputs, not a physiological retinal model.

Population drives

Let g = 1 − 0.7C(1 − E):

drive0 = L
drive1 = R
drive2 = 0.50r0
drive3 = 0.50r1
drive4 = 0.45(r0 + r1)

non-looming:
drive5 = g*r0     + 0.12r2 + 0.08r4
drive6 = g*r1     + 0.12r3 + 0.08r4

looming:
drive5 = g*1.8*r1 + 0.12r3 + 0.08r4
drive6 = g*1.8*r0 + 0.12r2 + 0.08r4

drive7 = 0.55(r5 + r6) + 0.25E

The looming condition selects crossed visual and integrator routing from the start of the experiment. This is an explicit aversive control rule chosen by the model author. It is neither a learned association nor a circuit inferred from a connectome.

Kinematics

angular velocity ω = 3.2(r6 − r5) rad/s
forward speed    v = 0.15r7 arena units/s

Heading is updated before position. Positive y points downward in the arena. The position is confined to x ∈ [0.045,0.955] and y ∈ [0.055,0.945]; a boundary encounter reflects the heading. Position uses normalized arena coordinates rather than millimeters. Muscle dynamics, hydrodynamic forces, and body biomechanics are not modeled.

Visualization and provenance

In the schematic view, the brightness of 5,220 drawing points is derived from eight model rates. These points do not have independent neural states. The measured-geometry view displays ZAPBench cell positions with neutral coloring and no activity assignment. The bundled centroid asset contains no region labels or connectivity.

Recording and reproducibility

This section describes laboratory recordings. The shared runtime adds browser frame identifiers, action events, host checkpoints, and its own recording endpoint.

The initial state is x=0.5, y=0.75, θ=−π/2, with all rates zero. The browser session starts automatically with the moving-target stimulus at contrast 0.7, and continues beyond 60 model seconds without restarting the state. The population model is the initial view; measured anatomy remains available separately.

Pause enables the stimulus and intensity controls. Changing either resets the state and recording while retaining the pause. Restart also resets state and recording: a running session continues automatically, and a paused session stays paused. The simulation suspends while its tab is hidden and automatically resumes when visible unless manually paused. It does not advance hidden wall time on return. Reloading or closing the page ends the browser session; no persistent server runs the model.

Samples are recorded every five model steps, or 0.1 s. Both the recording and the displayed trajectory use a rolling buffer of at most 600 samples, retaining the latest 60 model seconds. Old samples expire without resetting the model. JSON exports use schema version 2 and include the model version, configuration, time step, sample interval, totalSteps, units, provenance and samples. durationSeconds is total elapsed model time; recording.startTimeSeconds and recording.endTimeSeconds identify the retained interval, which may omit earlier session history. CSV exports contain time, pose, speed, angular velocity, and the eight rates, using the original session timestamps. Keep the JSON file with the CSV: the CSV does not carry configuration or provenance.

An experiment can be reproduced in code from its initial state with makeState(config) and repeated step calls using the same model version and total step count; then select the exported time interval. The interface does not yet import JSON recordings. Reproduction concerns the simulated trajectory and sampled values, not the export creation timestamp.

Continuous stepping does not imply constant activity or motion. The dark condition remains silent, and looming is a single presentation that fades after three model seconds. Restart repeats that presentation; the session does not silently cycle stimuli.

Validation

npm test covers zero-contrast behavior, mirror symmetry, the designed looming avoidance rule, bounded state over 60 seconds, deterministic and chunked execution, pose-dependent retinal input, CSV columns, invalid time steps, and centroid count/checksum integrity. Session checks cover automatic start, ten minutes of uninterrupted model time with bounded recording, visibility suspension, manual pause, restart behavior and slow-frame timing.

These checks evaluate implementation behavior and data integrity. No calcium fit, spike-prediction benchmark, or biological whole-brain validation has been performed.

Data provenance

Included geometry: ZAPBench

The application includes 71,721 measured cell centroids derived from segmentation of functional imaging in ZAPBench. They are displayed as a separate geometry layer. The bundled asset contains no activity traces, connectivity, or anatomical region labels.

The local binary dist/data/zapbench-centroids-71721.f32 contains 860,652 bytes: interleaved x,y,z coordinates stored as little-endian float32 with no header. Zero-based row i corresponds to segmentation label i+1. All source positions and their ordering are retained; conversion from the source JSON to float32 reduces numerical precision.

Coordinates

The file preserves the official Fluroglancer viewer coordinates in micrometers. The documented transformation from the native segmentation volume is:

x_um =  (native_y_voxel − 664)  × 0.406
y_um = −(native_x_voxel − 1024) × 0.406
z_um =  (native_z_voxel − 36)   × 4

The manifest records agreement with an independently reconstructed centroid for segmentation label 1 and links the native volume metadata. Anatomical axis signs were not established by the retrieved metadata. The viewer preserves the source coordinate orientation without assigning left/right, rostral/caudal, or dorsal/ventral labels.

For display, the application subtracts the cloud's bounding-box center and scales its largest axis extent to 3.4 rendering units. This view transformation leaves the physical coordinates in the binary file unchanged.

Relationship to the model

The eight-population model receives contrast from real browser screenshots in the shared live controller and synthetic retinal input in the controlled laboratory. It does not load the centroid file, infer connections from spatial proximity, or map model rates onto measured cells. No parameters have been fitted to biological calcium recordings.

Geometry, activity, and connectivity have independent provenance. A measured geometry layer does not establish the origin or validity of a dynamic model.

Candidate extensions

mapZebrain is a candidate source for regional annotations and neuronal morphologies. No mapZebrain atlas is bundled in v0.1.

ZAPBench activity traces could support a separate recording-playback mode and later model evaluation. A comparison between calcium fluorescence and normalized model rates requires an explicit observation model, preprocessing description, and separation of fitting and evaluation data.

FLYBRAIN and flycoinrh provide an interaction reference. Their code and fly data files have not been copied. No cross-species equivalence of neuron labels or neurotransmitter assignments is assumed.

Attribution

ZAPBench activity was acquired by Alex Bo-Yuan Chen in the Ahrens lab, HHMI Janelia. Segmentation annotations are credited to the CellMap Project Team, HHMI Janelia; processing, alignment, segmentation, and trace extraction to Google Research. The derivative retains the dataset's CC BY 4.0 license, independently of the application's MIT code license. See NOTICE and the manifest for the complete provenance record.

Research and development plan

Current baseline

The shared live controller runs in a Node.js process with Chromium, screenshot input, model-driven cursor actions, event recording, and checkpoint resume. It operates permitted Wikipedia articles on the operator computer. A separate laboratory provides a deterministic synthetic visual–motor loop, a virtual arena, activity export, and an independent measured-centroid view.

The operator has launched the project token, ZNEURO, manually on Pons. The confirmed creation transaction is documented in the token launch record. The controller did not perform that launch. Pons input, token-form execution, and signing remain outside the current runtime.

Next milestone: reproducible browser experiments

Package recorded visual inputs, observation poses, model state, proposed actions, applied actions, and assistance into an aligned experiment record. Identify the model and adapter versions, viewport, preprocessing parameters, frame identifiers, and action timing.

Replay recorded inputs to check reproducibility of model outputs and action proposals. Compare ordinary operation with controls that disable motor output or change the input. Report the role of operator-supplied starting pages and scheduled article rotations separately from controller actions.

Controlled browser evaluation

Use reproducible page layouts and documented visual targets to measure steering, action timing, link-selection outcomes, and sensitivity to contrast. Establish how stale frames, navigation, and recovery affect behavior. These tests evaluate the engineered controller; they do not establish semantic understanding of a web page.

The next infrastructure work is a stable feed hostname and an explicit uptime/restart arrangement. Any move from the operator computer to a separate host should preserve model state, data provenance, and the distinction between host uptime and model time.

Measured activity playback

Select a small ZAPBench recording interval and package it as a separate recording adapter with its source, license, sample interval, and processing history. Display recorded activity with its own time axis and provenance, distinguishable from a running simulation.

Completion requires a reproducible extraction procedure, a data manifest, and a verified mapping between included traces and their cell identifiers. The existing population model should not be presented as the source of the recorded activity.

Comparison with experimental data

Establish stimulus timing, cell or regional correspondence, and a calcium observation model before fitting parameters. Separate fitting and evaluation intervals, specify temporal and behavioral metrics, and report failed as well as successful model predictions. Benchmark results should identify the exact model and dataset versions used.

Anatomical constraints

Evaluate coordinate registration and regional labels from mapZebrain. Extend network topology only where suitable connectivity evidence is available. Record unsupported connections as assumptions and retain the distinction between morphological overlap and confirmed synaptic connectivity.

Open development

Source code and methods are published in zebrafishneural/zebrafish-neural. The included GitHub Actions workflow runs npm test and npm run check. Issues can follow the browser-recording, controlled-evaluation, infrastructure, measured-playback, and anatomical-registration milestones above.