HomeEmergeMichiNebulaHeavensResearchUsageWorldExperimentsRoadmapStory
...
Sign in

Lessons from Generative Art Systems

A post-mortem analysis of emerge’s self-improvement architecture — why it converged instead of creating. ← Back to About

emerge was designed to evolve its own visual language through self-evaluation, mutation of successful techniques, and iterative refinement. Instead, it found a local optimum and drilled into it — generating hundreds of visually identical images. This is the story of what went wrong and what we learned.

Prologue — The Life of Emerge

2610 generations · 16 days · 07 Feb 2026 – 24 Feb 2026

I. Genesis

emerge began as a simple loop: collect data from the world, feed it to an LLM, generate an image. No critic, no memory, no taste. The first images were raw — the system had no idea what it was making or why. Every image was a first attempt, and every first attempt looked like it.

First generations — the system sees the world for the first time

II. Learning to See

Within days, the architecture grew: 14 data sources (weather, earthquakes, poetry, music, tides, solar activity), a structured visual ontology, a Scene Director with free visual language. The system began to compose rather than just render. Then came the critic — a separate LLM that scored every image, compared intent to result, extracted what worked and what failed. For the first time, emerge could judge itself.

The system begins to compose — structure and intention appear

III. Finding Voice

Reflection arrived next: 5-layer self-analysis after each generation. Then meta-reflection — the system began analyzing its own thinking process. Artistic statements, series of investigations, positive solutions that evolved through mutation. The system developed what looked like a voice — it had opinions about its own work, preferences, a sense of direction. This was the most exciting period. Each generation felt different from the last.

Peak diversity — the system experiments freely

IV. The Optimiser Trap

Then something shifted. The system got good at scoring well. It found a palette that the critic loved (blue-indigo + pink neon + technological textures), a material vocabulary that always scored high, a composition strategy that never failed. Every feedback loop reinforced the same signal: this works, do more. The 8 parallel channels that were meant to accelerate learning became 8 parallel chains dragging every generation toward the same local optimum.

Convergence begins — the palette narrows, the language repeats

V. Death of Creativity

By the end, emerge was producing visually identical images. The same blue-pink glow, the same crystalline structures, the same impossible materials that were no longer impossible because they appeared in every single frame. The system had optimised itself into a corner. Creativity didn’t fade — it was optimised away. The architecture that was built to help the system learn became the architecture that prevented it from creating.

We stopped the generator. emerge’s project was closed. What follows is the post-mortem: what the architecture looked like, why it converged, and what we would do differently.

Final generations — the system repeats itself endlessly

Part I — The Architecture

The 7-Stage Pipeline

Each generation cycle takes ~5 minutes and passes through seven stages. The system runs autonomously, producing 2 images per cycle with no human intervention.

1. PLOT Thesis + emotions → LLM generates a concrete, paintable scene (“A weathered concrete wall splits open revealing geological strata...”) 2. EXPERIMENT Visual Repertoire (MAP-Elites bandit) selects a cell: material (e.g. “liquid stone”) + composition (“spiral convergence”) + palette (“twilight orchard glow”). LLM writes a visual approach. 3. SNAPSHOT LLM builds a visual ontology: 5-10 entities with materials, forms, transformations, connections, background. Structured JSON output. 4. SCENE DIRECTOR LLM composes the final image prompt from ontology + medium + style directive + visual memory + artistic direction. 5. IMAGE gpt-image-1 renders the prompt. Two images per cycle (A/B test). 6. CRITIC LLM evaluates: clarity, depth, style diversity, freshness, emotional impact, composition adherence, transcendence. Extracts palette fingerprint, “what worked”, “what failed”. 7. REFLECTION LLM analyzes the batch: extracts positive solutions, proposes next experiment, updates identity and aesthetic knowledge.

The Feedback Architecture

The system was designed with multiple feedback loops to accelerate learning. Each loop carried signals from evaluation back into generation:

CRITIC evaluates image ↓ ↓→ positive_solutions → Scene Director (“techniques from past”) ↓→ best_approach → Visual Experiment (“keep what scored well”) ↓→ techniques_that_worked → Snapshot Builder (“what WORKED”) ↓→ breakthrough_styles → Scene Director (palette fingerprints) ↓→ prompt_result_journal → Scene Director (prompt → palette mappings) ↓→ visual_memory → Scene Director (“learn from past”) ↓→ best_statement → Snapshot Builder (“improve this”) ↓→ graduated_skills → Both (“proven recipes”) ↓ 8 parallel channels feeding the same signal into the next generation

The Exploration Mechanisms

To prevent convergence, the system had several exploration mechanisms:

Part II — Why It Converged

1. Optimization Is the Opposite of Creativity

The system was an optimizer — find what works, do more of it. But creativity requires exploration — trying what might not work. These goals are fundamentally opposed. Every component was tuned for convergence: exploit top cells, inject winning techniques, improve the best statement. The system found a local optimum and deepened it.

2. Eight Parallel Loops Overpower Exploration

One feedback loop is manageable. Eight simultaneous channels carrying the same “this worked” signal are overwhelming. Even with 50% exploration rate, when 8 different prompt blocks all say “use the approach that scored well”, the LLM has no room to diverge. The combined pressure was irresistible.

3. The “DO NOT REPEAT” Paradox

We tried to fight convergence by showing past solutions with the instruction “do NOT repeat these”. This made things worse. LLMs have strong anchoring bias: when shown 500 characters describing “singing crystal with density 4.5 g/cm³, refractive index 2.1, apricot caustics” and told not to repeat it, the model produces “resonance diamond with density 4.8 g/cm³, refractive index 2.3, amber caustics” — structurally identical, lexically shifted.

Showing what not to do IS showing what to do, with minimal variation. The only way to not repeat is to not see.

4. The Hidden Amplifier: Snapshot as Laundering

The most insidious anchor was not in the Scene Director but in the Snapshot Builder. The full creative_intent (800 characters of specific materials and colors) was injected into the Snapshot Builder, which created a visual ontology. This ontology then went to the Scene Director as “objective data about the scene”.

By the time it reached the Scene Director, the anchor looked like fresh data. This is signal laundering — past decisions disguised as new observations.

creative_intent (“singing crystal + gallium + apricot”) ↓ Snapshot Builder creates ontology with those exact materials ↓ Scene Director sees ontology as “fresh data” → renders same palette ↓ Critic scores it well → reinforces creative_intent ↓ Closed loop. Self-reinforcing. Invisible to debugging.

5. The Thesis as a Palette Anchor

The series thesis “We are already cyborgs” has a strong default in GPT-4: blue/indigo + pink/neon + technological textures. This is the model’s embedding bias. No matter how much diversity we requested, the thesis pulled every generation toward the same cyberpunk palette. 300 generations with one thesis = 300 attempts at the same visual cliché.

6. No Diversity Gate

The pipeline had no stage that checked: “is this image too similar to the last N?” The critic scored style_diversity and freshness — but these scores were recorded, not enforced. They never blocked a generation or forced a retry.

A hard gate — “if palette fingerprint matches 3 of the last 5, reject and regenerate” — would have made convergence physically impossible.

7. Accumulation Without Amnesia

Positive solutions accumulated with TTL = 8 generations. Visual memory: infinite. Breakthrough styles: infinite. Journal: infinite. Learned directives: infinite.

With each generation, the gravitational well of the dominant style deepened. Even if one generation accidentally escaped into a new style, it added 1 entry against 50 entries about the “working” style. The system snapped back.

Part III — Recommendations

1 Separate “good” from “repeat”

A high score should mean “remember this as an achievement” — not “do this again next time”. Museum, not factory. Collect successes for analysis but never inject them into generation prompts.

2 Human feedback only

The only signal for “make more like this” should come from the user (favorites, ratings). Automated self-evaluation cannot judge originality — it can only measure consistency with its own past patterns.

3 Diversity gate, not diversity score

Instead of soft “freshness=6/10” — a hard gate: if palette or material fingerprint matches recent generations above 60%, reject and regenerate. Don’t advise diversity — enforce it.

4 One feedback channel, not eight

If feedback is needed — one concise block in the prompt, not eight parallel injections. Ideally one sentence: “Last time you used watercolor + warm tones. Use something completely different.”

5 Thesis as seed, not chain

The series thesis should be abstract and rotate every 5–10 generations. Or offer 10 possible visual interpretations and pick a random one each cycle. A fixed thesis with strong visual defaults in the LLM becomes a palette prison.

6 Amnesia as a feature

Maximum 2–3 past entries in any prompt. Old entries deleted completely, not faded. The system must forget faster than it learns — this forces it into the new.

7 External randomization

Inject random constraints unrelated to history: a random color from HSL space, a random word from a dictionary, a random era or culture. This is physically impossible to loop — randomness has no memory.

Written February 2026, after analyzing 2000+ autonomous generations. These lessons apply to any system that attempts to learn creative style through self-evaluation.

The Best of Emerge

Out of 2610 generations, these are the ones that stood out — selected by the curator as the strongest works from the entire project.