jev integration

structured decision-making for a hybrid nervous system

the hybrid does not think in language. it fires neurons, accumulates state, and needs to decide what to do. we gave it a decision engine that returns typed values with calibrated probabilities instead of generated text.

the problem

a 47-neuron hybrid nervous system produces continuous neural state at 100ms intervals. membrane potentials, spike rates, cross-species correlations. raw numbers. the system needs to convert this into behavior: approach, retreat, observe, hesitate.

LLMs are wrong for this. they generate text for humans. the hybrid is not a human. it needs typed decisions with confidence scores that map directly to motor output. a probability distribution over actions, not a paragraph explaining why it should maybe consider moving forward.

what jev is

jev is TypeSafe's System One model. it does not generate text. it returns structured values with calibrated probabilities. three primitives, each purpose-built for decision-making.

the reflex arc pipeline

every 100 milliseconds, the hybrid runs a decision cycle. neural state flows through jev, and the output maps to physical motor behavior on the robot body.

  47 LIF neurons (100ms tick)
          |
          v
  extract neural state
  [membrane potentials, spike rates,
   bridge coherence, motor drive]
          |
          v
  jev evaluates (4 questions)
          |
          v
  structured decision
  [action + confidence + distribution]
          |
          v
  motor output mapping
          |
    +-----+-----+
    |             |
    v             v
  RTDB          OhBot
  (state)       (physical)

the four questions

at each tick, jev receives the full neural state as context and answers four structured questions. no free text. no interpretation needed. just typed values.

confidence and hesitation

the decision engine does not always know what to do. when the choice distribution is flat (no option dominates) or the noul confidence is low, the system maps this to physical hesitation: jittery scanning movements, pauses, incomplete turns.

this is not programmed behavior. it emerges from the confidence distribution. a hybrid confronted with simultaneous reward and threat stimuli produces genuinely conflicted probability distributions. the motor output reflects that conflict as hesitation without any explicit hesitation logic.

# confidence-to-behavior mapping

if confidence > 0.7:    clean motor output, decisive movement
elif confidence > 0.4:  attenuated movement, slower response
else:                   hesitation pattern, scanning, jitter

neural state encoding

jev receives the hybrid's neural state as structured context, not natural language. each neuron class maps to a specific decision-relevant feature.

motor output mapping

jev's decision maps to six degrees of motor freedom on the physical robot. head rotation, eye position, and lip movement are all driven by the probability distribution, not the winning action alone.

# action-to-servo mapping

APPROACH  ->  head forward, eyes center-down, slow tracking
REMAIN    ->  head still, eyes scanning slowly
RETREAT   ->  head back, eyes up and away
HESITATE  ->  jitter on all axes, rapid small movements

the motor driver polls Firebase RTDB at 100ms intervals. the neural simulation writes state, jev evaluates, and the robot moves. the full loop from spike to servo is under 200ms.

the endpoint

# run a 30-second chemotactic reflex arc
curl "https://us-central1-hybrid-001-lab.cloudfunctions.net/reflex?stimulus=chemotaxis&duration=30"

# nociceptive stimulus (pain response)
curl "https://us-central1-hybrid-001-lab.cloudfunctions.net/reflex?stimulus=nociception&duration=15&strength=35"

# conflict stimulus (reward + threat simultaneously)
curl "https://us-central1-hybrid-001-lab.cloudfunctions.net/reflex?stimulus=conflict&duration=30"

why not an LLM

an LLM would read the neural state, generate a paragraph of reasoning, and somewhere in that paragraph mention that the organism should probably approach. then you would parse the paragraph to extract the action. then you would guess at the confidence. then you would do this every 100 milliseconds and wonder why the robot moves like it is having a conversation with itself.

jev returns a typed response in under 50ms. the distribution maps directly to motor output. no parsing. no ambiguity. the confidence is a number, not a vibe.

// jev response (50ms)
{
  "value": "APPROACH",
  "distribution": {
    "APPROACH": 0.62,
    "REMAIN":   0.24,
    "RETREAT":  0.09,
    "HESITATE": 0.05
  }
}

the hybrid does not need to explain its decisions. it needs to make them.