How to Make a Robot Pet Cat

TL;DR

The cat-feel does not live in the locomotion layer and it does not live in the skill library. It lives in a small thing on top: a behavioral-mode attractor with a 6-dimensional mood latent and a stochastic decision period. Add those three to a vanilla PPO categorical head and a generic walker, and the rollout starts to look like a cat.

This page summarizes Part 1 — Brain. It also describes the substrate the brain runs on (Tier 1 walker, Tier 2 skills) and documents the paradigms we tried and threw away.

The stack

Each tier is independently trainable. The contribution of Part 1 is the brain layer plus the empirical observation that the skill set should be small — four learned skills is enough, more skills do not help.

How it works

Mood latent. A 6-dimensional Ornstein–Uhlenbeck process running at every physics step. The first three dimensions (energy, alertness, sociability) provide a continuous bias to the mode-transition softmax. The last three dimensions are passed through σ(2x) to produce the per-step reward weights (w_curiosity, w_comfort, w_play), making the reward landscape itself a function of internal state. The time constant is ~20 min, so mood evolves much slower than skill selection.

Attractor. A mode-transition policy over six behavioral modes. At each potential transition point it computes logits as a linear function of the current mood weights, then samples from softmax(logits / T). A transition is gated by a minimum dwell time, so the cat commits to a mode for tens of seconds before reconsidering. Each mode defines an allow-list of skills and a set of hard-blocked skills (e.g. walk is always blocked in RESTING and GROOMING). Out-of-allow-list actions are suppressed stochastically with a 70/30 soft-pass rather than a hard mask, preserving gradient flow.

PPO brain. An MlpPolicy over a 15-dim observation vector (mood state[6], XY position[2], cos/sin yaw[2], body height[1], horizontal speed[1], normalized time-in-skill[1], play-target Δxy[2]) with a Discrete(5) action head. Index 0 is HOLD; indices 1–5 map to the five skills. The policy is queried on a stochastic commitment schedule (T ~ U(1.5, 4.0) s) rather than every step, which eliminates high-frequency skill thrashing without modifying the policy architecture. Entropy regularization (ent_coef = 0.05) is critical to prevent collapse to a single dominant skill.

Skill library

Four learned skills. Earlier versions of the system carried fifteen named skills; we converged here after the faking-is-enough principle: scripted PD for postures, RL only where RL is necessary.

What we tried and removed

A paper that only reports the final design overstates how obvious that design was. These paradigms were tried, integrated, and removed:

Released weights

All weights are MIT-licensed and hosted on GitHub.

Quickstart

git clone https://github.com/jeffrah00/robot-pet-cat.git
cd robot-pet-cat
python3.11 -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"

# Download released weights (~5 MB total)
python scripts/download_weights.py

# Run a 30-second autonomous rollout
python scripts/render_brain_3d.py \
    --checkpoint checkpoints/brain/brain_4skill_v1.zip \
    --duration 30 --output renders/demo.mp4

BibTeX

@article{rah2026brain,
  title   = {How to Make a Robot Pet Cat: Part 1 --- Brain},
  author  = {Rah, K. Jeff},
  journal = {arXiv preprint},
  year    = {2026}
}

What's next

Part 1 is the brain on top of a sim-only substrate. Future parts:

• Part 2 — Eyes. Replace the play-target features with a small visual encoder over a head-mounted egocentric camera.
• Part 3 — Body. Sim-to-real on a Go1 (or, eventually, a cat-shaped chassis).
• Part 4 — Self. Long-horizon memory, place recognition, and routines that emerge over hours rather than seconds.