What happens when a person learns to control a cursor, while the cursor’s rules keep changing?

Reading time: about 7–8 minutes.

Imagine trying to move a dot on a screen using only your forearm muscles. You have to discover which muscle patterns make it move left, right, up, or down. Just as you begin to improve, the computer changes how it translates your muscles into motion.

This is co-adaptation: the user learns a control strategy while the computer learns a signal-to-movement mapping. Madduri and colleagues built a concrete experiment around this problem, measured the two learning processes, and used control theory and game theory to predict their interactions.

1. What did participants actually do?

Fourteen participants wore a 64-channel surface EMG array on their dominant forearm. On the screen were two circles: a moving red target and a blue cursor. The task was to make the cursor follow the target by activating forearm muscles. The target followed an unpredictable two-dimensional path.

Each participant completed 16 trials of five minutes, split into two blocks. The computer began each trial with a randomly initialized decoder and was programmed to update that decoder approximately every 20 seconds. Participants learned through the visual feedback: if their cursor went the wrong way, they tried a different muscle activation.

Figure 1 — Co-adaptive cursor-tracking experiment

Figure 1. Panel a shows the experiment and feedback loop; b shows the trial structure; c–d show cursor tracking improving over time.

The researchers systematically changed three properties of the decoder: how quickly it updated, how strongly large weights were penalized, and which initial mapping it started with. Those changes let them test whether the computer’s learning rules also changed the human’s learning.

2. Decoder: the algorithm that actually moves the cursor

The Decoder, represented by the matrix D, takes 64 EMG signals and outputs a two-dimensional cursor velocity:

Here, u_t contains the 64 processed muscle-signal values, D has shape 2 × 64, and v_t = (v_x, v_y) tells the cursor how fast to move horizontally and vertically.

For example, one combination of muscle activity may send the cursor to the right, while another sends it upward. Each of the 64 channels contributes according to the current weights in D. The cursor’s position is then updated by integrating this velocity.

How does D learn every 20 seconds?

The online algorithm performs two steps:

  1. Find a better candidate decoder. Using recent EMG, target positions and cursor positions, it calculates a matrix D* whose predicted movement points more effectively toward the target. It minimizes a cost with two terms:

The first term compares the decoder’s predicted velocity with the desired corrective movement from the cursor position y toward the target τ. The second term penalizes large decoder weights; λD controls that penalty.

  1. Blend the candidate with the current decoder. Instead of switching all weights at once, the SmoothBatch update is:

The parameter α is the fraction of the old decoder retained. Thus, α = 0.75 means slow updating and α = 0.25 means fast updating.

Consider just one weight. If its current value is 0.2 and its optimized candidate is 1.0, a slow update changes it to 0.4, while a fast update changes it to 0.8. These numbers are an illustrative calculation using the study’s update rule.

This update is the algorithm that runs during the human experiment. As its matrix changes, the relationship between the participant’s muscles and the cursor changes too.

3. Encoder: how did the researchers measure human learning?

The computer knows D exactly, because it sets those weights. The human’s strategy has to be estimated from behavior.

To do so, the researchers fit another matrix, E, called the user encoder. It predicts the participant’s 64-channel muscle activity from eight task variables:

  • Target position: (x,y)
  • Target velocity: (v_x,v_y)
  • Position error between target and cursor: (e_x,e_y)
  • Velocity error between target and cursor: (velocity error x, y)

In compact form:

The authors estimated E using linear regression on short segments during which D was held fixed. They could then compare E at different moments within a trial.

Suppose the participant initially produces a large EMG response when trying to move right. After practice, the same target direction elicits a different combination or magnitude of muscle activity. That appears as a change in E. D measures the computer’s changing rule; E tracks the person’s changing strategy.

Figure 2 — Estimating the user's encoder

Figure 2. The user encoder links task information to measured EMG. Changes in the estimated encoder describe how a person’s control strategy evolves.

Why examine D and E together?

The actual control loop runs in this order:

Target and visual error → human strategy E → EMG → machine decoder D → cursor → new visual error.

The combined mapping therefore depends on D and E together. In control-theory analysis, the authors separate the encoder into feedforward components (responding to the target trajectory) and feedback components (correcting the cursor’s errors), then examine products such as (DF_1) and (DB_1).

A useful analogy is driving a car with adjustable steering sensitivity. The same steering-wheel turn can produce different vehicle movements after the car’s settings change. How well someone drives depends on both their learned steering strategy and the car’s response.

4. Game theory: what if both sides optimize at once?

Now we have two changing quantities: the human’s E and the machine’s D. The authors built a simplified one-dimensional game in which both learners try to reduce a shared task error, while each also has its own cost for large responses.

A compact potential function captures their trade-off:

  • (1−DE)²: how well the two mappings work together
  • λE × E²: the modeled cost of the user’s control strategy
  • λD × D²: the modeled cost of large decoder weights

For intuition, compare E = 2, D = 0.5 with E = 0.5, D = 2. Both have DE = 1, so the shared-error term is identical. But the work is distributed differently between user and computer. Changing λD changes which combination the system tends toward.

The model also assigns adaptation dynamics to E and D and studies whether they converge to a stable stationary point. Two predictions follow: learning rates affect whether and how fast the pair converges, and changing decoder penalties can change the user’s eventual strategy.

Figure 3 — Game-theoretic analysis

Figure 3. Panel b visualizes the joint optimization landscape; d–e show how learning rates affect convergence; f shows the trade-off between encoder and decoder magnitudes.

5. How did they test those predictions?

The experiment used a 2 × 2 × 2 design: two decoder update speeds, two decoder penalties, and two randomized initializations. That gives eight conditions, each repeated twice per participant.

Test A: fast versus slow decoder updating

The authors compared slow (α = 0.75) with fast (α = 0.25) updates. Participants tracked the target more accurately with the slow-updating decoder, and tracking error decreased more across each trial. Their estimated user encoders also changed more, suggesting that human adaptation proceeded more effectively when the mapping changed gradually.

Figure 4 — Decoder learning rate

Figure 4. Panels b–c compare tracking error for fast and slow updates; d compares changes in the user’s encoder; e–f examine the combined control dynamics.

Think of trying to learn a game in which the joystick’s sensitivity changes every few seconds. Updating the rule aggressively might help the computer fit recent data, but it can make the rule harder for the player to learn.

Test B: high versus low decoder penalty

The authors also compared a low penalty (λD = 10²) and a high penalty (λD = 10³). With a stronger penalty, the decoder’s weights became smaller. The estimated user’s encoder magnitude increased: the person compensated for the machine’s weaker response.

Tracking-error improvement remained similar across the two conditions, while cursor speed and individual movement strategies differed. The machine’s objective shaped how the human performed the task, even when overall accuracy was similar.

Figure 5 — Decoder penalty and user strategy

Figure 5. Panels c–d show the opposing changes in decoder and user-encoder magnitudes; e–g show cursor speed and individual strategies.

The third variable, decoder initialization, was also analyzed: the initial mapping could modestly influence the eventual encoder–decoder relationship.

Takeaway

The study brings together three distinct tools: an online Decoder that controls the cursor, an estimated Encoder that measures human adaptation, and a game-theoretic model that predicts what happens when both change.

Its central finding is that a decoder changes more than cursor accuracy: it changes what the user learns. Better co-adaptive interfaces therefore require designing the interaction between user and algorithm, rather than optimizing the decoder in isolation.

Paper and figures: Madduri, M. M. et al., Nature Machine Intelligence 8, 372–387 (2026). Original article · Data and analysis scripts. Figures 1–5: original authors, CC BY-NC-ND 4.0.