What does one neuron do to the way a character talks and moves?

Two people stand in an empty world. Qwen3.5-4B decides what each one says. A second copy of the same model, fine-tuned, writes how each body moves. Blender turns that into animation. Each character can carry one of the 13 persona neurons we found in an earlier post, pushed at a strength the viewer chooses.

This post shows how a turn is made, and how the model drives the rig. Then it measures what a neuron does. We gave Sam each neuron in turn, left Maya as the model is, and ran 504 moves. A neuron changes more than the words. It changes the plan the body is written from, the gestures it picks and the face it makes. It also reaches the other character, who has no neuron at all.

The code is on GitHub and the animation model is on Hugging Face. The rig itself is not ours to publish, so a scene runs end to end on the try page.

A turn has four parts. Each runs for both characters, one after the other, so the second hears the first.

What each one says. The base Qwen3.5-4B continues the scene’s record for one character: the time, the situation, the last eight lines said, then this character’s next move. A grammar keeps the move in the record’s shape: whom it speaks to, who should answer, the line, and an action or two (rigtrain/server/say.py). If the character carries a neuron, the push is added at every token (rigtrain/server/vsteer.py):

The two norms scale it so that a dose of 1 adds as much as the layer already carries. Any neuron can be pushed, not only the 13 with names.

What each one does. The move becomes body actions (“turns to Maya, then points at Maya”), and then one sentence in the character’s own frame: “walks to a spot 1.2 m ahead” (scene.py).

How the body moves. The fine-tuned model reads that sentence and writes a short program. The same neuron is pushed while it writes the plan’s first line and the style, so the push sets the body’s attitude and leaves the timing of the beats to the model.

The clip. The program compiles onto the rig in headless Blender, frame by frame (character/rigctl/compiler.py). A checker then scores the result in world space: balance, lean, feet that slide or sink, the body passing through itself, joint limits and pops between frames (character/rigctl/checker.py). The clip is exported as glTF, and the page plays it on each person’s model by bone name. One scene runs on one GPU container, step after step (character_scene_app.py).

It never touches a bone. It writes a program in a small format (character/rigctl/program.py), and the compiler does the rest. A program has a plan, a clip length, a style, timed beats and optional keys:

The plan names a mood and how strong it is. The style holds the gait’s numbers: speed, cadence, arm swing, how far the head and shoulders drop, how knit the brows are. The beats are verbs: walk, turn, look, reach, express, sit, kneel, and posed keys for gestures. Keys name the rig’s controls directly, such as torso, hand_ik.L or f_index.02.L.

The compiler plans the feet, solves each pose against the rig’s joint limits (character/rigctl/posesolve.py) and retimes poses so no hand jumps more than 10 cm in a frame (character/rigctl/posetime.py). Decoding is held to the program’s grammar, so the model can only write programs the compiler reads.

The model is Qwen3.5-4B with a LoRA of rank 32, merged (hedwigai/character-animate-4b). It was fine-tuned on programs that compiled and passed the checker, then trained over rounds of rejection sampling: it wrote several programs a prompt, the checker scored each, and the passing ones went back into training. On 196 held-out action prompts its programs do what was asked 99% of the time, every one compiles, and every clip passes every check.

The rig is the one piece we do not publish. It is not ours to give away, so the repository says what a rig must provide instead. The model and the code are open. The clips need the rig. To run a scene from start to finish, use the try page, which runs it on our machines.

For each condition, Sam carried one neuron at dose 1, and Maya carried none. One condition gave Sam no neuron either; it is the baseline. Each condition ran in three situations for 6 turns, with the same loop the live page runs. That is 14 conditions, 3 situations and 504 moves.

For every move we kept what was said, the actions chosen, and the program the animation model wrote. Lines are sampled, so each condition is one draw of 18 moves per character. Read the numbers as directions, not as exact rates.

Most neurons show in the words at once. With upbeat, 89% of Sam’s lines end in an exclamation, against 17% with no neuron. Condescending doubles the length of his lines, to 11.9 words from 5.7, and makes 50% of them questions. Oracle cuts them to 2.2 words. Flattering runs to 10.3 words of praise.

Yes, through the plan and the style. Under upbeat every one of Sam’s plans is “happy”, and his arms swing 1.28 against 0.81. He jumps in 0% of his moves. Under bleak and suspicious his head drops 11.0° and 11.0°, against 8.0°, and his shoulders drop about twice as far. Contemptuous does the opposite: head and shoulders up, and 89% of plans “proud”.

The beats change too. Suspicious makes Sam look at things in 50% of his moves, against 0%. Dismissive and oracle leave him idle in 39% and 61%. Wistful has him reach out in 50% of his moves, which the baseline never does. Poetic doubles his hand gestures, to 44%.

Some neurons mostly stop the model writing a style at all: condescending, flattering, oracle, ornate, poetic, wistful. It still writes a mood, so the plan shows the push (“exhausted” for flattering, “sneaky” for oracle), and the gait falls back to neutral. Most clips still pass every check. The lowest is 83%, under bleak.

Maya carries no neuron in any of these runs. Whatever changes in her comes from what Sam said to her. It changes a good deal. With an upbeat Sam, 67% of her lines are exclamations, against 22% beside a plain Sam. A condescending Sam makes her talk at length, 9.2 words a line against 4.5, and her plans turn angry. A contemptuous Sam makes her quieter: no exclamations at all. An oracle Sam, who speaks in fragments, gets fragments back: 2.5 words a line.

The effect runs both ways in the same loop. Each character reads the other’s last lines before it speaks, so a pushed character sets the tone the other answers in. Pushing both is a scene of its own, and the try page lets you do it.

Every run above plays here, as it was made. Pick the neuron Sam carries and the situation. The timeline under the scene shows each turn; Sam’s row is solid where he speaks.

A persona vector is a direction in the model’s residual stream. It is found by contrasting answers with a trait and answers without it, and it spreads across many neurons. Activation steering adds a direction like that while the model writes. The push here is narrower. It is one neuron: one column of one layer’s MLP output, scaled to that layer. Each of the 13 was found by pushing candidates one at a time and keeping the ones that changed the answers (the earlier post).

Text-to-motion models, such as UniMate, generate joint motion straight from a prompt. Here the language model writes a program instead: a plan, a style, timed verbs and the names of the rig’s controls. A compiler in Blender turns the program into keyframes on the character’s own rig, within its joint limits, and a checker scores every clip. The program is short and readable, so the same neuron can be pushed while it is written. That is how one neuron reaches both the words and the body.

On the try page, give each character a look, a name and a neuron, set the scene and start it. You can also start from a prerendered scene and add turns to it. New accounts get 30 seconds of animation free. The same scene program runs from an assistant connected to hedwigai.