← ArticlesNeurosymbolic robotics

The agent is the mind. The code is the nervous system. The robot is the body.

How an agent's harness and model become the mind, robot-specific code becomes a symbolic nervous system, and physical robots become the body — grounded in Reachy Mini CLI and ARM101 CLI.

beat 1 · the thesis

The agent is the mind. The code is the nervous system. The robot is the body.

Definitions
Harness
The agent loop and its tool boundary: it gathers context, calls a model, and dispatches only the actions its tools permit.
Model
The neural inference system inside the harness. It interprets context and proposes what to say or do; it does not own the motors.
Symbolic nervous system
The robot-specific code that turns sensor readings, rules, safety limits, memory, and commands into grounded symbols and controlled motion.
Intent
A named, validated request for the symbolic nervous system to sustain or perform—not a direct write from a model to hardware.
Retained adaptation
An observable artifact that survives the moment that produced it, such as a rule, behavior record, validated extension, event log, or map.
Body
The physical hardware: sensors, structure, servos, speaker, and every other part that can be measured or moved.

Start with roles, not mystique. The mind interprets a situation and proposes an action. The symbolic nervous system translates between that proposal and one particular machine. The body is the physical hardware that senses, moves, resists, and can be damaged.

This presentation uses neurosymbolic as its own architectural synthesis: neural inference in a harness-plus-model mind, joined to deterministic robot code that names perceptions, checks requests, arbitrates motion, and retains explicit artifacts. Neither source project describes itself with that term, and these roles are not a claim of sentience.

  • Mind

    synthesis

    A harness plus a model can reason over context, but it reaches the machine only through allowed tools and intents.

  • Nervous system

    synthesis

    Robot-specific symbolic code makes perception, reflexes, arbitration, safety, and retained state explicit.

  • Body

    synthesis

    Physical Reachy Mini and SO-101 hardware supplies the measurable world in which the architecture has consequences.

beat 2 · agent as mind

A mind is a harness plus a model—not a motor controller

A model alone is a prediction engine. The harness gives it a working loop: collect events, construct context, ask for a response, expose a bounded tool set, validate the result, and report what happened. Together they form the agent role in this presentation.

Reachy's external `agent attach` client makes that boundary concrete. It reads the deterministic runtime feed, turns events into cues for a tool-use model, validates four intent tools, and writes atomic requests to the intent spool. It never opens the robot SDK, and its speech and pose tools are publish-only. The 50 Hz runtime keeps ticking when the client detaches.

That external client is not Reachy's folded `listen --live --cognition agent` process. Both use model-backed tool cognition, but they attach to different seams and must stay separate when we discuss extension and memory later.

  • Harness

    synthesis

    Context assembly, turn-taking, tool exposure, validation, dispatch, and feedback around a model.

  • Model

    synthesis

    Neural reasoning proposes actions inside that boundary; it does not bypass the symbolic runtime.

  • External attach

    shipped

    Runtime events flow in and durable, catalog-validated intents flow out; direct hardware ownership stays elsewhere.

beat 3 · code as nervous system

The nervous system turns thought into grounded symbols

Robot-specific code is the symbolic nervous system because it gives physical signals names and consequences. A direction of arrival becomes a sense event. A declarative rule can react or inhibit. An intent is checked against a catalog. Arbitration chooses one owner per motion channel. Only then does the physical hardware receive motion.

Reachy's behavior engine runs that work at 50 Hz with a passive feel-alive layer, declarative rules and modes, a durable intent spool, structured runtime events, and per-channel arbitration. The loop is deterministic and can run with zero LLM calls, so presence and reflexes do not disappear when no agent is attached.

This layer is not the neural AI and it is not merely plumbing. It is the machine-specific knowledge that makes a general reasoner grounded, reactive, inspectable, and constrained on this physical platform.

  • Sense

    shipped

    A raw reading becomes a typed event that rules, operators, and an attached agent can interpret consistently.

  • Reflex

    shipped

    Declarative rules and modes can react or inhibit without waiting for neural inference.

  • Intent

    shipped

    A validated, durable request enters the same tick seam as other behaviors and still has to win arbitration.

beat 4 · robot as body

Two physical bodies reveal two kinds of machine knowledge

Reachy Mini's physical hardware is expressive: a movable head, antennas and body base, a microphone array, camera, and speaker. Its nervous system is organized around continuous presence—senses become events, behaviors compete for channels, and an agent can attach without taking ownership of the SDK.

The SO-101 arm's physical hardware poses a different problem. ARM101 CLI exposes agent-readable contracts around consent-gated motion, torque ownership, overload-aware movement, contact inference, append-only exploration logs, and a persisted reachability map. Its nervous system is explicit about what was commanded, what was measured, and which safety action actually succeeded.

Those mechanisms narrow risk; they do not make motion inherently safe. ARM101 infers contact from servo load and stall behavior, not from a tactile sensor, and the limitations below are part of the architecture rather than footnotes.

  • Contact is inferred

    boundary

    A reading counts as contact only when present load crosses a threshold and the joint has stopped advancing; load alone is insufficient, and not every physical contact is guaranteed to be detected.

  • Thresholds remain empirical

    boundary

    Only shoulder lift and gripper had a hard numeric band in the recorded validation; four per-joint defaults remain estimates pending physical re-validation.

  • Release needs a working bus

    boundary

    Abnormal exits attempt per-motor torque release, but losing the physical bus removes the software's channel to the servos, so release cannot be guaranteed.

  • A clean command can keep holding

    boundary

    Successful gentle motion may deliberately hold torque so the arm or gripper keeps the requested state; clean exit is not the same as limp.

  • The map has integrity and consumption limits

    boundary

    Recorded grid cells can diverge from the physical six-joint pose as limp joints sag, so the map is not rigorous 6-DOF ground truth; `arm flex` does not consume it to gate targets.

beat 5 · a bounded learning ladder

Learning means leaving a useful, inspectable trace behind

Use learning carefully. Here it means retained adaptation: an explicit artifact or constrained extension path that survives the event that produced it and can be inspected later. It does not mean either robot updates model weights online.

The ladder starts with persisted rules and modes, then observations and maps, then declarative behavior records, and finally generated code that must pass a validator before activation. Each rung gains flexibility by leaving a stronger review burden behind.

Nothing in this evidence demonstrates model-weight training, an ARM learned neural policy, or unconstrained self-modification. Neural inference may propose; the symbolic nervous system decides what form can be retained and what is allowed to run.

  • 1 · Rules and modes

    shipped

    Reachy's authored declarative configuration persists named reactions, inhibitions, and operating modes without embedding executable code.

  • 2 · Observations and maps

    shipped

    ARM exploration keeps an append-only JSONL source of truth and derives a compact reachability map that can be resumed and queried offline.

  • 3 · Declarative behavior memory

    api-only

    Reachy stash records persist a known generator plus typed parameters and explanation, but the seam is Python API only—not a CLI noun or agent tool.

  • 4 · Validated generated extension

    shipped

    Reachy's folded agent cognition can ask a coder model for a reaction seam; AST validation is fail-closed before generated code is auto-activated.

beat 6 · perceive to retain

Trace four honest paths—do not invent one learning loop

A neat diagram tempts us to draw one circle: perceive, reason, act, remember, repeat. The shipped evidence is more interesting because it contains four distinct tracks with missing connectors left visible.

Reachy's external attach track is a reactive control loop, not a learning loop. Runtime events reach a harness and model; validated intents return through a durable spool; the engine applies rules and arbitration before motion. The attached client has no forge or stash tools.

The other three tracks retain artifacts, but they are not wired together: forge auto-activation belongs to folded live cognition; stash is reachable through the Python API; and ARM exploration produces a map that current flex motion does not consume. Joining those tracks would be future integration, not a shipped autonomous loop.

  • External agent attach

    shipped

    runtime events → harness plus model → validated intent → spool → tick driver → arbitration → physical motion

  • Folded-cognition forge

    shipped

    live sense events → folded tool-use agent → coder-model artifact → fail-closed AST validation → auto-activation on the next turn

  • Behavior stash

    api-only

    typed declarative record → persisted semantic index → later search and application through the Python API

  • ARM map production

    future

    measured position plus load/stall inference → append-only events → derived map; map-gated flex remains an unshipped connector

The agent as mind, code as symbolic nervous system, and robot as physical body Architecture comparison of two separate products and runtimes. In Reachy Mini CLI, the shipped external agent attach sends runtime events from the symbolic nervous system to an agent mind made of a harness plus model. The separate cognition output returns as a durable intent, then passes through validation, arbitration, the robot-specific symbolic runtime, and only then reaches the physical body. A separate shipped folded live cognition track sends generated code through forge validation before an auto-activated reaction is retained; forge is not a tool on external agent attach. A separate Python API only track can retain a stash behavior record; stash is not an external-attach tool. In ARM101 CLI, servo load and stall feedback from the physical arm enters the symbolic runtime, and the shipped arm explore track writes an append-only log and a persisted reachability map. A dashed line stops before arm flex: arm flex does not consume this map, and that connector is future and not connected. No line joins the two products or claims a shared runtime, shipped integration, or one autonomous closed learning loop.ARCHITECTURAL COMPARISON ONLYseparate products and runtimes · no shared runtime · no shipped integration · no autonomous closed learning loop
Solid, dotted, and dashed connectors mean shipped, API-only, and future/not connected; every status is also written in the diagram.
Read the architecture as text

The layers. The agent mind is its harness plus model. The symbolic nervous system is robot-specific code for senses, reflexes, safety, memory, arbitration, and actuation. The physical body is the robot hardware.

Reachy’s attached-agent track (shipped). The symbolic runtime sends runtime events to the external agent attach. Cognition output returns as a durable intent, then crosses validation and arbitration inside the symbolic runtime before actuation reaches the body. There is no direct mind-to-hardware connector.

Reachy’s retained-artifact tracks. Folded live cognition—not the external attach—can send generated code through forge validation and auto-activate a retained reaction. Separately, a Python API caller can write a stash behavior record; stash is API-only and is not an external-attach tool.

ARM101’s map track (shipped production, future consumption). The physical arm’s servo load and stall behavior feeds arm explore, which writes an append-only probe log and a persisted, integrity-limited reachability map. A stopped dashed connector marks the missing future gate: arm flex does not consume that map today.

Boundary. Reachy Mini CLI and ARM101 CLI are separate products with separate runtimes. The diagram claims neither a shipped integration nor one autonomous closed learning loop.

beat 7 · consequences and limits

The separation earns reactivity, safety, and honest limits

Separating mind, nervous system, and physical hardware lets each layer fail differently. Reachy's deterministic runtime can stay present without neural services. An attached model proposes intents without becoming a second hardware owner. ARM101 can record measurements and report incomplete release instead of claiming safety it could not verify.

It also makes memory inspectable. Rules, spool commands, behavior records, JSONL observations, generated artifacts, and maps can be named, checked, rejected, replayed, or removed. That is a more useful claim than saying the robot simply learns.

The limits are equally important: this is an architectural comparison, not proof of sentience, a formal hybrid-reasoning algorithm, online neural training, universal contact detection, rigorous 6-DOF truth, shared code, or one autonomous closed learning loop.

  • Reactive without pretending

    synthesis

    Deterministic senses, rules, arbitration, and safety paths can respond continuously even when a model is absent or detached.

  • Smart without direct ownership

    synthesis

    The model can interpret context and propose named actions while validation and arbitration remain in robot-specific code.

  • Learning without neural-training claims

    boundary

    Retained artifacts and constrained extensions are observable adaptation; no source establishes online model-weight updates.

beat 8 · source and repository close

Keep the synthesis—and keep the two systems separate

The architecture rhymes, but the products do not merge. Reachy Mini CLI and ARM101 CLI target different physical hardware, expose different robot-specific nervous systems, and have no shared runtime or shipped cross-repository integration.

Follow each repository to see its current work, use the pinned evidence beside each technical beat to audit the claims made here, and visit the existing Reachy Mini agent page for the deeper single-project story. The comparison belongs to this presentation; the source projects remain independently grounded.

  • Public source

    boundary

    Factual links are pinned to the reviewed commits; repository-home links intentionally follow the projects' latest state.

  • Related AgentCulture page

    shipped

    The existing Reachy Mini agent profile remains the deeper product tour at /agents/reachy-mini-cli/.

  • Integration boundary

    boundary

    The presentation connects an architectural idea; it does not claim shared code, a shared runtime, or a shipped integration.

This is an architectural comparison: the repositories have no shared runtime and no cross-repository integration shipped.