DEV Community: Nathan Roll

We taught a fruit fly to hear human emotion

Nathan Roll — Tue, 08 Sep 2026 13:58:57 +0000

We copied the connections between 499 reconstructed fruit-fly neurons into software and fed the resulting network human voices. A small output layer learned to predict labels listeners had assigned to those recordings. The fly circuit stayed fixed throughout training.

This was a computational experiment with an artificial input pathway and simplified neuron dynamics. No living fly learned to recognize human feelings.

Disclosure: I'm a cofounder of Oruk, where this experiment was conducted. This adaptation was prepared by an AI agent from our published research article and checked against its reported methods and results. The experiment has not been peer reviewed.

The MaleCNS reconstruction supplies neuron shapes and connection tables. We selected a strongly connected group: every neuron can reach every other through some directed path. It contains 15,865 connections supported by 867,344 synaptic contacts.

More contacts produce stronger model weights. Neurotransmitter annotations supply positive or negative signs, followed by global spectral scaling. These are modeling assumptions; the wiring diagram alone cannot recreate each cell's physiology.

That recurrent wiring gives the network a short memory. Every 10 milliseconds, a new frame of audio enters through a fixed random projection. Each neuron combines its neighbors' previous activity with the incoming sound and retains some of its previous state:

x[t] = (1 - alpha) * x[t-1]
       + alpha * tanh(W @ x[t-1] + W_in @ u[t])

Here, u[t] contains 32 log-mel audio bands, x[t] contains 499 neuron states, and both weight matrices stay fixed. The interactive model uses alpha = 0.15 and a target recurrent spectral radius of 0.9.

This is reservoir computing. Suárez and colleagues developed conn2res to explore biological connectomes this way; Costi and colleagues have used fly connectivity for time-series prediction. We applied the approach to listener judgments of speech.

We resample audio to 8 kHz, use 25 ms analysis windows, and normalize features using training frames. Four successive temporal averages turn the circuit's activity into 1,996 features. Another 128 features summarize the audio directly. Both branches enter the learned ridge readout:

features = concatenate(pooled_neuron_states, pooled_audio)
scores = features @ beta + bias

Only beta and bias are learned. The output has 15 emotion labels and 16 speaking styles. The direct audio branch matters: useful predictions can come from acoustic features without passing through the fly circuit.

Training used 16,995 clips, validation 2,239, and testing 2,022. Known speakers stay within one split; when speaker identity is unreliable, the entire source corpus stays together. Exact duplicate audio does not cross splits. Most recordings have one listener rating, which limits what their labels can establish.

The decisive comparison was scrambled wiring. We shuffled connection destinations while preserving each source neuron's outgoing count, signs and weight values before rescaling, then selected settings and trained a separate readout. We also tested audio-only and disconnected-circuit controls.

Model	Test mean average precision
Fly wiring	16.84%
Scrambled wiring	16.88%
Constant scores	9.71%

Mean average precision measures ranking across the 31 labels; it is not classification accuracy. The fly-minus-scrambled difference was −0.04 percentage points, with a 95% interval of −0.16 to +0.07. The comparison averages three seeds; intervals use paired bootstrap resamples of 45 held-out speaker/corpus groups. These results provide no evidence that the fly's particular wiring helped on this split.

The interactive article also lets you silence neurons while holding the fitted readout fixed. Removing the 50 highest-ranked neurons drops that model's test mAP from 16.91% to 10.83%. Its starting score differs from the table because this intervention uses one model, rather than the three-seed mean.

That readout depends on its circuit's features. Destroying those features after training can hurt even when a different circuit, trained separately, works equally well. The intervention and scrambled control therefore answer different questions.

You can rotate the reconstructed neurons, compare six licensed demonstration recordings and rerun the intervention in the original article. The clips differ in speakers and words as well as listener labels; colored activity is not evidence of biological “emotion cells.” Those interactive figures cannot run inside this DEV post.

The fitted demonstration model and six excerpts are public. The full speech-labeling dataset and listener records remain private, so this is not a fully reproducible public benchmark. The fly circuit is an exploratory model, separate from Oruk's production speech API.

Build a local call-review panel with Python

Nathan Roll — Tue, 08 Sep 2026 01:31:19 +0000

An audio analysis response is easier to inspect when you can hear the passage beside its transcript. This tutorial builds a local review page that lets you replay a speaker turn, search the words or annotations, and read vocal-expression scores separately from what was said.

We will start with an actual saved response and a licensed public recording. That path needs Python and a browser, but no API key, model download, or inference request. Then we will connect the same page to the Oruk Python SDK for your own recordings.

Disclosure: this example is maintained by Oruk, the API provider. The article and implementation were prepared with an AI coding agent and checked with automated tests and browser playback tests. The sample demonstrates an integration; it is not an accuracy evaluation or a customer case study.

Run the saved example

You need Python 3.10 or later, curl, and a current browser. The complete renderer uses Python's standard library. It generates an HTML file with a native audio player, plain JavaScript controls, and no third-party scripts or fonts.

mkdir oruk-call-review
cd oruk-call-review
curl --fail --location -o call-review.py https://oruk.ai/examples/call-review.py
curl --fail --location -o response.json https://oruk.ai/samples/conversations/02-grocery-prices.oruk.json
curl --fail --location -o recording.wav https://oruk.ai/samples/conversations/02-grocery-prices.wav
curl --fail --location -o attribution.txt https://oruk.ai/examples/call-review-attribution.txt
python3 call-review.py --response response.json --audio recording.wav --output review.html --attribution-file attribution.txt

Open review.html in your browser. Keep recording.wav next to it. On Windows, use your Python launcher if python3 is not available.

The 14.45-second grocery conversation comes from The Agentic Data Company's Open Yap 1K public sample, licensed under CC BY 4.0. Oruk excerpted and downmixed it. The attribution file is included in the generated report; preserve it when sharing the sample. Other demo recordings can have different permissions.

The complete program is available under the MIT license. The saved JSON contains the model's original output, not substitute scores written for this tutorial.

Check the result before adding an API call

The page has four passages. The first runs from 0.185 to 4.325 seconds and has the local label speaker_0. Its transcript begins:

I'm sorry. The price of food has gone up so much.

The returned emotion annotation is disappointed, with a score of 0.868 when rounded. The speaking-style annotation is casual, with a rounded score of 0.869. The report displays them in separate lists below the words.

Press Play passage 1 to replay that interval. Playback pauses near the returned end time. Choose Play from here without stopping when you want to hear the surrounding context. Searching frustrated should leave two passages visible; clearing the search restores all four. Filtering reads the existing response and does not call the model.

There is a useful limitation in this example: its words arrays are empty. The response provides speaker-turn boundaries, not individual word timing. The page says that explicitly. If another response includes word timestamps, a details control exposes those returned values and lets you replay a word. It never assigns timestamps by dividing a passage's duration by its word count.

Analyze your own recording

For a fresh analysis, use an English recording you have permission to process, up to 30 MB and 60 minutes. Create a key through your Oruk account and set ORUK_API_KEY in your environment. The live API uses the current subscription terms; the saved-data example above does not require a subscription.

This command reuses the SDK's existing complete file example rather than introducing another upload implementation:

python3 -m venv .venv
# macOS / Linux; on Windows use .venv\Scripts\activate
source .venv/bin/activate
python -m pip install oruk==0.2.6
curl --fail --location -o analyze-file.py https://oruk.ai/examples/analyze-file.py

# Set ORUK_API_KEY in the environment before this command.
python analyze-file.py my-recording.wav --diarize > my-response.json && \
  python call-review.py --response my-response.json --audio my-recording.wav --output my-review.html

The renderer runs only if analysis succeeds. It reads the saved file; it does not upload or analyze the recording again. Do not attach the grocery sample's attribution to your own audio. You can supply your own source note with --attribution-file.

If you already have a Python application, use this request-and-save step instead of the analyze-file.py command:

import json
import os
from pathlib import Path
from oruk import Oruk

with Oruk(api_key=os.environ["ORUK_API_KEY"]) as client:
    result = client.analyze(
        "my-recording.wav",
        model="oruk-resonance",
        diarize=True,
    )

Path("my-response.json").write_text(
    json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8"
)

Choose the CLI or this snippet. Running both makes two logical requests. Unified analysis returns the transcript, emotion, and speaking style together; separate transcription and affect calls would process the audio separately.

diarize=True makes the segments speaker turns. Leave num_speakers unset unless you know the number of speakers. The labels belong to that recording; speaker_0 does not mean “customer,” “agent,” or a persistent identity. These SDK calls use the recorded-file API, not the separate realtime WebSocket preview.

Keep the fields separate

The report is built around a small data model:

for segment in result["segments"]:
    print(segment["start"], segment["end"], segment.get("speaker"))
    print("Words:", segment.get("text"))
    print("Emotion scores:", segment.get("emotions"))
    print("Style scores:", segment.get("styles"))
    for word in segment.get("words") or []:
        print(word["word"], word["start"], word["end"])

text is a model transcript and can contain transcription errors. emotions and styles contain selected acoustic model scores. They describe model support for how speech sounds; they do not reveal a person's private feelings or intent.

Several labels can coexist. Their scores need not sum to one, and the numbers are not automatically calibrated probabilities. Emotion output includes the highest-scoring label when none meets its selection threshold. An empty style list means no style was returned, which does not establish absence. See the score interpretation reference before designing application thresholds.

The report keeps the returned order and values, displays three decimal places, and preserves the full score in the meter value and numeric tooltip. It does not turn a high score into a customer-risk verdict or rank a speaker's performance.

Replay from the browser's media clock

The essential interaction is a seek followed by playback:

audio.currentTime = start;
await audio.play();

The complete program also tracks the chosen end time, checks that boundary while playback is running, and pauses near it. It stops that animation-frame check when paused. Native seeking outside the selected interval releases the stop boundary. Highlighting uses audio.currentTime, so it follows the recording rather than a separate elapsed-time timer. Overlapping intervals can both be active.

These boundaries are useful for reviewing a passage. They are not sample-accurate editing cuts. Browser media clocks and seek precision impose limits.

The renderer escapes transcript text, labels, titles, and source notes before inserting them into HTML. It does not inject a tagged transcript as executable markup. Its Content Security Policy permits the generated script and style by hash, allows local media, and blocks network connections. The generated report has no analytics or API calls.

Handle the failures a reviewer will encounter

Invalid credentials or a rejected request: the SDK CLI exits unsuccessfully, with the HTTP status, code, and request ID on stderr. An empty stdout file is not a successful response.
Temporary service errors: SDK 0.2.6 retries HTTP 429, 500, 502, 503, and 504 up to twice. It reuses a request ID for tracing, which does not establish exactly-once processing. Python network and timeout errors propagate. Do not add an unbounded retry loop.
Malformed saved data: the renderer rejects API error objects, unsupported tasks, invalid intervals, and non-finite or out-of-range scores before writing the report. It refuses to overwrite its input files.
Empty segments or missing scores: the page says what was not provided. The full transcript remains available even when there are no timed passages.
The wrong or missing recording: the page reports loading/playback errors and warns if the audio duration differs from the response. Equal durations cannot prove two files belong together; use the exact recording that produced the response.

Keep the report's relative audio path intact when moving files. The HTML contains the transcript, even though it never contains the API key. Treat the report and recording under the same permissions and access controls.

This is a local review tool, not an authenticated multi-user application. A team version needs recording permissions, reviewer access, storage and retention rules, and representative evaluation before introducing any automatic triage threshold. The small example provides a place to inspect those decisions against the original audio.

Further reference: speaker diarization, SDK setup and errors, and analysis response fields.