Some design problems have no formula for "good": game levels, visual styles, sounds. In these problems a person has to judge each candidate by eye. Such people tire within a few dozen judgments, and once they tire their ratings become noisy and their standards drift. Cooperative co-evolution is a standard way to search large design spaces. It splits a design into parts, evolves each part in its own population, and scores a part by plugging it into a complete design built from the best current versions of the other parts. This proposal asks what happens when the scorer in that loop is a tired human. We propose that each screen shown to the user should hold every part fixed at its current best version except one. The user then compares candidates that differ only in that one part.
Such a screen gives two benefits. First, a choice among candidates that share everything but one part can be credited to that part, and to nothing else. Second, the shared context and the current best design shown alongside act as a built-in reference point. This reference point absorbs the tendency of users to rate relative to whatever is on screen. We pair this screen design with two further pieces. One is a preference model that splits the user's taste into per-part terms plus an interaction term. The other is a bandit that decides which part the user is asked about next. We test whether this combination reaches a user's intended design in fewer human choices than asking about whole designs, as the strongest current systems do.
Core Claim
Consider a design assembled from part sub-vectors $x = [x_1, \dots, x_S]$, where $S$ is the number of parts (species). For example, $x_s$ could be the 10-dimensional latent code of the $s$-th segment of a Super Mario Bros. level produced by a pretrained generator. We model the user's hidden satisfaction as
$$u(x) = \sum_{s=1}^{S} f_s(x_s) + g(x),$$
where each $f_s$ captures how much the user likes part $s$ on its own, and $g$ captures interactions between parts, such as whether adjacent segments flow into each other.
A screen of $K$ candidates that share every part except $x_s$ has a useful property. Within a multinomial-logit choice model (a model in which the probability of picking a candidate grows with its utility), any offset shared by all candidates on the screen cancels. That cancelled offset includes the rest of the design's contribution and any screen-level shift in the user's rating scale. The user's pick is then informative mainly about $f_s$ and about the part of $g$ that involves $x_s$.
Whole-design screens, where every part changes at once, mix all these terms together. The claim is therefore concrete. When the parts interact weakly or moderately, one-part-at-a-time screens should lower the number of human choices needed to reach a given true utility, and this advantage should grow with the number of parts. When interactions are strong, a bandit that can also choose a "vary everything" screen should fall back gracefully to whole-design behavior. The decisive tests below check both halves of this claim.
Where This Sits
Three lines of work motivate the proposal.
The first reduces fatigue by searching inside a pretrained generator's latent space. Deep Interactive Evolution evolves a 20-dimensional GAN latent vector for shoes, faces and chairs. Interactive Evolution and Exploration Within Latent Level-Design Space of Generative Adversarial Networks does the same with a 10-dimensional latent for Mario and Zelda levels. Schrum et al. report that changing one aspect of a level unintentionally changes others, and they call for more modular control. Both systems treat the latent vector as a single monolithic block. We keep their generators but split the search into parts.
The second line models the user explicitly. Personalized Image Generation via Human-in-the-loop Bayesian Optimization (MultiBO) shows $K$ images, collects top-$N$ picks, and fits a Gaussian process with a multinomial-logit likelihood. It converges in 32 to 50 rounds. We reuse its choice model, but give it per-part structure and a different screen design. Improving the Performance of Predicting Users' Subjective Evaluation Characteristics to Reduce Their Fatigue in IEC identifies relative scaling and preference drift as the two main reasons surrogate models of users fail. It corrects for them by carrying anchor individuals across generations and by weighting recent data more heavily. In our design the current elite design appears on every screen, so the anchor comes for free. We borrow recency weighting directly.
The third line is cooperative co-evolution with scheduling. Sustainable Cooperative Coevolution with a Multi-Armed Bandit (CCEA-MAB) treats each species as a bandit arm and gives more evaluations to species that recently improved the global solution. We move its scheduler from spending machine evaluations to spending human screens.
Two papers already combine people with co-evolution, and both differ from this proposal in the way that matters. Multi-objective Human-computer Co-operative Co-evolutionary Method Based on Non-dominated Sorting Strategy injects engineer-drawn satellite layouts into co-evolving populations. It uses Pareto sorting so that machine-generated candidates neither drown out the human designs nor collapse onto them. It has no online preference loop, no user model, and no allocation of human attention across parts. The ANGELINA Videogame Design System - Part I and Initial Results from Co-operative Co-evolution for Automated Platformer Design co-evolve rules, maps and layouts using automated playouts. Humans appear only after the fact, and their rankings barely track algorithmic fitness (rank correlation 0.11). Neither system asks the question we ask: how to structure the human's judgments inside the co-evolutionary loop.
One result constrains the design. Cooperative Coevolutionary Decomposition shows that co-evolution fails badly when strong cross-part interactions go unmodelled. This is why the interaction term $g$ and the "vary everything" arm are required rather than optional. It is also why we sweep interaction strength in the experiments.
Research Program
We will build a system with three components.
The first is the population structure. Each part has its own small population of latent sub-vectors, varied by Gaussian mutation and crossover as in Deep Interactive Evolution. A pretrained generator decodes every assembled design, which avoids asking the user to inspect broken or nonsensical candidates. An automated check, such as an A* playability agent for Mario, filters out unplayable assemblies before any human sees them. This keeps hard constraints on the machine side and taste on the human side, which is the division of labor the ANGELINA results suggest.
The second is the user model. It is a multinomial-logit Gaussian process whose kernel is a sum of per-part kernels plus one kernel over the full vector, mirroring the equation above. It is trained on all top-$N$ choices, with recency weighting to track drift.
The third is the scheduler. It is a UCB bandit whose arms are the $S$ parts plus one joint arm. The reward is the increase in the model's predicted utility of the assembled elite after a screen. When an arm is chosen, the system fills a screen with $K-1$ candidates from that part's population, selected by the model's expected improvement given the current context, plus the elite itself as the anchor.
We will also analyze a question the literature leaves open: the "moving target" problem as it appears to a human. When part $B$'s elite changes, earlier judgments about part $A$ were made in an old context. The interaction kernel is what lets the model reuse those judgments. We will measure how much predictive accuracy on held-out user choices depends on it.
Baselines
The naive reference point is interactive evolution over the monolithic latent vector: selective breeding on whole designs, as in Schrum et al.'s interface, with the same generator, playability filter, screen size and number of screens. It tells us whether any user modeling pays off.
The strongest competitor is a MultiBO-style preferential Bayesian optimizer over the concatenated latent vector. It shows whole designs, collects top-$N$ picks, and fits a multinomial-logit Gaussian process with a standard kernel, following Personalized Image Generation via Human-in-the-loop Bayesian Optimization. That paper reports convergence in 32 to 50 iterations and a 70.82% human-preference win rate against DiffusionDPO, IterComp and DEMON. Those figures come from diffusion image personalization, not from our tasks. No reported result was found on Lacuna for any preferential optimizer on multi-segment VGLC levels, so we will run this baseline ourselves. Its hyperparameters will be tuned with the same simulated-user budget as ours. We count it as beaten only if our system reaches its final true utility in at least 25% fewer human screens, averaged across simulated users and seeds, with non-overlapping bootstrap intervals.
Three ablations isolate our ingredients.
The first gives the whole-design optimizer our additive-plus-interaction kernel. This separates the benefit of structuring the model from the benefit of structuring the screen.
The second keeps one-part screens but cycles through parts round-robin. This isolates the bandit. Sustainable Cooperative Coevolution with a Multi-Armed Bandit reports that the bandit raised success on a 5-pattern string-covering task from 22% to 71%, and cut generations to target on sensor placement from 429.4 to 283.7. Those gains were for machine evaluations and have not been shown for human ones.
The third removes the elite anchor from each screen. This tests the relative-scaling argument taken from Wang and Takagi.
A final fully automated reference runs the same co-evolution against a machine proxy scorer with no human in the loop. It is included because ANGELINA's results predict that this proxy will diverge from what people want.
Why not just…?
Why not just run preferential Bayesian optimization on the whole latent vector, as MultiBO does? This is the real threat. With 10 to 20 dimensions, a good Gaussian process may simply not need our structure, and the file gives no evidence either way on multi-part designs. We therefore make dimension an experimental variable, from 2 to 5 segments (20 to 50 dimensions). We expect whole-design optimization to match us at 2 segments and fall behind as the number grows. If it keeps pace at 5 segments, the proposal's central claim is false and we will report that.
Why not just use an additive kernel and keep whole-design screens? Additive Gaussian processes already exploit per-part structure in the model, so the extra step of changing what the user sees has to earn its place. Our argument is that a pick among whole designs is confounded: the model must infer which part drove the choice. A pick among one-part variants in a fixed context is not confounded in this way, and it cancels screen-level scale shifts. The first ablation above tests exactly this. If it closes most of the gap, the contribution shrinks to the kernel, and we will say so.
Why not just let the user choose which part to edit, like a slider panel? This is cheap and intuitive. It replaces the bandit with the user's own sense of what is wrong. It also spends the user's attention on a second decision at every step, and people are poor judges of which change would help most in a design with interacting parts. We will include a user-directed variant in the human study, where the user taps the part to refine and the system otherwise behaves identically. If it matches the bandit on screens-to-target without raising workload or inconsistency, we would adopt it as the default. The co-evolutionary machinery would still be needed underneath it.
Why not just remove the human and score with playouts or a learned aesthetic model? The ANGELINA Videogame Design System - Part I found only a 0.11 rank correlation between automated fitness and player preference. MultiBO's authors report that automated image scores are easily gamed by the optimizer. We keep automated checks for hard constraints only.
Proposed Experiments
The first stage uses simulated users, which permits hundreds of seeds. We build block-structured utilities from the Schwefel and Hartman functions used by Wang and Takagi and by Benchmarking Surrogate-Assisted Genetic Recommender Systems. Each block is one part, and a tunable cross-block term sets the strength of interaction. Following Wang and Takagi, the simulated user's responses are made human-like: scores are quantized to five levels, each screen gets a relative-scale offset, noise grows with session length to mimic fatigue, and the optimum shifts mid-session to mimic drift. Neither benchmark paper reports terminal values we can compare against. Wang and Takagi report only that their largest advantage came in the first 6 generations, so all numbers here will come from our own runs. The metric is true-utility regret as a function of human screens.
The second stage uses Mario and Zelda content from The VGLC: The Video Game Level Corpus, with a GAN in the style of Schrum et al. applied per segment or per room. Levels have 2 to 5 parts. Simulated users are given a hidden target level, and their utility is a tile-level similarity to that target plus a flow term between adjacent segments. This gives a genuine interaction term that we did not design ourselves.
The third stage is a human study with roughly two dozen participants, comparable to the 22 in Schrum et al. Participants recreate a shown target level and also build a level to their own taste. Within-subject conditions are counterbalanced: our system, the whole-design optimizer, and the user-directed variant. We measure four outcomes: tile distance to the target, the number of screens and minutes to a threshold, self-consistency on elite pairs that are secretly re-shown late in the session (a direct fatigue measure), and final preference among the three conditions' outputs.
Three results settle the question. First, the gap between our system and the whole-design optimizer in screens-to-target must widen as the number of parts grows. Second, as interaction strength rises in simulation, the bandit must shift its choices toward the joint arm, and its performance must degrade toward, but not below, the whole-design baseline. Third, the no-anchor ablation must show larger early regret than the full system under simulated relative scaling. Failing the first result falsifies the idea. Failing the second means the idea works only when parts are nearly separable, which is a much narrower contribution.
References
- Deep Interactive Evolution
- Interactive Evolution and Exploration Within Latent Level-Design Space of Generative Adversarial Networks
- Personalized Image Generation via Human-in-the-loop Bayesian Optimization
- Improving the Performance of Predicting Users' Subjective Evaluation Characteristics to Reduce Their Fatigue in IEC
- Sustainable cooperative coevolution with a multi-armed bandit
- Multi-objective Human-computer Co-operative Co-evolutionary Method Based on Non-dominated Sorting Strategy
- The ANGELINA Videogame Design System - Part I
- Initial Results from Co-operative Co-evolution for Automated Platformer Design
- On investigation of interdependence between sub-problems of the Travelling Thief Problem
- Benchmarking surrogate-assisted genetic recommender systems
- The VGLC: The Video Game Level Corpus.