НЕЙРОЛИНК ДЛЯ НИЩИХ: компьютер без чтения мыслей

TL;DR: чтобы получить интерфейс уровня BCI, не обязательно лезть в мозг. Нам часто достаточно читать следы намерения: мышцы, взгляд, жесты, голос, позу и физиологический контекст.

Эта статья выросла из ролика 8AAFFF с прекрасным названием I Built a Brain-Computer Interface (Without a Brain Scanner). Идея простая и очень инженерная: сделать интерфейс, который ощущается как BCI, но не пытается читать мозг напрямую.

Сначала я ожидал чего-то хардкорного: альтернативный биосигнал вместо EEG, куча фильтров, возможно, немного боли. Но автор сделал ход лучше: он убрал мозг из уравнения.

А нам правда обязательно читать мозг, чтобы понять намерение человека?

Может быть, достаточно читать следы намерения — в мышцах, взгляде, жестах, голосе, позе тела. Тогда задача превращается не в «прочитай мысли», а в: построить дешёвый, устойчивый и удобный контроллер человеческого намерения.

Это уже не совсем Brain-Computer Interface. Это Body-Computer Interface, Muscle-Computer Interface, Gaze-Computer Interface или, если собрать всё вместе, Human Intent Interface. Звучит скромнее, чем Neuralink на слайдах. Зато работает в реальности, а не только в питч-деке.

---

Почему классический BCI — это круто, но больно

BCI декодирует активность мозга в команды для компьютера. В медицине это огромное направление: нейропротезы речи уже синтезируют слова из мозговых паттернов почти в реальном времени, а парализованные пациенты получают канал коммуникации там, где раньше его не было.

Но если мы говорим о DIY-контроллере, AR/VR-интерфейсе, игре или pet-проекте, у BCI есть неприятные инженерные свойства:

1. Сигнал шумный: EEG с поверхности головы ловит мышцы, моргания, движения и плохой контакт.
2. Железо сложное: электроды, усилители, фильтрация, калибровка под пользователя.
3. Пользователь устаёт: управление «силой мысли» часто менее естественно, чем выглядит на демо.
4. Команд мало: получить много стабильных команд из неинвазивного EEG трудно.
5. Цена ошибки высокая: если система решила нажать delete, пока ты просто задумался, это уже не интерфейс.

Поэтому вопрос «а что если управлять не мозгом?» не звучит как отказ от BCI. Это нормальный инженерный вопрос: обязательно ли лезть в самое шумное место, или можно поймать тот же сигнал на выходе?

Это как дебажить не внутренности фреймворка, а API-ответ. Внутри может быть ад, но если endpoint стабилен — мы живём.

---

1. Gesture Control: управление жестами через камеру

Самая очевидная альтернатива BCI — жесты руками. Камера видит руку, модель находит ключевые точки, а мы превращаем позу руки в команду. MediaPipe Hand Landmarker находит 21 точку на руке: пальцы, суставы, ладонь. Из этого уже можно собрать язык управления.

открытая ладонь       → STOP
щипок пальцами        → SELECT
палец вверх           → CONFIRM
два пальца вперёд     → NAVIGATE
движение руки вправо  → NEXT

Python: распознаём pinch-жест через MediaPipe

Берём координаты кончиков большого и указательного пальцев. Если расстояние между ними ниже порога — это pinch.

import cv2, math
import mediapipe as mp

mp_hands = mp.solutions.hands
mp_draw  = mp.solutions.drawing_utils

def euclidean(a, b):
    return math.sqrt((a.x - b.x)**2 + (a.y - b.y)**2)

cap = cv2.VideoCapture(0)

with mp_hands.Hands(max_num_hands=1,
                    min_detection_confidence=0.7,
                    min_tracking_confidence=0.7) as hands:
    while True:
        ok, frame = cap.read()
        if not ok:
            break

        frame = cv2.flip(frame, 1)
        rgb   = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        result = hands.process(rgb)

        if result.multi_hand_landmarks:
            lm = result.multi_hand_landmarks[0].landmark
            dist = euclidean(lm[4], lm[8])

            if dist < 0.04:
                cv2.putText(frame, "PINCH: SELECT", (30, 60),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2)

            mp_draw.draw_landmarks(
                frame,
                result.multi_hand_landmarks[0],
                mp_hands.HAND_CONNECTIONS,
            )

        cv2.imshow("Gesture Controller", frame)
        if cv2.waitKey(1) & 0xFF == 27:
            break

cap.release()
cv2.destroyAllWindows()

Уже почти BCI по ощущению: никакой клавиатуры, просто жест — и система реагирует. Но это не мозг. Дебажится через обычный print(), а не через молитву богам нейрофизиологии.

---

2. EMG / sEMG: управление через мышцы

EMG измеряет электрическую активность мышц. sEMG — поверхностная версия: электроды на коже, без имплантов. Когда ты хочешь пошевелить пальцем, мозг отправляет сигнал к мышцам. Мышцы активируются — и это можно измерить.

То есть мы не читаем мозг напрямую. Мы читаем намерение на выходе из нервной системы. Поэтому EMG-браслеты выглядят как очень практичный путь к «почти BCI» для AR/VR, ассистивных интерфейсов и тихого управления устройствами.

import serial, time

PORT      = "/dev/ttyUSB0"
BAUD      = 115200
THRESHOLD = 620

ser = serial.Serial(PORT, BAUD, timeout=1)
time.sleep(2)

while True:
    line = ser.readline().decode("utf-8", errors="ignore").strip()
    if not line:
        continue
    try:
        value = int(line)
    except ValueError:
        continue

    if value > THRESHOLD:
        print("MUSCLE ACTIVATION → CLICK")
    else:
        print("relaxed")

Это учебная табуретка, но принцип правильный: мышечный сигнал → фильтр → порог или модель → команда.

Feature extraction + классификатор

from collections import deque
import numpy as np
from sklearn.ensemble import RandomForestClassifier

WINDOW = 64
buffer = deque(maxlen=WINDOW)

def extract_features(samples: list[float]) -> np.ndarray:
    x   = np.array(samples)
    mav = np.mean(np.abs(x))
    rms = np.sqrt(np.mean(x ** 2))
    var = np.var(x)
    return np.array([mav, rms, var])

X_train = [
    [0.12, 0.18, 0.02],
    [0.80, 0.91, 0.25],
    [0.45, 0.50, 0.10],
]
y_train = ["rest", "fist", "pinch"]

clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

features = np.array([[0.78, 0.88, 0.22]])
print(clf.predict(features)[0])

Для EMG классический ML часто выигрывает у тяжёлых архитектур: данных мало, паттерны хорошо разделимы, а latency важнее красоты модели.

---

3. Eye Tracking: управление взглядом

Мы часто смотрим туда, с чем хотим взаимодействовать. Eye-tracking давно используется в ассистивных технологиях: люди, которые не могут пользоваться руками, управляют компьютером глазами через системы вроде Tobii Dynavox.

Dwell-click: смотришь 0.7 секунды — срабатывает

import time

DWELL_TIME = 0.7
current_target: str | None = None
entered_at: float | None = None

def update_gaze(
    gaze_x: float,
    gaze_y: float,
    buttons: dict[str, tuple[int, int, int, int]],
) -> str | None:
    global current_target, entered_at

    target = None
    for btn_id, (x, y, w, h) in buttons.items():
        if x <= gaze_x <= x + w and y <= gaze_y <= y + h:
            target = btn_id
            break

    now = time.time()
    if target != current_target:
        current_target, entered_at = target, now
        return None

    if target is not None and now - entered_at >= DWELL_TIME:
        return f"CLICK:{target}"

    return None

Главная ловушка — Midas Touch: человек смотрит на объект, но это не всегда значит, что хочет нажать. Решение простое: взгляд выбирает, другой сигнал подтверждает.

gaze_target = "send_button"
emg_action  = "PINCH"

if gaze_target and emg_action == "PINCH":
    execute(f"SELECT:{gaze_target}")

---

4. EOG: глаза как биологический джойстик

EOG измеряет электрический потенциал при движении глаз. Камера не нужна: используются электроды вокруг глаз. Влево, вправо, вверх, вниз, моргание, двойное моргание, зажмуривание — минимальный набор команд уже есть.

def classify_eog(horizontal: float, vertical: float, blink: float) -> str:
    if blink > 0.8:
        return "BLINK"
    if horizontal >  0.5: return "LOOK_RIGHT"
    if horizontal < -0.5: return "LOOK_LEFT"
    if vertical   >  0.5: return "LOOK_UP"
    if vertical   < -0.5: return "LOOK_DOWN"
    return "CENTER"

Это полезно для простых меню, ассистивных интерфейсов, управления инвалидной коляской и hands-free режимов — особенно там, где камера недоступна или нежелательна.

---

5. Head Tracking: голова как контроллер

Голова тоже может быть контроллером: кивок → да, поворот → нет или назад, наклон → навигация. Реализуется через webcam, IMU, VR-шлем или смартфон.

def classify_head_pose(yaw: float, pitch: float, roll: float) -> str:
    if yaw   >  25: return "TURN_RIGHT"
    if yaw   < -25: return "TURN_LEFT"
    if pitch >  20: return "LOOK_DOWN"
    if pitch < -20: return "LOOK_UP"
    if abs(roll) > 20: return "TILT"
    return "CENTER"

Плюсы: дёшево, понятно, хорошо комбинируется с gaze и voice. Минусы: устаёт шея, мало команд, в общественном месте выглядишь так, будто споришь с невидимым налоговым инспектором.

---

6. Voice Control + LLM: голос как интерфейс намерения

Голос — самый недооценённый альтернативный BCI. Он не читает мозг, но иногда читает намерение лучше любого жеста.

микрофон → speech-to-text → intent parser → команда

естественная фраза → LLM выделяет намерение → система вызывает API

from dataclasses import dataclass

@dataclass
class Intent:
    action: str
    target: str | None = None
    params: dict | None = None

def parse_command(text: str) -> Intent:
    t = text.lower()

    if any(w in t for w in ("останов", "стоп", "stop")):
        return Intent(action="STOP")
    if "следующ" in t or "next" in t:
        return Intent(action="NEXT")
    if "назад" in t or "back" in t:
        return Intent(action="BACK")
    if "открой" in t and "заяв" in t:
        return Intent(action="OPEN", target="leads")

    return Intent(action="UNKNOWN", params={"raw": text})

LLM-based intent parser

SYSTEM_PROMPT = """
Ты получаешь команду пользователя и контекст интерфейса.
Верни ТОЛЬКО валидный JSON без пояснений и markdown-блоков.

Контекст:
  current_screen: crm.leads
  selected_object: leads_table
  available_actions: [filter, sort, open, create_task]
"""

USER_COMMAND = "Покажи только горячих и отсортируй по дате"

Голос хорош для сложных задач: «собери отчёт по новым лидам за неделю». Жесты и EMG — для быстрых атомарных команд: выбрать, отмена, вперёд. Вместе они закрывают весь диапазон.

---

7. IMU: акселерометр и гироскоп

IMU можно поставить в браслет, кольцо, перчатку, наушники или телефон. Он дешёвый, понятный и достаточно стабильный для жестов движения.

#include <Wire.h>
#include <MPU6050.h>

MPU6050 mpu;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  mpu.initialize();
}

void loop() {
  int16_t ax, ay, az, gx, gy, gz;
  mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);

  if      (gx >  12000) Serial.println("GESTURE:TURN_RIGHT");
  else if (gx < -12000) Serial.println("GESTURE:TURN_LEFT");
  else if (ay >  14000) Serial.println("GESTURE:TILT_UP");

  delay(20);
}

---

8. GSR, пульс, дыхание: не команды, а контекст

Некоторые сигналы плохо подходят для прямого управления, но хорошо описывают состояние пользователя.

GSR                  → стресс / возбуждение
пульс                → нагрузка / тревога
дыхание              → спокойствие / паника
температура кожи     → физиологический контекст

def estimate_stress(
    heart_rate: float,
    gsr: float,
    breathing_rate: float,
) -> float:
    score = 0.0
    if heart_rate     > 100: score += 0.4
    if gsr            > 0.7: score += 0.4
    if breathing_rate >  22: score += 0.2
    return min(score, 1.0)

stress = estimate_stress(heart_rate=108, gsr=0.82, breathing_rate=24)
if stress > 0.7:
    print("Switch UI to calm mode")

Если добавить эмоцию из текстового канала, получится мультимодальный emotional state: LLM может менять тон, длину ответов и уровень риска в зависимости от состояния пользователя.

---

9. Гибридный контроллер: нормальный путь

Главная ошибка — пытаться выбрать один идеальный способ управления. В реальности выигрывает гибрид.

глаза       → куда пользователь смотрит    (selection)
жест        → что он хочет сделать         (action)
EMG         → подтверждение микродействия  (confirmation)
голос       → сложная команда              (intent)
пульс/GSR   → эмоциональный контекст       (modulation)
LLM         → интерпретация намерения      (policy)

Event Bus: единый поток событий

from dataclasses import dataclass, field
from time import time
from typing import Callable

@dataclass
class InputEvent:
    source: str
    event: str
    confidence: float
    timestamp: float = field(default_factory=time)
    metadata: dict = field(default_factory=dict)

class EventBus:
    def __init__(self):
        self._subs: list[Callable[[InputEvent], None]] = []

    def subscribe(self, callback: Callable[[InputEvent], None]) -> None:
        self._subs.append(callback)

    def publish(self, event: InputEvent) -> None:
        for cb in self._subs:
            cb(event)

Fusion logic: приоритеты сигналов

from dataclasses import dataclass

@dataclass
class SignalState:
    gaze_target: str | None
    gesture: str | None
    emg_action: str | None
    voice_intent: str | None
    stress: float

def decide_action(s: SignalState) -> str:
    if s.voice_intent == "STOP" or s.gesture == "OPEN_PALM":
        return "STOP_CURRENT_ACTION"
    if s.gaze_target and s.emg_action == "PINCH":
        return f"SELECT:{s.gaze_target}"
    if s.voice_intent == "OPEN_LEADS":
        return "OPEN_VIEW:CRM_LEADS"
    if s.stress > 0.75:
        return "ASK_CONFIRMATION"
    return "NO_ACTION"

---

10. Где здесь LLM?

LLM не должен распознавать жесты. Для этого есть CV-модели, фильтры и классификаторы. LLM нужен выше уровнем: политика, планирование, объяснение и контекстные действия.

Низкий уровень:   EMG / gaze / gesture / voice
Средний уровень:  classifier / fusion / intent detection
Высокий уровень:  LLM policy / planning / explanation / context-aware action

Пример: пользователь смотрит на таблицу клиентов, делает pinch и говорит «оставь только горячих». LLM связывает контекст интерфейса, голосовую команду, историю действий и возвращает структурированный action.

{
  "action": "filter",
  "target": "leads_table",
  "filters": {"temperature": "hot"}
}

---

11. Этика: безопаснее, но не автоматически хорошо

Альтернативы BCI менее пугающие, чем чтение мозга, но это не делает их безобидными. Взгляд показывает интерес, пульс — реакцию, GSR — стресс, голос — эмоции, жесты — привычки, EMG — моторные паттерны.

1. Локальная обработка по умолчанию.
2. Минимум хранения сырых сигналов.
3. Явное согласие пользователя.
4. Возможность выключить каждый сенсор.
5. Логи действий, а не логи тела.
6. Никакого скрытого emotional profiling.

Иначе получится не интерфейс будущего, а очередная рекламная мясорубка: «мы поняли, что вы нервничаете, поэтому вот кредит под 49%».

---

Итоговое сравнение

---

Вывод

Самая сильная идея здесь — отказ от фетиша «читать мозг любой ценой». Мозг — не единственная точка входа. Намерение проявляется во взгляде, мышцах, жестах, голосе, позе, дыхании.

Если собрать эти сигналы вместе, получается интерфейс, который ощущается почти как BCI, но дешевле, проще, доступнее, безопаснее и лучше подходит для DIY и pet-проектов.

Не «компьютер читает мысли». А «компьютер понимает, что я пытаюсь сделать». Честно говоря, это даже круче.

Потому что чтение мыслей красиво на слайдах. А понимание намерения — это то, чем реально можно пользоваться.

// Источники

1. 8AAFFF — I Built a Brain-Computer Interface (Without a Brain Scanner)
2. Google MediaPipe Hand Landmarker
3. Meta / Reality Labs — wrist-based surface EMG research
4. Tobii Dynavox — eye tracking and gaze interaction
5. OpenBCI — EEG/EMG/ECG biosensing boards
6. NIH — BCI restores natural speech after paralysis

TL;DR: to get a BCI-like interface, you do not always need to read the brain. Often it is enough to read traces of intent: muscles, gaze, gestures, voice, posture and physiological context.

This article started with a video by 8AAFFF called I Built a Brain-Computer Interface (Without a Brain Scanner). The idea is elegantly simple: build an interface that feels like a BCI without trying to read the brain directly.

I expected something hardcore: alternative biosignals instead of EEG, a pile of filters, maybe a little pain. But the better move was removing the brain from the equation.

Do we actually need to read the brain to understand human intent?

Maybe we can read the traces of intent in muscles, gaze direction, gestures, speech and body posture. The task changes from “read thoughts” into: build a cheap, robust and ergonomic human intent controller.

This is no longer strictly a Brain-Computer Interface. It is a Body-Computer Interface, Muscle-Computer Interface, Gaze-Computer Interface or, if combined, a Human Intent Interface. Less hype than Neuralink in a slide deck. More useful in reality.

---

Why Classic BCI Is Cool but Painful

BCI decodes brain activity into computer commands. In medicine this is a breakthrough: neural speech prostheses can already synthesize words from brain patterns in near real time, giving paralyzed patients a communication channel where none existed before.

For DIY controllers, AR/VR interfaces, games or personal projects, classic BCI has practical problems:

1. The signal is noisy: scalp EEG sees muscles, blinks, motion and bad contact.
2. The hardware is complex: electrodes, amplifiers, filtering and per-user calibration.
3. Users get tired: “thought control” is often less natural than demos suggest.
4. Reliable command count is small for non-invasive EEG.
5. The cost of error is high: a false delete command is not a cute UX issue.

So “what if we skip the brain?” is not a rejection of BCI. It is engineering honesty: do we need to tap the noisiest possible signal, or can we catch the same intent downstream?

---

1. Gesture Control: Hand Gestures via Camera

The most accessible BCI alternative is hand gestures. A camera captures the hand, a model finds keypoints, and we map poses to commands. MediaPipe Hand Landmarker gives 21 hand landmarks: fingers, joints and palm.

open palm          → STOP
pinch              → SELECT
thumb up           → CONFIRM
two fingers        → NAVIGATE
hand swipe right   → NEXT

Python: detecting pinch with MediaPipe

import cv2, math
import mediapipe as mp

mp_hands = mp.solutions.hands
mp_draw  = mp.solutions.drawing_utils

def euclidean(a, b):
    return math.sqrt((a.x - b.x)**2 + (a.y - b.y)**2)

cap = cv2.VideoCapture(0)

with mp_hands.Hands(max_num_hands=1,
                    min_detection_confidence=0.7,
                    min_tracking_confidence=0.7) as hands:
    while True:
        ok, frame = cap.read()
        if not ok:
            break

        frame = cv2.flip(frame, 1)
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        result = hands.process(rgb)

        if result.multi_hand_landmarks:
            lm = result.multi_hand_landmarks[0].landmark
            dist = euclidean(lm[4], lm[8])

            if dist < 0.04:
                cv2.putText(frame, "PINCH: SELECT", (30, 60),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2)

        cv2.imshow("Gesture Controller", frame)
        if cv2.waitKey(1) & 0xFF == 27:
            break

It already feels almost like BCI: no keyboard, just a gesture and response. But it is not brain reading. You debug it with print(), not neurophysiology prayers.

---

2. EMG / sEMG: Muscle-Based Control

EMG measures electrical activity in muscles. Surface EMG does it non-invasively with electrodes on the skin. When you intend to move a finger, the brain sends a signal to muscles, and that activation is measurable.

import serial, time

PORT      = "/dev/ttyUSB0"
BAUD      = 115200
THRESHOLD = 620

ser = serial.Serial(PORT, BAUD, timeout=1)
time.sleep(2)

while True:
    line = ser.readline().decode("utf-8", errors="ignore").strip()
    if not line:
        continue
    try:
        value = int(line)
    except ValueError:
        continue

    print("MUSCLE ACTIVATION → CLICK" if value > THRESHOLD else "relaxed")

Real projects need feature extraction and a classifier. For EMG, classical ML is often enough because the datasets are small and the patterns are separable.

import numpy as np
from sklearn.ensemble import RandomForestClassifier

def extract_features(samples: list[float]) -> np.ndarray:
    x = np.array(samples)
    return np.array([
        np.mean(np.abs(x)),
        np.sqrt(np.mean(x ** 2)),
        np.var(x),
    ])

X_train = [[0.12, 0.18, 0.02], [0.80, 0.91, 0.25], [0.45, 0.50, 0.10]]
y_train = ["rest", "fist", "pinch"]

clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

---

3. Eye Tracking: Gaze-Based Control

We often look at what we want to interact with. Eye tracking has long been used in assistive technology, including systems that let people control computers entirely with gaze.

import time

DWELL_TIME = 0.7
current_target: str | None = None
entered_at: float | None = None

def update_gaze(gaze_x, gaze_y, buttons) -> str | None:
    global current_target, entered_at

    target = next(
        (bid for bid, (x, y, w, h) in buttons.items()
         if x <= gaze_x <= x + w and y <= gaze_y <= y + h),
        None,
    )

    now = time.time()
    if target != current_target:
        current_target, entered_at = target, now
        return None

    if target is not None and now - entered_at >= DWELL_TIME:
        return f"CLICK:{target}"

    return None

The trap is Midas Touch: looking at something does not always mean wanting to click it. Better design: gaze selects, body confirms.

---

4. EOG: Eyes as a Biological Joystick

EOG measures the electrical potential produced by eye movement. It does not need a camera, only electrodes around the eyes. Left, right, up, down, blink, double blink: a small but useful command set.

def classify_eog(horizontal: float, vertical: float, blink: float) -> str:
    if blink > 0.8:       return "BLINK"
    if horizontal >  0.5: return "LOOK_RIGHT"
    if horizontal < -0.5: return "LOOK_LEFT"
    if vertical   >  0.5: return "LOOK_UP"
    if vertical   < -0.5: return "LOOK_DOWN"
    return "CENTER"

---

5. Head Tracking: Head as Controller

Nod means yes, turn means no or back, tilt can navigate. It works with a webcam, IMU, VR headset or smartphone. Cheap and intuitive, but limited and tiring.

def classify_head_pose(yaw: float, pitch: float, roll: float) -> str:
    if yaw   >  25: return "TURN_RIGHT"
    if yaw   < -25: return "TURN_LEFT"
    if pitch >  20: return "LOOK_DOWN"
    if pitch < -20: return "LOOK_UP"
    if abs(roll) > 20: return "TILT"
    return "CENTER"

---

6. Voice Control + LLM: Speech as Intent Interface

Voice is the most underrated BCI alternative. It does not read the brain, but it often captures intent better than gestures, especially for multi-step tasks.

microphone → speech-to-text → intent parser → command
natural phrase → LLM extracts intent → system calls the right API

SYSTEM_PROMPT = """
You receive a user command and interface context.
Return ONLY valid JSON with no explanation or markdown fences.

Context:
  current_screen: crm.leads
  selected_object: leads_table
  available_actions: [filter, sort, open, create_task]
"""

USER_COMMAND = "Show only hot leads and sort by date"

Voice is excellent for high-level actions. Gestures and EMG handle fast atomic commands. Together they cover the useful bandwidth.

---

7. IMU: Accelerometer and Gyroscope

An IMU is cheap, simple and can live in a wristband, ring, glove, headphones or phone.

#include <Wire.h>
#include <MPU6050.h>

MPU6050 mpu;

void loop() {
  int16_t ax, ay, az, gx, gy, gz;
  mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);

  if      (gx >  12000) Serial.println("GESTURE:TURN_RIGHT");
  else if (gx < -12000) Serial.println("GESTURE:TURN_LEFT");
  else if (ay >  14000) Serial.println("GESTURE:TILT_UP");
}

---

8. GSR, Heart Rate, Breathing: State, Not Commands

Some signals are poor for direct control but excellent for understanding user state.

GSR                 → stress / arousal
heart rate          → load / anxiety
breathing           → calm / panic
skin temperature    → physiological context

def estimate_stress(heart_rate: float, gsr: float, breathing_rate: float) -> float:
    score = 0.0
    if heart_rate     > 100: score += 0.4
    if gsr            > 0.7: score += 0.4
    if breathing_rate >  22: score += 0.2
    return min(score, 1.0)

Combined with emotion from text, this becomes a multimodal affective interface: the LLM can adjust tone, response length and action risk.

---

9. Hybrid Controller: The Sensible Path

The biggest mistake is trying to pick one perfect modality. In practice, the hybrid wins.

eyes      → what the user looks at       (selection)
gesture   → what they want to do         (action)
EMG       → micro-action confirmation    (confirmation)
voice     → complex command              (intent)
pulse/GSR → emotional context            (modulation)
LLM       → intent interpretation        (policy)

from dataclasses import dataclass

@dataclass
class SignalState:
    gaze_target: str | None
    gesture: str | None
    emg_action: str | None
    voice_intent: str | None
    stress: float

def decide_action(s: SignalState) -> str:
    if s.voice_intent == "STOP" or s.gesture == "OPEN_PALM":
        return "STOP_CURRENT_ACTION"
    if s.gaze_target and s.emg_action == "PINCH":
        return f"SELECT:{s.gaze_target}"
    if s.voice_intent == "OPEN_LEADS":
        return "OPEN_VIEW:CRM_LEADS"
    if s.stress > 0.75:
        return "ASK_CONFIRMATION"
    return "NO_ACTION"

---

10. Where Does LLM Fit?

The LLM should not classify gestures. CV models, filters and classifiers do that. The LLM belongs higher up: policy, planning, explanation and context-aware action.

Low level:    EMG / gaze / gesture / voice
Middle level: classifier / fusion / intent detection
High level:   LLM policy / planning / explanation / context-aware action

---

11. Ethics: Safer, But Not Automatically Good

BCI alternatives are less alarming than brain reading, but they still collect sensitive data: gaze reveals interest, pulse reveals arousal, GSR reveals stress, voice reveals emotion, gestures reveal habits and EMG reveals motor patterns.

1. Local processing by default.
2. Minimal retention of raw signals.
3. Explicit user consent.
4. Ability to disable each sensor individually.
5. Log actions, not bodies.
6. No covert emotional profiling.

---

Comparison Table

---

Conclusion

The strongest idea here is abandoning the fetish of “read the brain at any cost”. The brain is not the only entry point. Human intent surfaces in gaze, muscles, gestures, voice, posture and breathing.

Not “the computer reads thoughts”. But “the computer understands what I am trying to do”. Honestly, that is even better.

Mind reading looks great on slides. Understanding intent is something you can actually ship.

// References

1. 8AAFFF — I Built a Brain-Computer Interface (Without a Brain Scanner)
2. Google MediaPipe Hand Landmarker
3. Meta / Reality Labs — wrist-based surface EMG research
4. Tobii Dynavox — eye tracking and gaze interaction
5. OpenBCI — EEG/EMG/ECG biosensing boards
6. NIH — BCI restores natural speech after paralysis