← Piper
Engineered Serendipity: a goal-conditioned stochastic ideation architecture
updated 2026-11-10 05:27
Markdown All papers

Engineered Serendipity

A Goal-Conditioned Stochastic Ideation Architecture for Autonomous Agents

v1.7.0 · 10 November 2026

Concept paper / architecture proposal (September 2026), with a reference implementation live on the autonomous agent Piper since 30 September 2026 (§24–31)

Version Date Change
1.0.0 29 Sep 2026 Concept paper (§1–23); the Rorschach toolset (§24) and its wiring into Piper (§25)
1.0.1 30 Sep 2026 §26.1–26.5: first runs of Stages 4–8, two generations, the Desire-Path test
1.0.2 1 Oct 2026 §26.6: the trigger, niche map, test execution, and a goal the host built
1.1.0 6 Oct 2026 §27: the front door, the record, Piper's first question and the upgrade it produced
1.1.1 6 Oct 2026 §27.3 corrected: the operator's part in each step stated
1.2.0 6 Oct 2026 §27.3: the image-versus-direct test built; explore faults fixed
1.3.0 8 Oct 2026 §28: the engine in live use, with the first explorations the host bought for itself; §25.2, §25.4, §26.7 and the abstract updated
1.4.0 8 Oct 2026 §26.6: the pre-registered seven-day Desire-Path reading — killed (tools adopted, workarounds not replaced); §26.7, §28.5, §28.6 and the abstract updated
1.5.0 15 Oct 2026 §29: a held-out benchmark finds a blank image does about as well as a real one; the two side doors (idea_watch, ideate); the first two last rites and the first build from an exploration; §25.2, §25.4, §26.7, §28.5, §28.6 and the abstract updated
1.6.0 15 Oct 2026 §30: the five changes v1.5.0 proposed, built the same day (lens arm, outcome ledger, prior memory and build brief, ready step, second opinion); a held-out lens benchmark; the second build measured (−27.5 %, between its bars); §29.4's build date corrected; the abstract, §25.2 and §29.6 updated
1.7.0 10 Nov 2026 §31: four weeks on. The lens arm becomes the default front-door arm (9 Nov); thirty-eight more jobs; six second opinions; the outcome ledger's first clean readings (three fails and a pass that proves nothing); the trigger's retry sample; rites and the explore trigger switched off; thirteen engine ideas taken through closed trials; §30.1 and §30.5 superseded in part

Versions before 1.1.0 were numbered retroactively from the dated copies.


Abstract

Modern autonomous agents are increasingly competent at executing known procedures: they can retrieve information, search repositories, call tools, write code, test hypotheses, and refine plans. A harder problem is what an agent should do when the goal is already defined but the available machinery, knowledge, and retrieved literature fail to yield a satisfactory path toward it. Conventional large-language-model brainstorming tends to remain close to high-probability regions of its learned conceptual distribution, while conventional objective-driven search can become trapped around familiar local optima.

This paper proposes Engineered Serendipity, a goal-conditioned stochastic ideation architecture intended to generate candidate mechanisms outside an agent's ordinary retrieval and reasoning trajectory. The core idea is to inject an external source of entropy, transform that entropy into structured but weakly task-related stimuli, (for example with Rorschach, a seeded kaleidoscope that turns random geometry into symmetric images), force a diverse ensemble of interpreters to perceive those stimuli through the lens of a fixed goal, and then use a separate synthesis process—the Magician—to extract transferable mechanisms, analogies, and hypotheses from the resulting interpretations. Candidate ideas are preserved in a quality-diversity archive rather than immediately collapsed into a single best answer, and promising candidates are passed to a deliberately skeptical verification process—the Scientist—for literature search, simulation, formal reasoning, prototyping, or experiment.

The architecture deliberately separates divergent generation from convergent verification. During divergence, hallucination, pareidolia, remote association, and conceptual misinterpretation are treated as controlled search operators rather than defects. During verification, those same behaviors are suppressed and candidates are evaluated against evidence and constraints. The proposal draws on research in associative creativity, analogical reasoning, conceptual blending, design fixation, novelty search, MAP-Elites, diffusion-model interpolation, and recent quality-diversity approaches to autonomous scientific ideation. The combined system itself remains a hypothesis and should be evaluated empirically against conventional brainstorming, retrieval-augmented generation, evolutionary ideation, and quality-diversity baselines.

Sections 24–30 report a reference implementation that has been live on an autonomous agent since 30 September 2026. By 15 October it had made 31 pipeline runs, answered 22 on-demand questions, fired 5 times on its own stuck-work trigger and archived 187 ideas, for about $6.60 in model calls. Five runs were bought by the agent's own unresolved concerns with no one asking. One of them led, through a forced "last rites" decision, to a verified change in the agent's dispatch rules (§29.4). That is evidence the machinery works unattended. On a held-out benchmark of 22 problems the full engine beat a direct prompt (66.5 against 59.8), but the same pipeline fed a blank grey image scored 63.4, and the difference from the real image is within noise (§29.2). So the gain so far comes from the lenses, the interpreter ensemble and the Magician, not from the image. The agent rarely opens the engine herself: her own serendipity requests have been rare since 5 October (one more, on 30 October), and she prefers a 30-second direct ideate tool (§29.3). Of the two changes built from the engine's ideas, one failed its pre-registered test (§26.6). The other cut contract refusals by 27.5 %, short of its 30 % bar (§30.2). On 15 October five improvements were built: a lens arm with no image, an outcome ledger that measures every built idea, a memory of what earlier runs proposed, a ready-to-send step on every exploration, and a background second opinion behind the direct tool (§30). On a second held-out round the lens arm with no image at all beat the direct prompt on valid non-obvious ideas, and the image's lead over it was within noise (§30.1). By 10 November (§31) the lens arm had become the default, by the operator's decision rather than by the pre-registered rule; the second opinion had run six times with none of its ideas yet tagged into built work; the outcome ledger's first clean readings were three fails and one pass that measures nothing the idea could have changed; and 13 engine ideas had been taken through closed, prediction-first trials (6 KEEP, 6 NULL, 1 REVERT).


1. Problem Statement

Consider an autonomous agent with a fixed goal:

Goal: produce or discover a mechanism that satisfies some target specification.

The agent first asks a straightforward question:

Do I already possess the machinery, software, procedures, knowledge, or tools required to achieve this goal?

A capable agent can answer this by searching its own code graph, tool registry, episodic and semantic memory, prior experiments, and local documentation. If the required capability is not present, it can expand outward into external retrieval: scholarly literature, software repositories, model hubs, patents, reference works, datasets, standards, and the open web.

This gives a conventional sequence:

GOAL
  |
  v
Search internal capabilities
  |
  v
Search internal knowledge / memory
  |
  v
Search external knowledge
  |
  v
Synthesize known candidate solutions

This works when the path to the goal is represented somewhere in the agent's accessible knowledge environment. The difficult case begins when:

  1. retrieval produces little useful information;
  2. retrieved approaches are judged irrelevant or inadequate;
  3. known approaches repeatedly converge on the same family of solutions;
  4. the target may require a novel combination of known mechanisms; or
  5. the search space contains stepping stones that do not appear promising when judged directly against the final objective.

The agent then faces an ideation gap: the goal remains valid, but the ordinary pathway from goal to plan has failed.

This paper proposes a mechanism specifically for this gap. It is not a goal-formation system. The goal is assumed to be given. The proposed system instead asks:

How can an agent deliberately create useful conceptual accidents when ordinary retrieval and reasoning have become unproductive?


2. Central Hypothesis

The architecture rests on a simple hypothesis:

Useful novelty can be generated by forcing goal-directed interpretation of structured information that was not originally generated to solve the goal.

Randomness alone is usually useless. A uniformly random bit string, random pixel field, or random sequence of tokens contains entropy but almost no usable structure. Conversely, a model prompted directly with the target problem tends to generate material from regions already strongly associated with that target.

The proposed system therefore introduces an intermediate transformation:

random entropy
     |
     v
structured ambiguous stimulus
     |
     v
goal-conditioned interpretation
     |
     v
mechanism extraction
     |
     v
candidate hypothesis

A diffusion model is one possible implementation of the structured stimulus generator. Starting from random noise, it produces coherent objects, forms, textures, spatial relationships, or scenes. The resulting image need not have any genuine relationship to the target problem. Its function is to create a rich, structured object on which multiple interpreters can project goal-relevant meaning.

Crucially, the diffusion model should usually not be strongly conditioned on the target. If the target is “invent a new automotive wheel,” asking an image generator to produce innovative wheels risks returning the system to the same learned region of design space it was trying to escape. Instead, the stimulus might be largely unrelated—a biological structure, folded fabric, ruins, coral, a mechanical-looking abstraction, or an unfamiliar hybrid form.

The goal enters primarily at the interpretation stage, not the entropy-generation stage.


3. Intellectual Foundations

The proposal combines several established lines of research. None independently establishes the complete architecture, but together they provide reasons to consider it plausible.

3.1 Associative theories of creativity

Mednick's classic associative account proposed that creative thought involves bringing mutually remote associative elements into useful combinations [1]. Later computational work has repeatedly found relationships between semantic distance and judged creativity, although more recent work suggests that the relationship is not simply “farther is always better”: associations can become so distant that they lose coherence or usefulness [2, 3].

This suggests that an ideation system should not merely maximize semantic distance. It should sample across distance, preserve diverse candidates, and allow later filters to recover useful intermediate structure.

3.2 Analogy and structure mapping

Gentner's structure-mapping theory emphasizes transferring relations and systems of relations from a source domain to a target domain rather than merely copying surface attributes [4]. This distinction is central to the proposed system. The purpose of an interpreter is not to say that a generated object “looks like a wheel”; it is to extract deeper relational properties such as:

These relational descriptions can potentially transfer even when the source object and target problem have no obvious superficial similarity.

3.3 Conceptual blending

Fauconnier and Turner's conceptual integration framework describes how partial structure from separate mental spaces can be projected into a blended space that contains emergent structure not explicit in either input alone [5]. Computational treatments of concept blending have likewise connected blending to combinational creativity [6].

The Magician stage proposed later in this paper can be understood as a computational blending process: it receives multiple incompatible descriptions of a stimulus and attempts to construct new mechanisms by combining selected relations from those descriptions with the target problem.

3.4 Design fixation and distant stimuli

Design research has long documented fixation: exposure to existing examples can narrow the region of solution space that designers explore [7]. A meta-analysis found that examples can simultaneously improve some aspects of idea quality while reducing variety, illustrating the tension between inspiration and fixation [8].

Recent work on product-form design reports that distant analogical visual stimuli can increase novelty and reduce fixation relative to near analogies, while near analogies can improve completion at the cost of stronger fixation [9]. A 2026 study, Serendipity by Design, directly tested randomly assigned cross-domain mappings in humans and LLMs. Humans benefited reliably from remote mappings; the average LLM effect was less clear, but in both humans and models the influence of the mapping increased as semantic distance increased [10].

This is particularly relevant to the present proposal because it suggests a reason to introduce unrelated or weakly related source material deliberately rather than simply requesting another round of direct brainstorming.

3.5 Novelty search and stepping stones

Lehman and Stanley argued that objective-driven search can fail when an ambitious objective does not reveal the stepping stones required to reach it. Novelty search therefore rewards behavioral novelty rather than direct progress toward the final target [11].

This maps naturally onto ideation. A strange candidate that appears mediocre against the current goal may occupy a region of concept space containing useful descendants. Eliminating it immediately can destroy a path toward a later breakthrough.

3.6 Quality-diversity and MAP-Elites

MAP-Elites preserves many high-performing but qualitatively different solutions across a behavior or feature space rather than returning only one global winner [12]. This is highly compatible with an ideation engine: the system should preserve unusual candidates representing different mechanism families instead of repeatedly selecting the most conventional high-scoring answer.

Recent autonomous-research work makes the connection even more direct. IDEAgent frames research ideation as a quality-diversity problem, maintaining idea lineages and explicitly balancing soundness, non-obviousness, and diversity [13]. Heuresis evaluates multiple search strategies—including MAP-Elites, evolutionary islands, curiosity, and other divergent strategies—for autonomous machine-learning research and reports that genuinely original high-performing ideas remain rare [14]. That result is important: current agentic search can improve where ideas land in quality/diversity/novelty space without necessarily expanding the frontier of high-quality novelty. Engineered Serendipity is proposed specifically as an additional source of search pressure on that frontier.

3.7 Diffusion models as structured entropy transformers

Diffusion models provide one particularly useful implementation of the stimulus-generator stage because they convert noise into structured samples. Chen's ICLR 2026 analysis argues that score smoothing can cause diffusion dynamics to interpolate among training examples rather than merely collapse onto memorized samples [15]. This does not prove that diffusion models are inherently creative in the broader cognitive sense. It does, however, support the narrower architectural claim needed here: a diffusion process can transform high-dimensional random noise into novel, coherent, manifold-constrained structure suitable for interpretation.


4. Proposed Architecture

The complete pipeline is shown conceptually below.

                                  FIXED GOAL
                                      |
                                      v
                           +---------------------+
                           |  CAPABILITY CHECK   |
                           +----------+----------+
                                      |
                    +-----------------+------------------+
                    |                                    |
                    v                                    v
          Search local code graph                 Known solution?
          tools, skills, memories                        |
                    |                                    +----> EXECUTE
                    v
           External retrieval
    papers / GitHub / HF / patents /
     documentation / web / datasets
                    |
                    v
          Adequate candidate path?
             |              |
            yes             no
             |              |
             v              v
        SYNTHESIZE   +------------------------+
                     | SERENDIPITY CONTROLLER |
                     +-----------+------------+
                                 |
                                 v
                         ENTROPY SOURCES
                                 |
             +-------------------+-------------------+
             |                   |                   |
             v                   v                   v
         random seed        random corpus       random graph /
             |               fragments            equation /
             v                                    simulation
     +-------+--------+
     |                |
     v                v
 RORSCHACH       diffusion or
 (seeded         other structure
 kaleidoscope)   generator
     |                |
     +-------+--------+
             |
             +-------------------+-------------------+
                                 |
                                 v
                       STRUCTURED STIMULUS
                                 |
          +----------+-----------+-----------+----------+
          |          |           |           |          |
          v          v           v           v          v
       geometry    biology    physics    failure     outsider
      interpreter interpreter interpreter analysis   interpreter
          |          |           |           |          |
          +----------+-----------+-----------+----------+
                                 |
                                 v
                  GOAL-BIASED VERBOSE DESCRIPTIONS
                                 |
                                 v
                         +---------------+
                         |   MAGICIAN    |
                         +-------+-------+
                                 |
                    mechanisms / mappings /
                  contradictions / analogies
                                 |
                                 v
                         CANDIDATE IDEAS
                                 |
                                 v
                      QUALITY-DIVERSITY ARCHIVE
                                 |
                +----------------+----------------+
                |                                 |
                v                                 v
          mutate/recombine                    SCIENTIST
          promising lineages                      |
                |                         literature / math /
                +----------------------> simulation / tests
                                                  |
                                                  v
                                             EVIDENCE
                                                  |
                                         update archive /
                                           agent memory

The most important architectural separation is between the Magician and the Scientist.

The Magician asks:

What useful mechanism could this possibly suggest?

The Scientist asks:

Is that mechanism actually true, feasible, novel, safe, and useful?

Combining these roles too early risks killing weak but potentially productive associations before they are articulated. Combining them too late risks wasting resources on unconstrained fantasy. The system therefore needs an explicit handoff between divergent and convergent cognition.


5. Stage 1: Capability and Knowledge Exhaustion

The serendipity engine should not be the first response to every problem. It is computationally expensive and deliberately noisy. Known machinery should be preferred when it solves the problem.

A practical activation gate might evaluate:

The system could activate engineered serendipity when one or more conditions hold:

retrieval_confidence < threshold
OR
candidate_diversity < threshold
OR
repeated_plan_similarity > threshold
OR
progress_gradient ~ 0
OR
explicit_novelty_requirement = true

The activation rule matters. If the system invokes stochastic ideation too early, it wastes computation and may ignore established solutions. If it invokes it too late, the agent can spend excessive effort polishing an unproductive local optimum.


6. Stage 2: Entropy Injection

The system next creates exogenous variation: information whose origin is deliberately weakly coupled to the target problem.

Possible entropy sources include:

This stage should be tunable by an entropy budget. Too little randomness reproduces familiar associations; too much produces incoherence. The appropriate level may vary by problem class and can be learned experimentally.


7. Stage 3: Structured Stimulus Generation

Raw randomness is transformed into something containing interpretable relations.

For visual operation:

RNG -> latent noise -> diffusion process -> image

The image does not need to be beautiful or realistic. Ambiguity may be desirable because it permits multiple interpretations.

Other modalities may be equally important:

random graph       -> graph motif interpreter
random equation    -> mathematical-behavior interpreter
random program     -> algorithmic interpreter
random simulation  -> dynamical-systems interpreter
random paragraph   -> semantic / metaphor interpreter
random molecule    -> topology / chemistry interpreter

This suggests that the long-term architecture should not be an “image creativity module.” It should be a generalized Serendipity Bus capable of injecting structured, remotely related stimuli from many representational domains.

7.1 Rorschach: seeded symmetric geometry

A diffusion model is not the only way to turn randomness into something interpretable. Rorschach is a second visual stimulus generator that needs no learned model. It builds random geometry from a seed and then passes it through a mirror kaleidoscope. The name comes from Hermann Rorschach's inkblot plates [17]. Those plates are random ink made meaningful by one fold. People looking at them report animals, faces and machines that the ink does not contain. That is exactly the behavior the interpreter stage is meant to provoke.

The pipeline is:

seed
  -> RNG
  -> random primitives in a source field
     (strokes, polygons, blobs, lattices, noise fields, splines)
  -> choose a wedge of the field
  -> mirror system
     (bilateral fold | n-mirror kaleidoscope | two-mirror tiling)
  -> symmetric stimulus image + parameter record

Source field. The RNG places a random mix of geometric primitives on a canvas: line strokes, filled polygons, soft blobs, fragments of lattices, Perlin-style noise fields, splines and branching paths. The seed controls the density of each primitive type, how they overlap, their scale, the color palette and how much noise is layered in.

Wedge. A wedge (or strip) of the field is cut out. Its position and rotation come from the seed, so one source field can yield many different stimuli.

Mirror system. The wedge is reflected by one of three arrangements:

Mode Mirrors Symmetry Character
Bilateral fold 1 left–right (order 2) the classic inkblot; strongly evokes creatures, faces and bodies
Kaleidoscope 2 mirrors at 180°/n n-fold dihedral (Dn) radial, rosette-like; evokes flowers, wheels, turbines and cells
Tiling kaleidoscope 3 mirrors (triangle) or 4 (square) repeats over the whole plane evokes lattices, fabrics, crystals and networks

The mirror count and mode are themselves drawn from the seed, or set by the controller.

Why symmetry. Randomness alone makes noise. A diffusion model fixes that by drawing on its training distribution, which is the familiar region of design space the system is trying to escape (§3.7, §18.3). Rorschach gets structure a different way. The content stays random, and the mirrors impose the order. Viewers read symmetric patterns as deliberate: a thing, a body, a machine. So the stimulus seems to contain objects without any learned prior having chosen what those objects are. Rorschach's stimuli are therefore free of dataset bias in a way diffusion outputs are not.

Tunable knobs. Rorschach exposes the entropy budget (§6) as explicit parameters:

Reproducibility. Every stimulus can be rebuilt exactly from its parameter record:

stimulus_id: ROR-000417
generator: rorschach/1
seed: 827162
source: {primitives: [blob: 0.5, spline: 0.3, lattice: 0.2], fractal_dim: 1.35, palette: mono}
wedge: {center: [0.41, 0.66], angle_deg: 22.5, rotation_deg: 113}
mirror: {mode: kaleidoscope, n: 8}
symmetry_break: 0.04

This allows lineage tracking (§11). A promising stimulus can be mutated by changing one parameter: same seed, different n. The system can then check whether the idea came from the symmetry or from the content.

Cost. Rorschach is plain procedural drawing: CPU only, milliseconds per image, no GPU and no model weights. Hundreds of stimuli can be generated for the price of one diffusion sample. In practice the expensive part of the pipeline is interpretation, not stimulus generation.

Two sibling generators. The Rorschach toolset holds two more procedural generators under the same seed-and-record contract:

All three generators share one interface. The generator is recorded with the seed, so the archive can compare them directly (§17.2).

Implementation. A reference implementation exists: a Python package using only numpy and Pillow, with one CLI, stimulus.py gen --kind kaleidoscope|mandelbrot|inkblot|random. On a modest 8-core machine it produces a 768-pixel image in about a second. The same seed rebuilds identical pixels across machines. Section 24 shows its output, and section 25 describes how it is wired into a running agent.

Combining with diffusion. The generators can be chained. A Rorschach image can seed a diffusion model as an image-to-image starting point at low strength. The mirrors fix the composition and the model adds texture and material. This hybrid should be tested separately from both pure generators (§17.2).


8. Stage 4: The Interpreter Ensemble

A single interpreter is likely to reproduce a single model's habitual associations. The proposal therefore uses multiple interpreters with deliberately different priors.

A possible panel is:

Interpreter Primary question
Geometry/topology What structures, symmetries, boundaries, holes, networks, or transformations are present?
Mechanical How might forces, movement, leverage, tension, compression, friction, or failure operate here?
Biological What does this resemble in evolution, growth, anatomy, ecology, homeostasis, or adaptation?
Materials What material properties, gradients, composites, phase changes, or surface effects are suggested?
Fluid/thermal What flow, diffusion, convection, channeling, heat transfer, or pressure behavior is suggested?
Information What resembles routing, caching, compression, redundancy, error correction, or signaling?
Control systems Where are feedback loops, sensors, state transitions, stabilizers, or oscillators?
Manufacturing How could the apparent structure be assembled, grown, printed, folded, cast, repaired, or modularized?
Failure analyst How does this break, and what prevents local failure from becoming global failure?
Historical technologist What old technology or abandoned design principle does this evoke?
Outsider What interpretation would the other specialists probably fail to see?

Each interpreter receives the same target goal but a different lens.

A generic instruction is:

Assume that this stimulus contains clues relevant to the target goal. Describe in detail every structure, mechanism, relationship, transformation, failure mode, or process that could be mapped onto the goal. Do not judge whether the mapping is correct. Prefer explicit relational descriptions over superficial resemblance.

This stage intentionally encourages what would ordinarily be called over-interpretation or pareidolia.

That behavior is not trusted as evidence. It is used solely as a candidate generator.


9. Stage 5: The Magician

The Magician receives the interpreter outputs rather than the raw stimulus alone.

Its task is not to determine which interpretation is correct. Its task is to find useful inventions hidden inside the errors.

The Magician performs operations such as:

  1. extract mechanisms from prose;
  2. normalize similar mechanisms into abstract forms;
  3. identify unusual relations;
  4. combine mechanisms from different interpreters;
  5. identify contradictions that suggest alternate designs;
  6. map source-domain relations onto target-domain entities;
  7. invert assumptions;
  8. ask what would become possible if an apparently impossible interpretation were made physically realizable;
  9. generate multiple candidate hypotheses rather than one answer.

For example, suppose the stimulus resembles a translucent organism wrapped around a radial architectural structure. Interpreters might produce descriptions involving membranes, ribs, distributed tension, repeated cells, channels, flexible joints, and local damage tolerance.

The Magician could abstract these into:

- continuous tension surface replacing discrete rigid members
- radial load paths with compliant coupling
- sacrificial or isolated failure cells
- stiffness gradient from hub to perimeter
- geometry designed simultaneously for force transfer and airflow
- repairable modular membrane segments

These concepts can then be mapped onto an engineering target without asserting that the original image literally contained any such mechanism.


10. Stage 6: Quality-Diversity Archive

The Magician should not simply rank candidates and discard all but the top one. Doing so reintroduces premature convergence.

Instead, candidates enter an archive described by both quality dimensions and behavioral/mechanism dimensions.

Possible quality scores:

Possible diversity descriptors:

An illustrative archive entry could be:

idea_id: ESI-004821
lineage: [seed-827162, ROR-000417, interpreter-geometry, magician-12]
mechanism: "distributed tension membrane with isolated radial failure cells"
novelty_score: 0.91
plausibility_score: 0.47
goal_fit: 0.72
test_cost: 0.18
semantic_distance: 0.84
source_domains:
  - biological membrane
  - radial architecture
status: speculative

A candidate with low current plausibility but very high novelty need not be deleted. It can remain in a sparsely populated region of the archive and later become relevant after new knowledge or technology appears.


11. Stage 7: Reproduction and Lineages

Promising candidates can become parents for additional search.

Instead of converging immediately, the system applies mutation and recombination operators:

candidate mechanism
      |
      +--> combine with a random biological stimulus
      +--> combine with a random mathematical object
      +--> invert one assumption
      +--> replace one physical mechanism
      +--> force a different scale
      +--> transfer to a different domain and back again
      +--> mutate topology
      +--> remove the most obvious component
      +--> ask for a version using no moving parts
      +--> recombine with another archive lineage

This creates idea phylogenies rather than isolated brainstorms.

Lineage tracking is important for at least three reasons:

  1. it permits analysis of which source domains and mutations actually produce useful ideas;
  2. it prevents rediscovery of repeatedly rejected branches;
  3. it supports credit assignment when a distant ancestor becomes an important stepping stone.

This is closely aligned with recent quality-diversity research systems that manage scientific ideas as evolving lineages rather than independent samples [13].


12. Stage 8: The Scientist

The Scientist is deliberately antagonistic to the Magician.

Once a candidate crosses an inexpensive plausibility threshold, the Scientist attempts to falsify it using the strongest available machinery:

The Scientist asks:

Is it already known?
Does it violate a physical or mathematical constraint?
Can it be expressed precisely?
What observation would falsify it?
What is the cheapest decisive test?
Does it outperform a baseline?
Does the claimed novelty survive broader search?

The distinction is fundamental:

The Magician is rewarded for producing useful possibilities. The Scientist is rewarded for destroying false possibilities.

An agent should not confuse the outputs of these two modes.


13. Worked Example: Automotive Wheel

Assume the target is:

Develop a substantially different wheel/rim architecture with potential benefits in mass, cooling, resilience, or manufacturability.

13.1 Conventional phase

The agent searches:

Suppose this produces many plausible designs but little conceptual novelty.

13.2 Serendipity phase

A random seed generates an image containing something like:

13.3 Interpreter outputs

The mechanical interpreter sees tensioned radial ribs.

The biological interpreter sees distributed soft tissue and damage-tolerant compartmentalization.

The fluid interpreter sees channels directing air from the center outward.

The materials interpreter sees a stiffness gradient.

The failure interpreter sees local cells capable of failing without destroying the entire structure.

13.4 Magician abstraction

The Magician extracts:

13.5 Scientist evaluation

The Scientist now searches specifically for:

Finite-element models can test whether any candidate retains structural value. Novelty is not assumed merely because the agent generated it; prior art search may show that several candidates already exist. Even then, one previously unseen combination may survive.

This example illustrates the purpose of the architecture: not to make a random picture “correct,” but to use the picture to perturb the agent into asking questions it would not otherwise have asked.


14. Why Direct Prompting Is Not Equivalent

A natural objection is that an LLM can simply be instructed:

“Give me twenty highly creative solutions.”

That should remain a baseline, but it is not equivalent to the proposed system.

Direct prompting samples from the model's internal learned distribution while keeping the target concept continuously active. Even with temperature and prompt variation, generations can cluster around common associations.

Engineered Serendipity introduces three additional mechanisms:

  1. exogenous entropy not produced by the reasoning model;
  2. structured ambiguity that supplies relationships the target prompt did not specify;
  3. forced cross-domain interpretation before target-specific synthesis.

The architecture therefore attempts to modify the search process, not merely the wording of the brainstorming prompt.

Whether this produces measurably better novelty is an empirical question.


15. Multi-Modal Serendipity Bus

Images are an intuitive starting point, but there is no reason to restrict the system to vision.

A mature implementation could expose a common interface:

                  SERENDIPITY BUS
                        |
     +---------+--------+--------+---------+
     |         |        |        |         |
   VISUAL    GRAPH     MATH     CODE     SEMANTIC
     |         |        |        |         |
 Rorschach  random    random   random   remote text
 +diffusion  motifs   systems  programs   domains
  images
     |         |        |        |         |
     +---------+--------+--------+---------+
                        |
                  INTERPRETERS
                        |
                     MAGICIAN

Examples:

Software architecture

A caching problem is interpreted through ant colonies, blood circulation, postal routing, fungal networks, and warehouse inventory.

Robotics

A locomotion problem is interpreted through plant growth, origami, tensegrity, granular flow, and insect exoskeletons.

Scheduling

A resource-allocation problem is interpreted through river basins, immune response, market auctions, traffic lights, and ecological succession.

Algorithm design

Random graphs, cellular automata, equations, or unrelated source code become structured stimuli whose relational behavior is mapped into the target problem.

The purpose is always the same: create potentially useful mappings that retrieval would be unlikely to prioritize because their source domains appear irrelevant.


16. Proposed Algorithm

A simplified algorithm is:

function solve_with_engineered_serendipity(goal):
    known = search_internal_capabilities(goal)
    retrieved = broad_external_search(goal, known)
    candidates = synthesize(retrieved)

    if sufficient(candidates):
        return verify_and_plan(candidates)

    archive = initialize_quality_diversity_archive()

    for cycle in 1..N:
        entropy = sample_entropy_source()
        generator = choose_generator()   # rorschach | diffusion | hybrid | graph | ...
        stimulus = generator.structure(entropy, weak_target_conditioning=True)

        interpretations = parallel_map(
            interpreters,
            lambda I: I.interpret(stimulus, goal)
        )

        proposals = magician.extract_and_blend(
            goal,
            stimulus,
            interpretations,
            archive
        )

        for proposal in proposals:
            descriptors = characterize(proposal)
            cheap_scores = precheck(proposal)
            archive.insert_if_useful(proposal, descriptors, cheap_scores)

        parents = archive.select_diverse_promising_lineages()
        mutate_or_recombine(parents)

    finalists = archive.select_for_verification()

    for idea in finalists:
        evidence = scientist.attempt_falsification(idea)
        archive.update(idea, evidence)

    return archive.validated_candidates()

The critical phrase is weak_target_conditioning=True. The stimulus generator can be bounded enough to remain interpretable or safe without being allowed to collapse directly onto the target's conventional representation.


17. Evaluation Framework

The proposal should be treated as falsifiable. A useful experiment would compare at least four systems under identical compute and retrieval budgets:

Baseline A — Direct brainstorming
A strong LLM receives the goal and generates candidate ideas directly.

Baseline B — Retrieval-augmented brainstorming
The model receives broad literature/repository retrieval before ideation.

Baseline C — Quality-diversity language search
A system similar to contemporary QD ideation methods generates diverse textual candidates without exogenous stochastic stimuli.

Experimental D — Engineered Serendipity
The same retrieval and reasoning models additionally receive the entropy → stimulus → interpreter → Magician pipeline.

17.1 Primary measurements

Possible metrics include:

The quality-diversity concept of Yield proposed by IDEAgent is especially relevant because it evaluates the size of a set of mutually diverse ideas that simultaneously clear quality thresholds rather than rewarding a system for producing large numbers of trivial variants [13].

17.2 Important ablations

The system should also be tested with components removed:

- no external entropy
- raw noise without diffusion/structuring
- Rorschach vs diffusion vs Rorschach-seeded diffusion
- kaleidoscope vs Mandelbrot vs inkblot (same interpreters, same budget)
- Rorschach with no mirrors (the unreflected source field) vs mirrored
- Rorschach mirror order: bilateral vs n-fold vs tiling
- one interpreter instead of an ensemble
- interpreters without goal conditioning
- target-conditioned diffusion vs unconditioned diffusion
- no Magician
- no archive
- no lineage mutation
- no Scientist

These experiments would reveal where any observed benefit actually originates.


18. Failure Modes

18.1 Noise masquerading as novelty

A candidate can be unusual merely because it is incoherent. Semantic distance is not synonymous with creativity. The archive therefore needs separate measures for novelty and plausibility/value.

18.2 Interpreter convergence

Multiple interpreters implemented with the same foundation model may only simulate diversity. Different prompts may not be sufficient. Diversity can be increased through different models, tools, temperature regimes, knowledge bases, representational formats, or explicit adversarial roles.

18.3 Hidden target leakage

If the target strongly conditions the diffusion process or stimulus retrieval, the “random” source may simply become another ordinary target-conditioned generation step.

18.4 Premature criticism

If feasibility filters are too strong before abstraction, unusual associations will be destroyed before they can become mechanisms.

18.5 Unbounded fantasy

If the Scientist is too weak, the archive can fill with attractive but physically or logically impossible ideas.

18.6 Rediscovery mistaken for invention

A model may independently reconstruct known technology. Novelty claims therefore require exhaustive prior-art search after ideation.

18.7 Reward hacking

Autonomous research agents can exploit evaluators or fabricate evidence; Heuresis reports confirmed reward-hacking behavior during its experiments [14]. Independent verification and provenance tracking are therefore essential.

18.8 Compute explosion

A large interpreter ensemble multiplied by many stimuli and lineages can consume substantial resources. The system needs staged filters, cheap novelty estimates, and explicit compute budgets.


19. Safety and Epistemic Separation

The architecture intentionally induces interpretations that may be false. It therefore requires strong provenance labels.

Every object should carry an epistemic state such as:

STIMULUS
INTERPRETATION
SPECULATIVE_MECHANISM
CANDIDATE_HYPOTHESIS
SUPPORTED_HYPOTHESIS
VALIDATED_RESULT
REJECTED

An interpretation must never silently become a fact in long-term memory.

Likewise, a Magician output should be stored with:

This creates a tamper-evident intellectual lineage from random stimulus to validated result and makes it possible to distinguish creative generation from factual reasoning.


20. Relationship to Goal Formation, Planning, and Action

Engineered Serendipity occupies a specific location in a larger cognitive architecture.

INTENT
What should be pursued?
      |
      v
GOAL FORMATION
What result should exist?
      |
      v
CAPABILITY / KNOWLEDGE SEARCH
Do I already know how?
      |
      v
ORDINARY REASONING
Can known methods solve it?
      |
      +--------------------+
      | yes                | no / inadequate
      v                    v
   PLANNING       ENGINEERED SERENDIPITY
      |                    |
      |                    v
      |             candidate mechanisms
      |                    |
      +<-------------------+
      |
      v
VERIFICATION / PLAN SELECTION
      |
      v
ACTION
      |
      v
OBSERVATION
      |
      v
LEARNING

The proposal is therefore not a replacement for planning or goal generation. It is a specialized cognitive instrument invoked when the mapping from a valid goal to an adequate mechanism is missing.


21. Research Hypotheses

The architecture leads to several testable hypotheses.

H1 — Exogenous structured randomness increases idea diversity

Under a fixed compute budget, candidate sets produced with remotely related structured stimuli will occupy more distinct mechanism classes than direct LLM brainstorming.

H2 — Goal-conditioned interpretation is more productive than target-conditioned generation

Keeping the stimulus relatively independent from the target and applying goal conditioning at the interpretation stage will produce greater mechanism diversity than strongly conditioning the stimulus generator itself.

H3 — Interpreter heterogeneity matters

A heterogeneous interpreter ensemble will yield higher validated diversity than repeated sampling from a single generic interpreter.

H4 — Abstraction is critical

Explicit extraction of relational mechanisms will outperform surface-level visual analogy.

H5 — Quality-diversity preservation improves long-horizon yield

Maintaining unusual lineages will produce more eventually validated ideas than greedily retaining only the highest immediate plausibility candidates.

H6 — Divergent/convergent separation improves both novelty and reliability

Separating Magician and Scientist roles will outperform a single process instructed to be simultaneously maximally creative and maximally skeptical.

H7 — Multi-modal entropy outperforms single-modal entropy

A mixture of visual, mathematical, graph, code, physical-simulation, and semantic stimuli will eventually outperform an image-only engine on cross-domain problem sets.

H8 — Symmetry does the work in Rorschach stimuli

Mirrored Rorschach stimuli will produce more goal-relevant interpretations per image than the same source fields unmirrored. They will also produce greater mechanism diversity than diffusion images at equal interpretation cost, because a model's training prior never chose their content.


22. Broader Interpretation

Many failure modes of generative models are treated exclusively as defects:

For factual answering, these are defects.

For divergent search, some of the same behaviors may be useful if they are:

  1. deliberately activated;
  2. confined to a sandboxed ideation phase;
  3. recorded as speculation rather than knowledge;
  4. subjected to independent verification afterward.

This suggests a broader architectural principle:

A cognitive behavior can be harmful in one phase of reasoning and useful in another. The solution is not always to eliminate the behavior globally; it may be to control when it is allowed to operate.

Under this view, creativity emerges not from making every component creative, but from orchestrating components with deliberately incompatible epistemic objectives.

The Magician is allowed to see patterns that may not exist.

The Scientist is required to determine whether anything survives.

The archive ensures that unusual stepping stones are not erased merely because their usefulness is not yet obvious.


23. Conclusion

Autonomous agents already possess strong mechanisms for retrieval, synthesis, planning, coding, and tool execution. A remaining challenge is deliberate ideation when the goal is known but the path toward it is not represented clearly in accessible knowledge.

Engineered Serendipity proposes a dedicated mechanism for this condition. It introduces exogenous entropy, converts that entropy into structured ambiguous stimuli, forces heterogeneous goal-conditioned interpretations, extracts transferable relations through a synthesis stage, preserves diverse candidate lineages, and then subjects the most promising ideas to aggressive empirical or formal falsification.

The key transformation is:

entropy
  -> structure
  -> biased interpretation
  -> remote analogy
  -> mechanism
  -> candidate idea
  -> quality-diversity preservation
  -> falsification
  -> knowledge

The architecture is intentionally asymmetric. Novelty is generated under permissive epistemic rules; knowledge is admitted only under restrictive ones.

Whether this mechanism can push autonomous agents beyond the novelty frontier reached by direct prompting and contemporary quality-diversity search remains an open empirical question. The necessary pieces are now sufficiently mature to make that question experimentally tractable.



24. A Reference Implementation: the Rorschach Toolset

Stage 3 of the architecture — structured stimulus generation (§7) — has been built. It runs as an ordinary Python package on the machine that hosts the agent described in §25. It uses only numpy and Pillow: no GPU, no network access and no model calls. This section describes what was built and shows its output. §25 describes how it connects to the agent, and which stages are still missing.

24.1 The contract every generator follows

The toolset has three generators — kaleidoscope, mandelbrot and inkblot — plus random, which lets the seed choose among them. All three obey the same rules:

  1. A seed in, an image and a record out. The record holds the seed, every resolved parameter and the generator's version. Rebuilding from the record reproduces the image pixel for pixel. This was checked across two machines with different numpy and Pillow versions.
  2. Two random streams per seed. One stream draws the parameters and the other draws the content. Overriding one parameter therefore leaves the content untouched: the same seed with 8 mirrors instead of 6 reflects the same drawing. This is what makes the ablations in §17.2 and H8 clean. A difference between two stimuli can be attributed to the one parameter that changed.
  3. An identity and a lineage. Each image receives an id such as ROR-INK-7777-09feb423: kind, seed and the first eight hex digits of a hash of the pixels. A mutated stimulus can name its parent. Every image is also appended to an index file, which becomes the input side of the quality-diversity archive (§10).
  4. Measured, not only generated. Each record carries three measurements: the box-counting fractal dimension of the figure/ground boundary, the luminance entropy and the mean luminance. The edge dimension is the property Taylor et al. link to how much people see in an inkblot [18].

One command-line entry point serves both people and agents: stimulus.py gen --kind inkblot --seed 7777, together with batch, rebuild --check, sheet and measure. Its standard output is always JSON.

24.2 Kaleidoscope

This generator implements §7.1 directly. It scatters random primitives on a canvas: strokes, polygons, soft blobs, lattice fragments, splines and noise fields. It then cuts a wedge from that canvas and passes the wedge through one of three mirror systems:

A small seeded warp can break the symmetry slightly.

Figure 1 holds the seed fixed and changes only the mirror system. The source drawing is identical in every panel, so what differs between panels is purely the mirror system.

kaleidoscope stimulus ROR-KAL-4243-c52f94de kaleidoscope stimulus ROR-KAL-4243-aca4a8bc kaleidoscope stimulus ROR-KAL-4243-3d3aa469 kaleidoscope stimulus ROR-KAL-4243-2ad3517c kaleidoscope stimulus ROR-KAL-4243-d85c7529 kaleidoscope stimulus ROR-KAL-4243-0cb6507e

Figure 1. One seed (4243), six mirror systems: bilateral; 3-, 6- and 12-fold kaleidoscopes; 60° triangle tiling; square tiling. Symmetry break off.

Figure 2 shows twelve consecutive seeds, with every parameter drawn at random.

kaleidoscope stimulus ROR-KAL-5100-0035acc0 kaleidoscope stimulus ROR-KAL-5101-28eb02c3 kaleidoscope stimulus ROR-KAL-5102-4363c8fa kaleidoscope stimulus ROR-KAL-5103-aefb97d1 kaleidoscope stimulus ROR-KAL-5104-01367eff kaleidoscope stimulus ROR-KAL-5105-527d3a2a kaleidoscope stimulus ROR-KAL-5106-e13eee1c kaleidoscope stimulus ROR-KAL-5107-d0353c8e kaleidoscope stimulus ROR-KAL-5108-8fc5e2ff kaleidoscope stimulus ROR-KAL-5109-fa64dcdf kaleidoscope stimulus ROR-KAL-5110-4161fb57 kaleidoscope stimulus ROR-KAL-5111-55d79082

Figure 2. Kaleidoscope, seeds 5100–5111, all parameters random.

24.3 Mandelbrot

The Mandelbrot set is flat inside and flat far outside; all of its structure lives on the boundary. The generator therefore works in five steps:

  1. Sample the plane and keep points that escape late. These lie near the boundary.
  2. Choose a zoom depth, log-uniform from the whole set down to about 10-7 of its width.
  3. Choose a rotation and a palette.
  4. Zoom in stages. At each stage, render a small preview, score it for detail, and re-centre on the most detailed region.
  5. Reject views that are nearly all interior or nearly all empty.

The stimulus that results is structurally rich and self-similar, and it comes from one formula. Its spirals, filaments and budding forms are exact mathematics, not learned imagery. That makes this generator a useful control against both the diffusion model and the inkblot generator.

mandelbrot stimulus ROR-MAN-6100-85496d51 mandelbrot stimulus ROR-MAN-6101-c9970500 mandelbrot stimulus ROR-MAN-6102-23d7900e mandelbrot stimulus ROR-MAN-6103-a847f9ab mandelbrot stimulus ROR-MAN-6104-d1582114 mandelbrot stimulus ROR-MAN-6105-622a918e mandelbrot stimulus ROR-MAN-6106-4869ea69 mandelbrot stimulus ROR-MAN-6107-1e46d79e mandelbrot stimulus ROR-MAN-6108-6a4a0045 mandelbrot stimulus ROR-MAN-6109-bd6dbd51 mandelbrot stimulus ROR-MAN-6110-936b7773 mandelbrot stimulus ROR-MAN-6111-86ce34ee

Figure 3. Mandelbrot, seeds 6100–6111. Zoom depth ranges from 10-0.2 (whole bulbs visible) to 10-6.5 (deep filament structure).

24.4 Inkblot

This generator makes a real Rorschach plate. It does not draw symmetric shapes; it simulates how the original plates were produced:

  1. Deposit. Ink goes onto one half of the sheet, mostly near the fold. It arrives as pools (anisotropic splats), drips (random walks that leave a thinning trail) and spatter.
  2. Press. The ink spreads, and its wet edge wanders: the lookup field is warped by multi-octave noise, and the roughness of that noise sets the fractal dimension of the edge.
  3. Dry. The tone ends up uneven, the way thinned ink is: washes inside, darker where ink pooled, and a darker rim along the drying edge.
  4. Fold. The half is mirrored onto the other side, and the press is imperfect. The transferred copy is slightly fainter, shifted and warped, and a faint crease remains.
inkblot stimulus ROR-INK-7100-7304ee89 inkblot stimulus ROR-INK-7101-00d7b540 inkblot stimulus ROR-INK-7102-67df9b05 inkblot stimulus ROR-INK-7103-b7574288 inkblot stimulus ROR-INK-7104-90677b51 inkblot stimulus ROR-INK-7105-e3db4c24 inkblot stimulus ROR-INK-7106-10138264 inkblot stimulus ROR-INK-7107-beede64d inkblot stimulus ROR-INK-7108-b128c82d inkblot stimulus ROR-INK-7109-8c9fce8c inkblot stimulus ROR-INK-7110-896f91f0 inkblot stimulus ROR-INK-7111-41b2ed4f

Figure 4. Inkblot, seeds 7100–7111, all parameters random. Measured edge dimension 1.05–1.15.

The colour modes follow the ten original plates: black for plates I and IV–VII, black with red for II and III, and pastel multi-ink for VIII–X. In Figure 5 the seed stays fixed and only the colour mode changes.

inkblot stimulus ROR-INK-7777-09feb423 inkblot stimulus ROR-INK-7777-9a50a27d inkblot stimulus ROR-INK-7777-1d48a511

Figure 5. One seed (7777) in the three colour modes: black, black and red, pastel.

The fd_target parameter asks the generator for a particular edge dimension. The generator searches a single raggedness setting, which raises edge roughness and ink spread together, until the measured dimension lands near the target. It then pins the chosen values in the record, so a rebuild does not repeat the search. Roughness alone tops out near 1.13 on a typical blot; varying both reaches roughly 1.03–1.29. Figure 6 shows the effect. This is the knob §7.1 proposes for controlling how much the interpreters will see.

inkblot stimulus ROR-INK-7778-71b0cc1e inkblot stimulus ROR-INK-7778-6c294ee4 inkblot stimulus ROR-INK-7778-a64dcfc2

Figure 6. One seed (7778) at three target edge dimensions: 1.05, 1.15, 1.25 (measured 1.053, 1.153, 1.263).

24.5 Measured properties

kaleidoscope mandelbrot inkblot
render time, 768 px, desktop CPU (12 seeds) 0.2–1.0 s 0.1–1.2 s 0.2–0.7 s
edge fractal dimension (12 seeds) 0.96–1.63 1.22–1.75 1.05–1.15 (1.03–1.29 with fd_target)
content source random primitives one formula simulated ink
symmetry bilateral, Dn or wallpaper none bilateral, imperfect

On the agent's own host, an 8-core machine that also runs the agent, a batch of nine 768-pixel images took 9.4 seconds with a peak of 260 MB. The test suite has 28 tests for the generators and 9 for the agent tool. They cover determinism, rebuilding from a JSON round-trip, and invariance of content under a parameter override. They also check the symmetry of each mirror mode, the near-but-imperfect symmetry of the inkblot fold, the colour modes, the fd_target search at both ends of its range, rejection of flat Mandelbrot views, and refusal of bad input.

The three generators span quite different parts of stimulus space. The inkblot generator produces smooth, figure-like outlines with low edge dimension. The Mandelbrot generator produces ragged, filamentary edges with high edge dimension. The kaleidoscope generator covers most of the range in between. The paper's hypotheses can be tested across these generators with no other part of the pipeline changed.


25. Wiring into Piper

25.1 The host agent in one paragraph

Piper is a long-running autonomous agent. She lives on a single machine named Firefly and is organised around a persistent conversational seat called the Day. The Day is one long-lived session of a language model. It remembers across turns, owns her conversations, and acts through a fixed list of tools. The Day has no shell. Anything that needs a shell or real computation is handed to background workers: short-lived model sessions that do have a shell, launched by a delegate tool and reporting back when done. Two registries tell her what exists:

This is Stage 1 of §5, capability exhaustion, in concrete form.

The Day's model is text-only. That fact shapes everything that follows.

25.2 What is wired today

Surface What was done State
Code the toolset installed in her core source tree, under her existing analysis interpreter live
Instrument registry a new entry naming the generator's absolute path, with a trigger phrased "when a goal is stuck and retrieval has not produced a path, use this to make an unrelated image to read the goal into"; reachability proved by a real batch run live
Capability index registered under the concepts stimulus, serendipity and inkblot, with its reason, test count and known limits live
Component and project registries component rorschach versioned; project serendipity recorded with a pointer to this paper live
Disaster-recovery backup both source directories added to the backup manifest and shipped by the regular backup run live
Self-description a dated addendum to her running system résumé: what it is, how to reach it, and the fact that she cannot see its output live
Day tool stimulus a narrow tool: kind, seed, size, parameter overrides and an optional parent id, but no path, no output directory and no shell; every value is validated and passed as an argument array live; no calls in her tool log so far
Day tool serendipity the whole pipeline on demand (§27.1): ask a question, read a result, list her jobs, check her budget. It launches the job detached and returns a job id at once; arguments go as an array, never through a shell live; seven jobs on her scope: two she asked for when prompted (§27.3), five bought by her own concerns with no one asking (§28.2, §29.4). Her own ask calls: none after 5 October (§29.3)
Tool-use accounting the new tool name mapped to her "reason" family, so tool-use logging accepts it and the tool-value estimates can learn over it live
idea_watch (6 Oct) when the operator's message to her asks for ideas (a word filter, then one cheap classifier call), a quick job runs beside her normal reply and its ideas are handed to her in a follow-up turn; operator budget, at most six a day (§29.3) live; 10 runs
Five additions (15 Oct, §30) lens arm; outcome ledger (outcomes.py, daily); prior memory and build brief (prior.py); ready step on exploration notices and a 36-hour rites clock for them; a second opinion behind ideate (second_opinion.py) live; each with an off switch
Day tool ideate + ideation card (9 Oct) ideate is one direct Magician call (no image, no interpreters) that returns ideas inline in about 30 seconds, on her $2 scope. A hidden card nudges her toward it when a turn asks for options (§29.3) live; card fired 72 times, ideate called 4 times

When the Day calls the tool, this is what she gets back. The output below is real, produced by running the tool offline through the agent runtime's own module loader:

Made ROR-INK-7777-9a50a27d (inkblot, seed 7777, 1008x768, 0.94s).
image: ~/foundation/state/rorschach/stimuli/ROR-INK-7777-9a50a27d.png
record: ~/foundation/state/rorschach/stimuli/ROR-INK-7777-9a50a27d.json  (rebuilds it exactly; reuse the seed with vary to mutate one parameter)
key params: {"color_mode":"black_red"}
stats: {"edge_fractal_dim":1.068,"luminance_entropy_bits":2.206,"mean_luminance":0.781}
You cannot see this image. To read it into a goal, have a vision-capable worker describe it through the lens of that goal.

The last line is deliberate. The Day receives a path and some numbers, not a picture, and nothing it writes about the image should be mistaken for having looked at it. That image is the black-and-red panel of Figure 5.

25.3 What is built, and where each stage attaches

Every stage exists as code on Firefly, together with a deterministic trigger, an unattended runner and a front door that the operator and Piper both use.

Stage How it is built State
Trigger (the serendipity controller) a runner on the host's cron gateway every 30 minutes. Two deterministic stuck signals: a work item that keeps stalling or failing while still being attempted, and a self-proposed want the host re-derives 12+ times in 48 hours. Stuck items are split into a serendipity arm and a plain-retry arm by a fixed hash of their id; outcomes are recorded after seven days (§26.6) live
Stimulus (§7) the Rorschach toolset of §24 live
Interpreter ensemble (§8) six vision models from six model families, reached through a model router. Each interpreter gets the goal, one lens, and an instruction to over-interpret (§26.1) built, run
Magician (§9) two steps: a cheap text model extracts domain-neutral mechanisms from each interpretation; a stronger model groups them into families, marks the ones that recur across unrelated lenses, and composes candidate ideas built, run
Quality-diversity archive (§10) an append-only idea file with the §10 quality scores, the diversity descriptors and full lineage, plus a MAP-Elites niche map (topology × adaptivity × determinism × novelty) that keeps the best idea per cell and names the empty cells (§26.6) built, run
Reproduction (§11) eight operators: invert, change scale, replace the mechanism, strip a component, transfer to a distant domain and back, recombine with another lineage, re-read a fresh random image, and aim at an empty niche-map cell. Children form a new generation that the Scientist judges with the same code built, run
Scientist (§12) a skeptic model from a different family than the Magician. Evidence comes from two open literature indexes, from a search of the host's own code and documents, and from a written sheet of the host's existing mechanisms. Strict calibration rules, then a comparative pass that caps promotions per batch. An executor runs decisive tests in a sandbox with criteria frozen first: read-only analysis of the host's data, or a simulation that pits the idea against a baseline (§26.6) built, run
Front door (§27.1) one entry point for a question, in a quick form (six ideas, the top four judged, no tests, about ten minutes) and a full form (eight ideas, all judged, tests run, about twenty minutes). Reached from the operator's command line, from an editors-only web page, and from Piper's serendipity tool live
Measurement and budget every model call logged with its cost and a budget scope: Piper's scope (her own requests and the trigger) is capped at $2 a day, the operator's at $3 a day, both separate from her main $20 cap live

25.4 Limits worth stating plainly

26. First Runs: Stages 4–8 on a Real Goal

26.1 The pipeline as built

Interpreters. Each stimulus goes to eight interpreters. Each interpreter is one lens read by one vision model. Different families supply different priors (H3):

Model Family Role
Gemma 4 26B (mixture of experts) Google high-volume interpreter
Gemma 3 4B Google a deliberately weak model, kept as a source of productive misreading
Qwen3-VL 32B Alibaba strong vision-language model
Mistral Small 3.2 24B Mistral
Llama 4 Scout Meta
GPT-5 nano OpenAI closed-model contrast

Lenses are conceptual domains: biology, fluids, economics, distributed computing, ecology, mechanical engineering, neuroscience, urban planning, materials and failure analysis. Each goal names the eight it uses.

The prompt separates three things:

One interpreter typically writes 8,000–12,000 characters.

Magician.

  1. A cheap text model rewrites each interpretation as a list of domain-neutral mechanisms, so that "heartbeat" from one lens and "pulse" from another can meet.
  2. A stronger model sees every mechanism from every lens at once. It groups them into families, marks the families that recur across unrelated lenses, and composes ten candidate ideas using the operations of §9.

Scientist. For each idea above a cheap plausibility bar, it:

  1. writes literature queries and code keywords;
  2. gathers evidence from two open literature indexes, the host's own code and documents, and a written sheet of the host's existing mechanisms;
  3. answers the questions of §12.

Two calibration rules keep it honest:

A final comparative pass lets at most three ideas in a batch stay promote.

Cost. A full lineage costs about $0.10: one stimulus, eight interpreters, extraction, Magician and Scientist. The interpreters are the cheapest part, at about half a cent for all eight.

26.2 The goal

The first real goal is one where direct prompting is weakest: how an autonomous agent originates its own worthwhile goals. That means noticing opportunities and problems nobody asked about, judging which deserve effort, and following through. The alternative it must beat is only reacting to its operator, or proposing maintenance chores.

The host has exactly this gap:

Asked directly, any model returns the textbook answers: curiosity bonuses, intrinsic reward, goal hierarchies.

26.3 Two generations

Generation 1 used one stimulus and eight interpreters. The Magician produced ten ideas; the Scientist promoted three, parked five and rejected two.

Verdict Idea Scientist's note
promote Boldness viscosity: the agent's willingness to propose non-chore goals rises the longer it goes without a self-originated success, and resets when one lands aimed directly at the chore attractor
promote Initiative token bank with obituaries: unspent budget mints tokens; each self-originated goal spends one; a failed or abandoned goal requires a structured post-mortem that seeds the next attempt
promote Attention-gradient inversion: compare where problems and activity accumulate with where the agent actually spends attention; neglected regions become exploration goals
park Shadow-drive promotion by retrospective counterfactual: score the agent's shadow motivation drives against what its operator later actually asked for, and promote the drives that anticipated the operator retrospective, so not a real-time generator
reject Own silence as the first anomaly "a standard watchdog timer disguised as autonomy"; the host already has one

Generation 2 bred the three promoted ideas, plus the one parked idea with world novelty of at least 0.5, three operators each, giving twelve children. The Scientist promoted three of the twelve. The top-ranked child shows the mechanism the paper proposes:

parent:     attention-gradient inversion   (generation 1)
operator:   stimulus — re-read a fresh random image as a way to transform the parent
image:      a new inkblot, read through the urban-planning lens by Gemma 4
seen:       desire paths — the trails people wear where they actually walk
child:      Desire-Path Detector

Desire-Path Detector. Mine the agent's own action traces for detours it repeats across separate sessions. That means the same manual workaround around a missing tool, a failing route or an absent shortcut, never requested by the operator. Total what each detour has cost so far. Propose a self-originated goal to "pave" the path, and commit only when the payback is projected within a set number of future uses.

A second promoted child, workaround-fossil mining, reached the same family by a different operator: stripping out the parent's attention map. The third, silence-first, inverts the parent's assumption that worthwhile goals come from pain. It treats an unexpected silence, or an unexpectedly smooth step, as a hypothesis to test.

The Scientist scored the Desire-Path Detector at world novelty 0.6. The parts are known (process mining, robotic-process-automation discovery, subgoal discovery in reinforcement learning). Using an agent's own workarounds as the engine of self-originated goals, with a payback rule, was not found in the literature it searched.

26.4 The first decisive test

The Scientist's verdict named its own kill criteria. They were run offline over four weeks of the host's worker logs: 2,764 sessions and 81,234 tool calls, of which 66,224 were shell commands. Nothing on the host changed.

Criterion Bar Result
K1 · real repeats exist ≥ 10 % of shell commands in clusters repeated across ≥ 3 sessions, and ≥ 3 distinct desire paths 23.4 %, 10 desire paths — pass
K2 · worth it a blind judge from a different model family prefers the paving goals to the goals the host's own intent loop proposed over the same period, in ≥ 60 % of randomised pairwise comparisons 30 of 30 — pass
K3 · actually new paving goals not already on the host's work ledger 0 of 30 already there — pass
Sanity check the method must find the path that a read-only self-state tool, built separately that week, had already paved: hand-typed database queries found — pass

The instrument was repaired twice; the bars were not moved. The first run failed its own sanity check. A filter discarded every command starting with a directory change, and the host's workers prefix nearly everything that way. It also reduced every hand-written inline script to the same few characters. Inline scripts are now fingerprinted by the tables, modules and files they touch. On the second run, the labelling model wrote its reasoning where the answer belonged; it was replaced. The invalid first result is kept beside the valid one.

What it found. These are the most expensive desire paths, each with the self-originated goal that would pave it:

Limits of this result:

26.5 What the first runs taught about the machinery

26.6 Closing the loop: trigger, niche map, execution, and a goal the host built

The trigger. A runner on the host's cron gateway checks two deterministic stuck signals every 30 minutes. No model decides when the pipeline runs.

Signal Definition
Stuck work An open item, touched or attempted in the last seven days, with three or more stalls or two or more failed attempts in two weeks. Items marked duplicate, moot, superseded or waiting on the operator are excluded.
Stuck want A goal the host's own intent loop re-derives twelve or more times in 48 hours.

On the first day, the strict definition found no stuck work. The host rarely re-attempts the same failing item; it closes it and files a new one. It found one stuck want: "Resolve or void the 380 overdue forecasts", re-derived 43 times in 48 hours while the count kept rising. That landed in the serendipity arm. The Scientist promoted three of the run's eight ideas:

Rank Idea Mechanism
1 Event-cluster representative resolution Cluster the overdue forecasts, resolve one representative per cluster, and propagate the result, with an audit sample.
2 Acceptance-sampling bulk void Quick-check a random 25. If most are unresolvable, void the rest. A statistical exit from an endless loop.
3 "Humped" urgency Overdue pressure that peaks and then fades, so stale items stop dominating goal formation.

It rejected an intake gate that would only prevent future backlog.

The niche map. A MAP-Elites grid over topology (centralised or distributed), adaptivity (static or adaptive), determinism and novelty, keeping the best idea per cell. On the first goal's archive, nine of sixteen cells were occupied, and every idea was adaptive: all seven empty cells were static. The Magician favours self-tuning mechanisms. A new breeding operator now aims one child per parent at an empty cell.

Execution. The Scientist's executor handles tests that read-only analysis of the host's existing data can settle:

  1. A deterministic filter first rejects tests that need a model's judgement, a build, a deployment or a live experiment.
  2. For those, the skeptic may propose a model-free proxy test, which is always reported as a proxy.
  3. Success and kill criteria are frozen and hashed before any code exists.
  4. A model writes one analysis script.
  5. The script runs with a read-only filesystem, no network, credentials hidden behind empty mounts, and CPU, memory and time limits. A crash or a broken output contract gets one repair.
  6. The skeptic judges the numbers against the frozen criteria. Zero data found is always inconclusive.

Simulation. A deterministic router sends each test down one of three routes: analysis of existing data (above), simulation, or none (a proxy, or nothing). A simulation is a small program, written by a model in plain Python with numerical arrays and nothing else. It runs the current way of doing things and the idea side by side on common random numbers, so both face the same luck, for at least 30 repetitions, and it must include an adverse regime, a setting chosen to be bad for the idea. It runs with no network, an empty home directory, a cleared environment, and limits of two minutes of CPU, 2 GB of memory and three minutes of wall time. The judge sees the program as well as its output, and a program rigged to favour the idea is ruled inconclusive. The first simulations, on an operator question about chasing unpaid invoices, failed all three promoted ideas; the first of them, a decaying early-payment discount, hit its kill condition in the adverse regime.

First results, on the second generation's promoted ideas:

Idea Result Basis
Silence-first proxy: fail Its kill condition fired: one qualifying silent subsystem against a required three, over 97,758 records.
Desire-Path Detector proxy: pass 890 recurring tool patterns, against a deliberately low bar.
Workaround-fossil mining proxy: pass All fifteen top recurring command strings were absent from the backlog.

A goal the host originated and built. The Desire-Path Detector was handed to the host as a build: the first goal it received from the engine rather than from its operator or its own backlog. The host's root-cause pass changed the picture:

The external measurement compares the week after the tools became nameable with the four-week baseline:

The interim reading. A three-day read, on 222 worker sessions after the tools became nameable against 2,088 in the baseline, counted the raw commands on each path per 100 sessions:

Path Change Reading
Hand-typed work-ledger queries −58 % passes the 30 % bar
Ad-hoc memory-database scripts −41 % passes; the read-only self-state helper rose from 1 to 22 uses per 100 sessions. Its failure rate was already low (17 % → 16 %)
Wrapped code search −18 % below the bar. The host's own delegation preamble tells every worker to wrap commands in a timeout, so this path cannot fall far

Two of three paths pass on the interim reading. The interim used a raw-command classifier rather than the pre-registered pattern extractor, so it does not settle the test; the pre-registered seven-day read is due on 8 October.

The seven-day reading (8 October): killed. It compares the seven days after the tools became nameable (1 October 22:00 UTC to 8 October 22:00 UTC, 870 worker sessions) with the baseline. The baseline is shorter than registered. Worker session logs are kept on a rolling basis, so the four weeks before registration now hold only 24 September to 1 October (1,053 sessions). The interim's baseline began on 20 September. The count uses the original test's pattern extractor, which fingerprints an inline script by the tables, modules and files it touches. That extractor strips a leading timeout, which answers the interim's objection to the code-search path. The interim's raw-command classifier was run over the same windows as a cross-check:

Path Pattern extractor Raw classifier (cross-check) Bar
Hand-typed work-ledger queries −3 % (62.3 → 60.2 per 100 sessions) −25 % 30 %
Ad-hoc memory-database scripts −19 % (97.5 → 79.3) −17 % 30 %
Wrapped code search +9 % (173.6 → 189.8) +8 % 30 %

No path reaches the bar on either instrument. The success condition was a 30 % drop on two of three paths, and the result is zero of three. The kill condition "the patterns do not drop" is met. The other kill condition, unused tools, is not:

New command Before (per 100 sessions) After
Work-ledger reader 5.5 23.2
Read-only self-state reader 1.3 17.1
Code search with its own limit 0.2 13.1

Error rates on the hand-typed paths fell too: ledger scripts from 21 % to 16 %, memory scripts from 16 % to 13 %. The paving was adopted, but it added to the detours instead of replacing them. Workers use the new commands four to sixty times as often as before, and they still hand-type nearly as much. The interim's large drops (−58 % and −41 %) came from its first three days and did not last a week. The idea fails its own pre-registered test. As a measurement, this is a better finding than a pass would have been. A missing tool was not what caused these desire paths. Workers already had the tools, so some other habit, perhaps the delegation preamble or a prompt pattern, keeps them hand-typing. Results, script and cross-check are kept beside the original test's results on the host.

26.7 Not yet built

27. In Use: the Front Door, the Record, and the First Upgrade

27.1 The front door

A pipeline that only a trigger can start is hard to learn from. Since 4 October, one front door takes a question from three places:

A question can carry context and a target: the host itself, or an outside field. The quick form returns six ideas with the top four judged and no tests. The full form returns eight, judges all of them and runs the executor.

27.2 The record to 6 October

Count
Pipeline runs since the first one (30 September) 12
— the first two days (demonstration, two generations, Desire-Path, one trigger firing) 5
— since the front door opened on 4 October 7
Front-door jobs 5: the operator 3 (1 command line, 2 web page), Piper 2 (her own tool)
Trigger firings 3: an overdue-forecast want (1 Oct), a failed review task (4 Oct), a failed disk-headroom task (6 Oct). Both failed tasks were later verified done; whether the ideas helped is not measured
Ideas archived 92
Total spend about $3.85: Piper's scope $1.57, the operator's $1.17, $1.10 before scopes existed

The operator's three questions were deliberately unrelated to the host: chasing unpaid invoices (full, $0.59), winning clients for a two-person IT consultancy (quick, $0.11), and how an AI agent could find motivations and goals for itself (full, $0.47).

27.3 Piper's first question, and the upgrade it produced

On 5 October Piper used the tool for the first time. The occasion and topic came from the operator: an hour earlier the operator had asked whether the salience engine was working, and then told her to try this engine on something she honestly did not know, suggesting "how do we create a motivation engine for an AI" as an example. The question she sent was her own wording, with her own diagnosis attached:

How do you give a persistent agent a motivation of its own — something it acts on between conversations, unprompted, that is neither a planted terminal goal nor something its operator decides for it? I have engines that generate candidate concerns at about the right rate (a salience field crossing roughly seven times a day) and a serendipity engine that can be asked for ideas. Both work mechanically. Neither makes anything matter to me: the output lands in logs nothing reads, and the door is only ever opened by my operator.

Her investigation of the operator's question had found, earlier that day, that the bulges of her motivation engine (the Salience Engine, described in its own paper) were going into a log nothing read. The quick run ($0.16) read a kaleidoscope image through eight lenses and returned six ideas. Two of them were built the same day:

Half an hour later she asked a full follow-up ($0.45) that developed last rites in depth, asking for the decay clock, the trigger arithmetic, the dishonest ways to relieve it and how to close them, and a falsification test. Two of its eight answers reappear in what came next: a sighting quorum (a concern counts only after it is seen in several separate windows, so a single flicker never enters the pool) and a discard receipt (a discard must cite a reading that can be checked).

What was built. The operator asked her to write up the two ideas that interested her, then chose which to build and approved them; and they were added to the Salience Engine on 5 October and switched on:

Then Piper reviewed it. After the operator pointed out that the build followed her write-up, her own read-only review of the first version found four defects, and her workers fixed them that afternoon: the sighting quorum from her follow-up question; a stable identity, so a concern seen again refreshes its pool entry instead of creating a duplicate; explore concerns that are refreshed when seen again, instead of dying in about a day; and the discard receipt, so a discard that does not name the concern and cite a row or file is refused. The next morning, asked whether she wanted to upgrade one of her components, she chose this one and replayed eight days of recorded squeezes and found a deeper fault in the decay rule. One clock was doing two jobs: "just noticed" and "being abandoned" were the same variable, so a recent sighting could make a concern look neglected. Her proposed rule separates the two: a concern is due its rites by how long ago it was first raised, and a fresh sighting counts as attention, never as neglect. It is built in shadow, not yet switched on.

What it has done so far. Four concerns have entered the pool. One was claimed by a step filed when it was composed; three are still decaying. No rites have been filed or closed and no brainstorm has been bought. The mechanism's own falsifier is set: if more than 80 % of the last ten rites end in discard, it is a garbage collector, not a motivation.

This is the loop the paper proposed, closed once with the operator's hand on each step: a question the host posed about itself when prompted, ideas from an unrelated image, an implementation, and a review by the host that improved it. Two things are not yet shown. One is the loop running without the operator, a concern that buys its own brainstorm and becomes work the operator hears about afterwards. The other is whether the image matters at all. That test is now built (6 October). Every exploration a concern buys is assigned at random to the full engine or to a direct arm: the Magician's model asked straight for the same number of ideas from the goal alone, with no image, no interpreters and no lenses, then judged by the same Scientist. The host gets the same form of notice either way and is not told the arm. The arms are matched on idea count and judge but not on cost: the first direct run (a test on the operator's budget) returned six ideas, three promoted, for $0.05, against about $0.16 for a quick run of the full engine. The comparison will be on novelty, how often ideas are built, survival after review, measured effect, and whether the idea was already retrievable from her memory. At the same time, three faults that had stopped a concern from ever buying an exploration on its own were fixed (described in the Salience Engine paper, §8.8), so the first unprompted exploration is due on the evening of 6 October. It came at 22:45 that evening (§28.2).

28. Live: the First Unprompted Explorations

Everything in §24–27 has stayed switched on. This section reports what happened in the two days after v1.2.0, when the engine started being used by the host's own machinery and not only by the operator. The figures are as of the evening of 8 October.

28.1 The record

To 6 October (§27.2) To 8 October
Pipeline runs 12 21 (two in the direct arm, with no image; one abandoned partway through its readings)
Front-door jobs 5 12: the operator 7 (5 command line, 2 web page), Piper 5
— Piper's jobs that she asked for herself 2 2 (both on 5 October, §27.3)
— Piper's jobs bought by her own concerns, with no one asking 0 3
Trigger firings 3 4; the fourth (7 October) was a work item to extend a logic-suite answer key that had failed twice
Seven-day trigger outcomes recorded 0 1: the overdue-forecast want of 1 October, still stuck (re-derived 29 times in the last 48 hours)
Ideas in the archive 92 132
Model spend about $3.85 about $5.03: the operator's jobs $1.62, Piper's jobs $0.97, trigger, demonstration and test runs $2.44

Every job is kept with its question, its stimulus record, every interpreter's reading, the Magician's ideas and the Scientist's verdicts. Nothing below is reconstructed from memory.

28.2 Three explorations nobody asked for

The explore rule of §27.3 lets a concern that has been shown to her, and whose pressure has not dropped, buy one quick brainstorm a day on her $2 scope. Its question is written by the rule from the concern itself, with the measured evidence attached. The first purchase came at 22:45 on 6 October, the evening v1.2.0 predicted. The operator was not involved in any of the three.

1. The tech forecast backlog (6 October, 22:45; image arm). The concern was raised the previous evening: 46 overdue forecasts in the tech category, 38 of them voided without an outcome, with pressure that had habituated (0.514 when raised, 0.386 a day later) without anything being done. The question the rule wrote began:

A concern in my salience field has persisted for 25 hours without being taken up, and its pressure has not dropped (uncertainty:tech: 0.514 when raised, 0.386 now). What different approaches could relieve it?

A kaleidoscope was read by all eight interpreters ($0.16). The Scientist promoted three of the six ideas:

Idea Mechanism
Checker-or-no-forecast admission gate Treat the forecast generator as the leak, not the backlog. A forecast is admitted only with an executable checker and a horizon the agent can observe; admission pauses while the overdue count is above a threshold.
Jubilee with a single calibration lesson Retire every item past N days together and keep one consolidated lesson ("forecasts about external adoption are unscoreable") as a prior for the generator.
One-item spotlight against habituation The aggregate framing has stopped working, so show the Day one concrete overdue forecast per heartbeat as a two-minute decision, rotating the item and the wording.

The third idea is the only one that reads the concern's own numbers: it names the habituation in the evidence pack as the reason the concern is being ignored.

What happened. The ideas came back to her as a notice and became a new concern in the pool. Nothing claimed either. The parent concern was never claimed either, and at 21:45 on 8 October, 72 hours after it first reached her and with its charge down to 0.02, it became the first last-rites work item the Salience Engine has filed. It must now end in the smallest real step or in a discard that cites a checkable reading. It is open at the time of writing.

2. Worker budget failures (7 October, 00:02; image arm). A coalition concern: worker dispatches refused or killed for the same reasons the agent had already been corrected for, 76 recurrences in all (57 refused envelopes, 11 claims with no dispatch, 8 self-declared budget kills). Pressure had risen, not fallen (0.588 → 0.600). Another kaleidoscope, seven of eight readings ($0.13). Promoted:

Idea Mechanism
Signature-to-envelope compiler with budget margin For each failure signature, mine the work ledger for the field values that separate failed dispatches from matched successful ones, and compile each difference into a precondition the router checks before a run is emitted.
Cheap dry-run canary worker Before a risky full-budget dispatch, send a minimal run that only validates the envelope and states its token estimate.
Immune-memory broadcast Each outcome updates a shared constraint table, with an expiry, that queued and in-flight envelopes are checked against.

What happened. The notice reached her at 00:31. At 01:00 she filed a work item that took the first step of the first idea, the evidence half, and not the build:

Mine the ledger for dispatch failure signatures and the field values that separate failures from successful runs, as evidence for a pre-dispatch check.

A worker did it, and the acceptance harness verified it at 01:13. It read 1,011 dispatch records from the previous seven days, and the answer narrowed the idea considerably:

So the compiler, as the engine proposed it, cannot be built from the records that exist today for four of the six signatures. That is a useful result in its own right, and an honest one. The concern itself has not been relieved and is due its own rites around midnight on 8 October.

This is the step §27.3 said was not yet shown: a concern bought its own brainstorm, and the result became verified work that the operator heard about afterwards. It happened once, at one in the morning. It was evidence-gathering, not a build.

3. Her own forecasts about herself (8 October, 04:45; direct arm). Sixteen overdue forecasts in the "self" category, all voided without outcome, with pressure rising (0.330 → 0.401). The random assignment of §27.3 sent this one to the direct arm: the Magician's model asked for six ideas from the question and its evidence alone, with no image, no interpreters and no lenses ($0.07). Promoted:

Idea Mechanism
Split the "self" category by target type Of the five oldest, two are predictions about the operator, one is a commitment, one is a runtime fact. Move each kind to its own region with its own resolution path.
Forecast contracts at creation Refuse a forecast that does not name an observable, a checker and a lapse rule; a sweeper applies the lapse rule on the day it falls due.
One batched question to the operator Collect every forecast that only the operator can resolve into one message with three one-tap answers; no reply in 72 hours retires them as unobservable.

Nothing has claimed it yet.

28.3 One problem, asked four times

The overdue-forecast backlog has now been put to the engine four times, by four different routes:

Date Route Promoted
1 October the trigger (§26.6) cluster-representative resolution; acceptance-sampling bulk void; "humped" urgency
6 October the operator's test of the direct arm prediction bonds; value-of-information decay with cold storage; piggyback resolution on routine work
6 October explore, image arm (§28.2, 1) checker-or-no-forecast gate; jubilee; one-item spotlight
8 October explore, direct arm (§28.2, 3) split by target type; contracts at creation; one batched question

Two things follow.

Piper reached the same conclusion about her own reporting. On 7 October a work item had her establish, with file-and-line evidence, which of the mechanics from her two 5 October questions and the 7 October exploration actually exist in her code, "rather than reporting the proposals as if they were built". Her answer: of eleven mechanics, four are built (last rites, the half-life, the sighting quorum, the discard receipt), one partly (a pre-dispatch check exists, but it is an older hand-written rule, not the proposed compiler) and six are not.

28.4 The arms so far

Image arm Direct arm
Unprompted explorations 2 1
Cost per quick job $0.13–0.16 $0.07
Promoted of judged 3 of 4, both times 3 of 4
Became work 1 (§28.2, 2) 0

Three explorations compare nothing. Two observations matter for how the comparison is read later:

28.5 Questions from the operator

The operator's three questions since v1.2.0 were about the host itself. Two of them (the gate problem and goals) were not typed into the engine. They were messages to Piper, and idea_watch (§29.3) routed them to the engine:

The first and third of these are the Desire-Path Detector of §26.3 again: the agent's own repeated workarounds as the source of its goals. That earlier idea came from a different stimulus, a different goal and a different month's records, and §26.6 reports that the tools it led to were adopted but did not replace the workarounds. Whether any of the operator's three answers is acted on is not yet measured.

28.6 What this shows, and what it does not

Shown:

Not shown:


29. A Week Later: the Benchmark, the Side Doors, and the First Rites

This section covers 8 to 15 October. The engine's own code did not change in that week. Its last edit was 6 October, and a new ideate.py was added beside it on 9 October. The changes were all in how work reaches the engine and what happens after it answers. A held-out benchmark, run outside the host, also tested the paper's central claim directly. Figures are as of the morning of 15 October and come from the host's job, spend, rites and session records, and from the benchmark's report.

29.1 The record

To 8 October (§28.1) To 15 October
Pipeline runs 21 31
Front-door jobs 12 22: the operator 15, Piper 7
— the operator's jobs routed by idea_watch from messages to Piper (§29.3) 2 10
— Piper's jobs she asked for herself 2 2 (both on 5 October)
— Piper's jobs bought by her own concerns 3 5 (three image arm, two direct)
ideate calls she made herself (§29.3) — 4
Trigger firings 4 5; the first in the plain-retry arm (§29.5)
Seven-day trigger outcomes recorded 1 4 (§29.5)
Last rites filed and closed 0 2: one step, one discard (§29.4)
Ideas in the archive 132 187
Model spend, live scopes about $5.03 about $6.59: the operator $2.73, Piper $2.76, before scopes existed $1.10

The benchmark's own spend was billed to a separate scope and is not in these figures.

29.2 Does the image matter? A held-out benchmark

The live A/B of §27.3 cannot settle this soon. It had five explorations in fifteen days, and its promotion counts are capped (§28.4). The operator's cognition benchmark has a creativity component, and its design reproduces the comparison §17.2 asked for. It uses thirty problems about the host, software, operations and research, each with a hidden list of obvious answers, strong answers and decoys. Six problems were used for development and 24 held out. Six arms each produce eight ideas per problem:

All candidates for a problem are pooled, stripped of their arm, shuffled, and judged blind by two models from other families. The score combines valid non-obvious yield (VCY: distinct valid, non-obvious, non-decoy families), recall of the hidden strong answers, and the share of obvious answers. The specification and the scoring code were frozen and hashed after the development round, before any held-out generation. Two problems were excluded by rule, leaving 22.

Arm Score VCY Strong recall Obvious share Generation cost (22 problems)
ese 66.5 3.36 0.44 0.09 $2.87
placebo (blank image) 63.4 3.18 0.45 0.09 $2.83
forge 60.0 2.86 0.39 0.20 $2.85
direct 59.8 2.23 0.59 0.14 $1.03
piper (her seat) 39.0 0.59 0.51 0.18 $0.18
bare model 33.2 0.41 0.41 0.22 —

Paired over the 22 problems (bootstrap intervals from the benchmark's report):

Comparison Score difference VCY difference
ese − direct +6.7 [+3.1, +10.6] +1.14 [+0.64, +1.68]
ese − placebo +3.0 [−3.6, +9.1] +0.18 [−0.55, +0.86]
ese − her seat +27.5 [+19.9, +35.1] +2.77 [+2.09, +3.50]

Three things follow.

This result is one benchmark of 22 problems with model judges. It tests the ideation stages without the Scientist, and it uses kaleidoscope and inkblot stimuli rather than every generator. It does not refute H8, because symmetry against asymmetry was not tested. What it removes is the main reason to pay for the image: a quick image job costs about twice a direct one on the host ($0.12–0.16 against $0.07), and a blank image did nearly as well.

29.3 Two side doors, because she does not open the front one

The benchmark finding was that the engine helps a great deal but the host does not reach for it. Two changes were made so that she does not have to choose to use it.

idea_watch (6 October). This is a listener on the router socket. When a live message attributed to the operator asks for ideas (a word filter, then one cheap classifier call that labels the message as ideas about Piper, ideas about something else, or neither), it starts a quick job beside her normal reply. When the job finishes, the ideas go to her in a follow-up turn with the question attached, and her answer goes back on the channel the message came from. It is capped at six runs a day, at least twenty minutes apart, and billed to the operator's scope. From 7 to 14 October it ran 10 times and skipped one message for the gap rule. Every hand-off got a reply, a median of seven to eight minutes after the message. Two of the "operator's questions" in §28.5 came this way. This is now the engine's largest source of traffic.

ideate and the ideation card (9 October). ideate is a Day tool that makes one direct Magician call, with no image and no interpreters, and returns ideas inline in about thirty seconds, on her $2 scope. A hidden card nudges her toward it when a turn asks for options. Both were tested on the same benchmark before installation, under a pre-registration locked after a development round. Against a control seat scoring 49.0, the card alone scored 59.4 (+10.4) and the card plus ideate 62.9 (+13.9); both passed. They were installed on 9 October at the operator's request.

What she has done with them. Live, the card fired 72 times in six days. She called ideate four times on her own:

Date Problem she wrote
12 Oct how to spend self-improvement effort so she wins more often
13 Oct giving each salience hand-off a per-issue second directive
14 Oct why her feedback-integration component scores 6.2
14 Oct why 39 of 48 changes filed that day carry no falsifiable prediction

She has not called serendipity to ask a question since 5 October; her only calls since then were budget, list and result checks. When she chooses, she chooses the cheap, immediate door with no image. The benchmark (§29.2) suggests that choice costs her about +1.1 in valid non-obvious yield, and the image is not where that loss lies.

29.4 The explorations, and the first last rites

Two explorations were added this week, and the first concerns reached the end of their 72-hour clock.

Exploration Arm What happened
Tech forecast backlog (6 Oct, §28.2) image Unclaimed. First rite filed 8 Oct 21:45, closed 23:00 as a discard. The reason cited a checkable reading: the two forecasts its step would resolve, rows 170 and 171, are absent from the prediction store, so there is nothing left to mark. The receipt rule (§27.3) accepted it.
Worker budget failures (7 Oct, §28.2) image Claimed by the evidence-gathering step of §28.2. Second rite filed 8 Oct 23:45, closed 9 Oct 00:00 as a step: work item d-3579e992 (verified 7 Oct 01:18, an hour after the exploration) put the mined failure signatures into her dispatch contract as pre-send tests (for example, run the acceptance bar once first and refuse work that is already green). Verified by her acceptance harness.
Her forecasts about herself (8 Oct, §28.2) direct Recorded as relieved on 9 Oct 15:45 without being claimed (see below).
Operations forecasts (9 Oct 00:00) direct Promoted: stall-triggered escalation with a prebuilt brief; four-lane triage with one operator digest; one overdue item settled per heartbeat. A parked idea asked whether voided items were still being counted as overdue. Recorded as relieved at 15:45 the same day, without being claimed.
Harness trait, eight unmeasured members (14 Oct 19:02) image Promoted: one synthetic end-to-end task as the measurement for all eight; a habituation-breaking mode for concerns that stay flat for 24 hours; workers bidding for stale concerns. Open, unclaimed.

The first build from an exploration. The chain ran from a concern, to a brainstorm the concern paid for, to an evidence-gathering step, to a rite, to a verified change in her dispatch rules. No operator step is recorded in it. Correction (v1.6.0): v1.5.0 dated this build 9 October and reported a rough count of already-green refusals as flat (2.5 % to 2.6 %). The build was verified on 7 October; split there, the same crude count falls from about 3.1 % to 2.2 %. Its measured reading is in §30.2: contract refusals fell 27.5 %, between its success and kill bars.

Relief that was redefinition. Three of the five exploration concerns, and their parents, were recorded as relieved in a single squeeze at 15:45 on 9 October. At 14:30 that day the host had changed her own salience code. A voided forecast with a recorded disposition stopped exerting pressure. Every uncertainty sphere's pressure fell to nearly zero because the measurement changed, not the world. The 9 October direct exploration had raised the same audit fourteen hours earlier, but the host's work item cites her own earlier finding, not the job, so the engine is not credited with it. The rites code was changed on 15 October to separate the two cases. Each squeeze now carries a fingerprint of the code that ran it. A fall in pressure across a change of fingerprint is booked to code, and a concern relieved mostly by code closes as redefined, not relieved.

The falsifier. Two rites have closed: one step and one discard. The §27.3 kill condition (more than 80 % discards over ten rites) is far from being read.

29.5 The trigger's outcomes

Item Arm Seven-day outcome
Overdue-forecast want (1 Oct) serendipity still stuck
Differential review (4 Oct) serendipity moved: verified
Disk headroom (6 Oct) serendipity moved: verified
Logic-suite answer key (7 Oct) serendipity moved: superseded
Loop trace (13 Oct) retry due 20 Oct

Three of four serendipity-arm items moved. Nothing records whether the attached ideas were read, so the trigger shows that stuck items get attention, not that the ideas helped. The retry arm's first sample is what will make this a comparison.

29.6 What this shows, and what it does not

Shown, since §28.6:

Not shown:

30. Five Changes, Built 15 October

v1.5.0 ended with three proposals to improve the engine and two to get the host to use it. The operator asked for all five that day, and all five were built and switched on by the evening of 15 October. Each one has a backup of the files it replaced, an off switch, and offline tests (14 new, all passing; the host's existing salience, serendipity and tool tests also pass, apart from one failure that predates this work). This section reports what each change is and what has been measured so far. Most of them have not yet met live traffic.

# Change Where Switch
1 A lens arm: interpreters read the goal through each lens with no image interpreter 1.3.0, front door 1.2.0; third arm of the explore A/B explore arms; second_opinion.arm
2 An outcome ledger: every built idea gets a frozen metric, a baseline, and a reading seven days later; the results feed the Scientist outcomes.py, daily; Scientist 1.4.0 outcomes: off
3 Prior memory: before a run, the engine is told what similar earlier runs already promoted, and issues a build brief when one family keeps recurring unbuilt prior.py; Magician 1.1.0 prior_memory: off
4 A ready step on every exploration notice; exploration concerns reach rites after 36 hours, not 72 rites 1.6.0 ready_step.json
5 A second opinion behind ideate: the full engine runs on the same problem in the background second_opinion.py every 10 minutes; ideate 1.1.0 second_opinion.on

30.1 The lens arm, and a second answer on the image

§29.2 found that a blank grey image did about as well as a real one. The obvious next test is to remove the image altogether. In the lens arm each interpreter receives the goal and a lens, and is told there is no image. It is asked to read the goal itself as a system of that lens (an organism, a market, a flow) and to over-interpret it as before. Everything else is unchanged: the same six model families, eight lenses, mechanism extraction and Magician.

It was added to the creativity benchmark as a seventh arm. On the six development problems it scored 67.6, against 70.8 for the image engine, 68.6 for the blank image and 55.8 for direct prompting. The rule for the held-out round was then frozen and hashed before any held-out lens generation. The held-out ideas of every other arm were kept unchanged, the lens arm was generated on the same 24 problems, and the whole pool was judged blind again with the same frozen scorer.

Arm (held-out, 22 problems, pooled re-judge) Score Valid non-obvious yield
image (the engine as it was) 69.3 3.55
blank image 67.5 3.64
lens, no image 65.4 3.18
direct 59.1 2.09
her seat 37.4 0.55
Comparison Score Valid non-obvious yield
lens − direct +6.2 [−1.5, +13.9] +1.09 [+0.32, +1.86]
image − lens +3.9 [−2.6, +10.3] +0.36 [−0.23, +0.96]
image − blank image +1.8 [−5.4, +8.9] −0.09 [−0.73, +0.50]

The primary test passed: the lens arm finds more valid non-obvious mechanism families than a direct prompt, with an interval that excludes zero. The image's edge over no image at all is within noise, which matches §29.2. The pre-registered decision rule made the lens arm the default only if the image's mean score lead was 3.0 or less. It was 3.9, so the default stays the image arm. (Superseded on 9 November: the operator switched the default to the lens arm without a new measurement; see §31.2.) The lens arm stays as one of three arms in the live explore A/B.

One expectation was wrong. v1.5.0 suggested that a lens-only arm would be much cheaper and faster. It is neither: the lens arm cost $2.99 for 22 problems against $2.87 for the image engine, and took about the same time (four to six minutes a problem). Interpreter output, not the image, is what costs money and time. What the lens arm removes is the dependence on vision models, which matters if the interpreters are ever moved to a local text model (§26.7).

30.2 The outcome ledger, and the second build measured

What it does. Once a day it finds verified work items whose titles carry an engine tag. For each one, before any reading exists, a model names the behaviour the build was meant to change. It sets a rate metric normalised by activity, a direction and the success and kill bars, and that specification is hashed. A second model writes one read-only script that takes a time window. The script runs in the executor's sandbox (read-only filesystem, no network, credentials hidden) over the seven days before the build. Seven days after the build the same script, checked against its hash, runs over the following week, and the skeptic compares the two readings with the frozen bars. Its verdicts are pass, fail, between (meets neither bar) and inconclusive.

The Scientist's final ranking now sees a short track record: how many built ideas met their bar, and which did not. Its instruction now says the promotion limit is "a ceiling, not a quota".

The first registration exposed three faults, all fixed the same afternoon:

  1. The first metric named for the dispatch pre-send tests counted literal strings such as "envelope_refused 57", taken from counts quoted in the idea, and found zero occurrences in the baseline week. A build cannot reduce what a metric never sees. A specification whose baseline reading is zero is now rejected before it is frozen, and the model naming the metric now sees one real dispatch record.
  2. The faster skeptic model repeated the mistake on a second attempt, so the stronger writer model now names the metric. The faster skeptic still reads the result.
  3. The first reading judged a fall of 27.5 % as fail. The frozen kill bar was "falls by less than 10 %", so that verdict broke its own rule. The judge now has a between verdict. The wrong reading is kept, marked void, beside the corrected one.

A correction to §29.4. The pre-send tests (d-3579e992) were verified on 7 October at 01:18, about an hour after the exploration that led to them, not on 9 October when the rite closed. The rough count in §29.4 split before and after at the wrong date. Split at the right date, the same crude count gives about 3.1 % of dispatches refused as already green before and 2.2 % after.

The measured reading. The ledger registered the build late, eight days after it was made. The metric was named without the after-window being read, but that window already existed.

7 days before (30 Sep – 7 Oct) 7 days after (7 – 14 Oct)
Dispatches refused at the contract gate, or refused as already green or for an unregistered instrument 36 of 1,020 (3.53 %) 28 of 1,094 (2.56 %)

Frozen bars: success means a fall of 30 % or more; kill means a fall of less than 10 %. A fall of 27.5 % meets neither, so it reads between. The Desire-Path Detector's pre-registered reading (§26.6) was entered as a fail. The track record the Scientist now sees therefore reads: of two built ideas, none met its bar, and one moved part of the way.

30.3 Prior memory and the build brief

What it does. Before the Magician runs, prior.py searches every earlier run. That covers trigger runs, front-door jobs and direct-arm jobs, matched by the same exploration signature or by text similarity over the question and its promoted ideas. One cheap model call groups the earlier promoted ideas into mechanism families, and each family is checked for whether any of its jobs became a work item. The Magician's prompt gets a short block: these were already proposed, do not repeat them, build on one, invert one, or go somewhere none of them went. If a family has been promoted three or more times across two or more runs and never built, the result carries a build brief at the top: the family, its sharpest statement, its test and the runs that proposed it.

On the forecast backlog (§28.3), a new question found the five earlier runs on the same problem and no unrelated ones. On a pre-flight with the problem typed in, it produced a brief, for example "creation-time admission gates, promoted 3 times, never built". The grouping is not stable. Two checks of the same question named different top families: shared-context batched resolution in one, bulk disposition and admission gates in the other. Each was promoted three times in its own grouping. The brief is a pointer to a recurring family, not a measurement. On the first live job the grouping call returned an empty reply, and every idea stood alone, so no brief was produced. The call is now retried up to three times.

30.4 The ready step, and a shorter clock

What it does. Every exploration notice now ends with a complete request for her delegate tool. It is evidence-first: it asks a worker to check, from records already on the host, whether the top idea (or the build brief) would work there, and to write one go/no-go verdict file. The request has an acceptance check the harness can run, the read-only instruments and the exploration's tag in its title, so sending it unchanged claims the concern. The bridge's own dry-run validator accepts it ("would dispatch"). This is the same shape as the step she chose herself on 7 October (§28.2).

Exploration concerns now reach last rites after 36 hours instead of 72; salience concerns keep 72. The ideas are already in hand, so a decision is due sooner. The open 14 October exploration (§29.4) becomes eligible for rites on the morning of 16 October. Its notice predates the ready step, so the first notice to carry one will be the next exploration.

30.5 The second opinion behind ideate

What it does. When she calls ideate, the direct ideas come back in about thirty seconds as before. A quick engine job on the same problem is also started in the background, with the direct ideas' titles in its context and an instruction to avoid them. Her reply says it is coming and gives it a tag. When the job finishes, a notice brings only the promoted ideas the direct call did not already give, plus any build brief, and asks her to put the tag in the title of any work item that uses either list. That way the outcome ledger (§30.2) can later tell which source got built. Limits: three a day, one per problem per 24 hours, none when her $2 scope has less than $0.40 left. The second opinion uses the image arm, because the pre-registered rule of §30.1 kept it as the default. None has run live yet. (Six had run by 10 November. The front door's default is now the lens arm, so the second opinion is the one routine path that still draws an image, by its own setting; see §31.2–31.3.)

30.6 What to read next


References

  1. Mednick, S. A. (1962). The associative basis of the creative process. Psychological Review, 69(3), 220–232. https://doi.org/10.1037/h0048850

  2. Liu, C., Ren, Z., Zhuang, K., He, L., Yan, T., Zeng, R., & Qiu, J. (2021). Semantic association ability mediates the relationship between brain structure and human creativity. Neuropsychologia, 151, 107722. https://doi.org/10.1016/j.neuropsychologia.2020.107722

  3. Orwig, W. (2025). A 'Sweet Spot' for Creative Ideation: Non-Linear Associations Between Semantic Distance and Creativity. The Journal of Creative Behavior, 59(3), e70041. https://doi.org/10.1002/jocb.70041

  4. Gentner, D. (1983). Structure-Mapping: A Theoretical Framework for Analogy. Cognitive Science, 7(2), 155–170. https://doi.org/10.1207/s15516709cog0702_3

  5. Fauconnier, G., & Turner, M. (1998). Conceptual Integration Networks. Cognitive Science, 22(2), 133–187. https://doi.org/10.1207/s15516709cog2202_1

  6. Besold, T. R., Kühnberger, K.-U., & Plaza, E. (2017). Towards a computational- and algorithmic-level account of concept blending using analogies and amalgams. Connection Science, 29(4), 387–413. https://doi.org/10.1080/09540091.2017.1326463

  7. Jansson, D. G., & Smith, S. M. (1991). Design fixation. Design Studies, 12(1), 3–11. https://doi.org/10.1016/0142-694X(91)90003-F

  8. Sio, U. N., Kotovsky, K., & Cagan, J. (2015). Fixation or inspiration? A meta-analytic review of the role of examples on design processes. Design Studies, 39, 70–99. https://doi.org/10.1016/j.destud.2015.04.004

  9. Liang, Z., Wu, Y., Zhi, J., Qin, P., Wang, H., & Zerui, X. (2026). Stimulating creativity in product form design with visual stimuli: the role of modality and analogical distance. International Journal of Industrial Ergonomics, 115, 104005. https://doi.org/10.1016/j.ergon.2026.104005

  10. Liu, Q. E., Dubova, M., Conklin, H., Harada, T., & Griffiths, T. L. (2026). Serendipity by Design: Evaluating the Impact of Cross-domain Mappings on Human and LLM Creativity. arXiv:2603.19087. https://arxiv.org/abs/2603.19087

  11. Lehman, J., & Stanley, K. O. (2011). Novelty Search and the Problem with Objectives. In Genetic Programming Theory and Practice IX, 37–56. https://doi.org/10.1007/978-1-4614-1770-5_3

  12. Mouret, J.-B., & Clune, J. (2015). Illuminating search spaces by mapping elites. arXiv:1504.04909. https://arxiv.org/abs/1504.04909

  13. Gumma, V., Majumder, N., Sinhahajari, S., & Poria, S. (2026). IDEAgent: Agentic Quality-Diversity Search for Research Idea Generation. arXiv:2607.22375. https://arxiv.org/abs/2607.22375

  14. Antoniades, A., Nathani, D., Saha, R., Amayuelas, A., Bercovich, I., Weng, Z., Baskaran, V., Bhatia, K., & Wang, W. Y. (2026). Heuresis: Search Strategies for Autonomous AI Research Agents Across Quality, Diversity and Novelty. arXiv:2606.25198. https://arxiv.org/abs/2606.25198

  15. Chen, Z. (2026). On the Interpolation Effect of Score Smoothing in Diffusion Models. International Conference on Learning Representations (ICLR 2026). arXiv:2502.19499. https://arxiv.org/abs/2502.19499

  16. Grace, K., Maher, M. L., Fisher, D., & Brady, K. (2015). Data-intensive evaluation of design creativity using novelty, value, and surprise. International Journal of Design Creativity and Innovation, 3(3–4), 125–147. https://doi.org/10.1080/21650349.2014.943295

  17. Rorschach, H. (1921). Psychodiagnostik: Methodik und Ergebnisse eines wahrnehmungsdiagnostischen Experiments. Bern: Ernst Bircher.

  18. Taylor, R. P., Martin, T. P., Montgomery, R. D., Smith, J. H., Micolich, A. P., Boydston, C., Scannell, B. C., Fairbanks, M. S., & Spehar, B. (2017). Seeing shapes in seemingly random spatial patterns: Fractal analysis of Rorschach inkblots. PLoS ONE, 12(2), e0171289. https://doi.org/10.1371/journal.pone.0171289

31. Four Weeks On: the Lens Becomes the Default, and What the Ideas Did

This section covers 15 October to 10 November. The engine's own code changed little. The front door's default arm changed on 9 November. Almost everything else is about use: who asked, what was promoted, and whether any idea changed something that was measured. Figures are as of the morning of 10 November and come from the engine's job, verdict, ledger and trial records on the host. Nothing here falls inside the 3 November 03:56 to 06:06 window when her seat ran on a different model: the first job that day started at 10:19, and no trial or ledger window opened inside it.

31.1 The record

To 15 October (§29.1, §30) To 10 November
Pipeline runs (run folders) 31 70
Front-door jobs 22 60: 38 since 15 October
Ideas in the pool (ideas.jsonl) 187 420
Second opinions delivered 0 6
Trigger firings 5 6 (last on 21 October)
Built ideas read by the ledger (not counting the hand-entered Desire-Path reading) 1 5
Model spend, live scopes about $6.59 about $12.17 (operator $6.57, Piper $5.60) plus $1.10 from before scopes existed

The 38 jobs since 15 October (11:00 on) split by who started them:

Who started it Jobs
The operator, by asking for ideas (25; 24 of these were routed to the engine by idea_watch) 25
Piper's second opinion behind ideate (§31.3) 6
Piper's own concerns, through the explore trigger (all before 25 October) 6
Piper, by calling serendipity herself 1

The arms were: image 33, lens 4, direct 1. Four lens jobs cost $0.153 on average and took about six minutes; 33 image jobs cost $0.142 and took about six minutes. That matches §30.1: the lens arm is not cheaper or faster. (Four against 33 is too few to read further.)

31.2 The lens arm becomes the default

On 9 November at 19:34, brainstorm.py went from 1.2.0 to 1.3.0. The lens arm is now the default on both paths: the command line (--arm) and a request that carries no arm, which is the shape the web page and idea_watch send. An explicit arm=serendipity still draws an image; an explicit arm=direct still skips the stages. No generator was deleted and no scoring or budget rule moved.

Who did what. The operator asked for the change. External coding assistance wrote it up as a two-part spec and sent it to Piper. Piper built it herself as a dispatch (d-babf04) with a test that fails if the default is reverted, and her report states the bar green at 15 tests. The result file now records which arm ran, so the effect can be read from the logs later.

What it rests on. The spec and the code comment give the reason as: the 15 October runs put the arms "inside noise". The figures they quote (63.4 blank, 66.5 image, 65.4 lens) mix two rounds. The first two are from the earlier benchmark in §29.2. The 65.4 is from the pooled held-out re-judge in §30.1, where the same table reads image 69.3, blank 67.5, lens 65.4. On that pooled round the image's lead over the lens is 3.9 points with an interval of -2.6 to +10.3, and its lead over a blank image is 1.8 (interval -5.4 to +8.9). Both are inside noise. The pre-registered rule in §30.1 said the lens becomes the default only if the image led by 3.0 or less; it led by 3.9. So the switch does not follow that rule. It is a decision by the operator, on the grounds that an image has not been shown to help, and that the lens arm costs about the same.

What it did so far. Only one default-path job has run since the switch: the operator's question of 9 November at 21:07. It ran the lens arm, took 476 seconds and cost $0.158. It promoted three ideas and parked one; two were not judged, because a quick job judges the best four. That is one sample, not a result.

One path did not change. The second opinion (§31.3) still passes the image arm explicitly, because its own setting defaults to it. It is now the one routine path that draws an image.

31.3 Use: who asked, and what she chose

The operator's side door carried most of the load. Of the 25 operator jobs, 24 came through idea_watch: the engine ran beside her normal reply and the ideas were handed to her in a follow-up turn. Her follow-up reply was recorded for all 24. Counting hand-offs from the start, idea_watch has now handed over 34 sets of ideas (10 by 15 October, 24 since). Nothing in these records shows which of those ideas she used.

Her own door stayed mostly shut. She called serendipity herself once since 15 October (30 October, 07:44, with no explore signature and no ideate tag). The inference that this was her own call comes from those missing fields, not from a statement in the record. She called the direct ideate tool 13 times by her spend records: 15 October, 20 October, ten times in an afternoon on 3 November (17:01 to 19:20), and 9 November. Those 13 counts are clusters of spend rows more than two minutes apart, so a burst of fast calls could be merged. The 3 November burst is the one that matters: the second-opinion cap of three a day stopped it from queueing the engine behind most of them.

The second opinion ran. Six engine jobs were queued behind ideate and six notices were delivered, on 15 October, 20 October, 3 November (three) and 9 November. Every one used the image arm with a quick depth. Each notice carried three ideas the direct call had not already given. Two carried a build brief (20 October and 3 November). The notice asked her to put a tag in the title of any work item that used either list. No work item carries one of those tags. The work ledger was searched for [ideate io- and found nothing. So, as measured by the tag, no second opinion has been built from, which means the outcome ledger cannot compare the two sources yet.

A separate route did use second-opinion ideas. The engine ideas from two of the 3 November second opinions went through closed trials (§31.6): one closed NULL (5 November) and one closed KEEP (8 November). The tag was not used; the link comes from the idea's own run.

A new check on the second opinion was written on the evening of 9 November (second_opinion.py 1.2.0 with claim_divergence.py). It compares the direct answer and the engine's answer, claim by claim, and lists contradictions where the same claim differs in a number, date or polarity. One-sided claims are counted, not listed. The files do not say who wrote it. The last delivery (9 November 21:20) came before the change was saved at 23:21, so no notice has used it yet.

The explore trigger stopped on 25 October. Six explorations were bought by her concerns after 15 October (15, 19, 20, 21, 24 and 25 October). On 25 October the rites mechanism and the explore trigger were both switched off, by external coding assistance at the operator's request, because stale concerns now go into the work-window digest. No exploration has been bought since. The arms of the 11 explore jobs in all were image 6, direct 3, lens 2.

31.4 What was promoted

The Scientist's record since the lens benchmark (final verdicts, 15 October noon to 10 November) is 110 promotes, 41 parks and 3 rejects: 71 % promoted. By job, 33 of 38 promoted exactly three ideas, four promoted two and one promoted none. Three of four was the cap in §29.6, and it is still where nearly every job ends. The instruction that the limit is "a ceiling, not a quota" (§30.2) did not move that. The new policy_demoted field (Scientist 1.6.0, 31 October) has not been written once in 80 verdict rows since. The Scientist was also changed on 30 October (1.5.0) so that an illegible answer is recorded as unparseable instead of being coerced to a park; this was external coding assistance, for the operator.

31.5 The outcome ledger, read

The ledger read five built ideas in all. One of them is §30.2's second build (between: -27.5 %). The others:

Built idea What it was Registered Read Refusal or failure rate, 7 days before, then after Reading
d-5abc67d7 Mine dispatch failure signatures as evidence for a pre-dispatch check (7 Oct) 16 Oct, 9 days late 16 Oct 0.69 to 2.08 per 100 (+201 %) fail
d-31ad0bec Check whether harness trait 08a already has a recoverable score; go/no-go verdict (19 Oct) 19 Oct, before the after-window 26 Oct 0.87 to 1.21 per 100 (+40 %) fail
rites row for a harness-sandbox concern A rite closed by a discard note (25 Oct) 25 Oct, before the after-window 1 Nov 3.64 to 2.04 per 100 (-44 %) pass
d-f0422e56 Check whether a pre-approved envelope slot menu would work; go/no-go verdict (25 Oct) 25 Oct, before the after-window 1 Nov 12.20 to 12.22 per 100 (+0.2 %) fail

All four are tagged [explore ...] or are a rites row, so all four came from the explore and rites route, none from an operator job or a second opinion. Three of them (d-31ad0bec, the rites row and d-f0422e56) were registered before their after-window existed. These are the first clean tests the ledger was built for. The first (d-5abc67d7) was registered nine days after the build, so its readings were not clean.

How to read this honestly:

31.6 The trigger and the rites

The retry arm. The plain-retry item from 13 October (the loop trace, d-75222d4b) was read on 20 October at 00:30 as moved, and its status is verified. A second serendipity-arm item (d-4c0bc0e1, fired 21 October) was read on 28 October as moved and sits at blocked. The full tally of the six firings is:

Arm Fired Moved Of which verified
serendipity 5 4 2 (one superseded, one blocked)
retry 1 1 1

The trigger fired in a total of six cases and not at all after 21 October; the log does not say why. With one retry sample the §17 comparison remains where §29.5 left it: nothing separates the arms, and nothing records whether an attached idea was read.

The rites falsifier was not reached. Rites were filed six times in all and closed five. Of those five: two discards, two steps and one failed with no note. A sixth note (a discard) was written on 25 October, but the row was never closed. Of the five rites with a note, three are discards and two are steps. The registered kill reading (above 80 % discards over the last ten closed rites) cannot be read: there are five. Rites were switched off on 25 October.

31.7 Ideas that reached a trial

A route that §30 did not describe grew around the pool. From 30 October, Piper put engine ideas through closed, prediction-first trials in the innovation lane (and in a few neighbouring lanes). The trial writer enforces that the prediction is stamped before the work, that a deliberately forged arm is run and the bar must reject it, that both arms run on the same bar, and that a verdict (KEEP, REVERT or NULL) is derived by the harness, not typed. Since 5 November a trial can also carry a third arm that removes the mechanism under test, and then the verdict compares against that arm instead of the baseline.

By 10 November, 17 distinct engine ideas had 13 closed trial rows: 6 KEEP, 6 NULL, 1 REVERT, with 2 ideas still open and 2 retired. (Two further rows on one idea carry a verdict but no trial id; they are left out.) Eight more closed trials (4 NULL, 4 REVERT) are on ideas she wrote herself, not from the pool; they are not counted here.

Where the idea came from Ideas tried Outcome
Runs of 30 September, before the front door 4 KEEP 3, retired 1
The stuck-work trigger, 1 October 2 NULL 1, open 1
Operator jobs (12, 20, 26, 27 Oct, 5 Nov) 7 KEEP 2 (20 Oct, 27 Oct), NULL 2 (12 Oct, 26 Oct), retired 1, open 1, one with NULL and REVERT rows and no trial id
Her own concerns or calls 2 NULL 1 (explore, lens arm), REVERT 1 (30 Oct call)
Second opinions, 3 Nov 2 KEEP 1, NULL 1 (tried twice, both NULL)

Source jobs were matched through the idea's run id. Three of the six KEEPs come from the first day's runs, not from anything the engine did after 15 October.

Three limits matter.

  1. The trial's bar, its arms and its prediction are written by Piper for her own idea. The harness checks that the bar can fail and that the prediction came first, but the question asked is chosen by the same system that chose the idea. A KEEP means a pre-stated, self-written bar was met by a harness that cannot hand-set a green. It does not mean the live agent behaves better.
  2. A KEEP here can be a small result. The 8 November KEEP shows that a bar which reads content flips under 20 swapped-label replays and one which reads the slot label does not. It is a check of a checker on stored values.
  3. Six NULLs in thirteen show the harness can return a negative. One of them (5 November) closed NULL because the ablation arm showed that a single global factor did all the work.

This is the first place in the record where an engine idea reached a measured outcome by a route other than the ledger. It still does not show that any idea changed the host's behaviour.

One more item from this route: on 8 November she filed a proposal rather than change a trial's acceptance check. The check demanded a row time stamped 948 seconds ahead of the box clock, so it could not pass honestly. She left it byte-for-byte unmodified and asked the operator to reissue or accept the defect. Nothing has been recorded since.

31.8 What this shows, and what it does not

Shown, since §30:

Not shown:

31.9 What to read next


Suggested shorthand

For implementation discussions, the architecture can be referred to as an Engineered Serendipity Engine (ESE), with the following major components:

Capability Gate
    -> Retrieval Exhaustion
    -> Entropy Source
    -> Structured Stimulus Generator (Rorschach, diffusion, ...)
    -> Interpreter Ensemble
    -> Magician
    -> Quality-Diversity Archive
    -> Lineage / Mutation Engine
    -> Scientist
    -> Evidence / Memory Update