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:
- retrieval produces little useful information;
- retrieved approaches are judged irrelevant or inadequate;
- known approaches repeatedly converge on the same family of solutions;
- the target may require a novel combination of known mechanisms; or
- 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:
- radial load distribution;
- nested redundancy;
- elastic tension instead of compression;
- flow through branching channels;
- failure isolation;
- modular growth;
- phase transitions;
- hierarchy;
- symmetry breaking;
- feedback.
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:
- whether the code graph already contains a relevant implementation;
- whether a registered tool can perform the operation;
- whether episodic memory contains a solved analogue;
- whether retrieval produces strong candidate mechanisms;
- diversity among retrieved mechanisms;
- confidence that retrieved approaches satisfy constraints;
- progress across repeated planning cycles.
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:
- pseudorandom seeds;
- hardware randomness;
- randomly selected images;
- procedurally generated geometry;
- diffusion-model latent noise;
- random graphs;
- cellular automata;
- random walks through Wikipedia or knowledge graphs;
- unrelated scientific abstracts;
- mathematical objects;
- pieces of code from unrelated domains;
- sounds or spectrograms;
- random physical simulations;
- random patent classes;
- random biological organisms or processes.
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:
- mirror order n. Low n (bilateral) produces organic, figurative readings. High n produces mechanical and radial ones.
- fractal dimension of the source field. Taylor et al. found that what people see in the Rorschach plates is driven by the fractal character of the blot edges, and that blots with lower edge fractal dimension evoke more reported images [18]. Rorschach can target an edge dimension, which gives a direct knob for how much interpreters will "see".
- primitive mix. Mostly curves reads biological. Mostly straight lines reads architectural or mechanical.
- color. Monochrome keeps attention on form. Color adds material and fluid readings.
- symmetry break. A small, seeded perturbation of one reflected copy. Perfect symmetry can read as decoration, and a slight flaw often makes the image read as a real object.
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:
- Mandelbrot. A random view of the Mandelbrot set boundary. The generator picks a boundary point, a zoom depth (log-uniform, from the whole set down to about 10-7 of its width), a rotation and a palette. It rejects views that are nearly all interior or all empty. This produces endlessly varied, self-similar structure with a precise mathematical origin: spirals, filaments and budding forms, from one formula.
- Inkblot. A real Rorschach plate, simulated the way the originals were made rather than drawn as symmetric shapes. Ink is laid on one half of the sheet, mostly near the fold, as pools, drips and spatter. The sheet is pressed: the ink spreads, and its wet edge wanders fractally. It dries with uneven washes and darker rims. Finally it is folded, with an imperfect press, so the transferred half is slightly fainter and shifted. The colour modes follow the ten original plates: black, black with red, and pastel. A
fd_targetparameter searches for an edge fractal dimension, the property Taylor et al. link to how much people see [18].
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:
- extract mechanisms from prose;
- normalize similar mechanisms into abstract forms;
- identify unusual relations;
- combine mechanisms from different interpreters;
- identify contradictions that suggest alternate designs;
- map source-domain relations onto target-domain entities;
- invert assumptions;
- ask what would become possible if an apparently impossible interpretation were made physically realizable;
- 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:
- apparent goal relevance;
- physical or logical plausibility;
- estimated implementation cost;
- expected performance;
- testability;
- reversibility;
- safety;
- amount of supporting prior art.
Possible diversity descriptors:
- mechanism family;
- source domain;
- degree of semantic distance;
- physical principle;
- architectural topology;
- centralized vs distributed;
- continuous vs discrete;
- static vs adaptive;
- deterministic vs stochastic;
- software vs hardware vs hybrid.
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:
- it permits analysis of which source domains and mutations actually produce useful ideas;
- it prevents rediscovery of repeatedly rejected branches;
- 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:
- exhaustive literature search;
- patent search;
- code search;
- dimensional analysis;
- symbolic algebra;
- theorem proving;
- constraint solving;
- finite-element analysis;
- simulation;
- ablation studies;
- benchmark execution;
- prototype construction;
- controlled experiment;
- external expert review.
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:
- internal engineering knowledge;
- wheel patents;
- topology-optimized rims;
- forged, cast, composite, and printed wheels;
- lattice structures;
- non-pneumatic wheel research;
- brake-cooling designs.
Suppose this produces many plausible designs but little conceptual novelty.
13.2 Serendipity phase
A random seed generates an image containing something like:
- a jellyfish-like membrane;
- radial architectural ribs;
- branching channels;
- repeated translucent compartments.
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:
- continuous tension surfaces rather than isolated spokes;
- radial cellular segmentation;
- graded stiffness;
- cooling channels integrated into load-bearing geometry;
- replaceable sacrificial sectors.
13.5 Scientist evaluation
The Scientist now searches specifically for:
- tension-spoke and membrane wheels;
- composite wheel membranes;
- segmented energy-absorbing rims;
- structural brake-cooling channels;
- compliant cellular wheel structures.
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:
- exogenous entropy not produced by the reasoning model;
- structured ambiguity that supplies relationships the target prompt did not specify;
- 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:
- novelty: semantic and structural distance from retrieved prior art;
- independent rediscovery rate: proportion later found to already exist;
- expert-rated usefulness;
- technical soundness;
- idea diversity;
- validated yield: number of mutually diverse ideas passing predefined quality thresholds;
- frontier expansion: whether any candidate exceeds the novelty/quality frontier of the baselines;
- test efficiency: useful candidates per unit compute;
- lineage depth: number of useful candidates requiring intermediate stepping stones;
- surprise: degree to which candidates were not predictable from the initial retrieval set.
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:
- parent stimuli;
- interpreter traces;
- model versions;
- random seeds;
- synthesis prompts;
- novelty searches;
- verification status;
- failed tests;
- surviving evidence.
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:
- hallucination;
- over-interpretation;
- pareidolia;
- analogy where none objectively exists;
- semantic drift;
- unlikely conceptual combination.
For factual answering, these are defects.
For divergent search, some of the same behaviors may be useful if they are:
- deliberately activated;
- confined to a sandboxed ideation phase;
- recorded as speculation rather than knowledge;
- 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:
- 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.
- 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.
- 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). - 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:
- bilateral: a single fold;
- kaleidoscope: two mirrors at 180°/n, giving n-fold dihedral symmetry;
- tiling: reflection into a triangle (60-60-60, 90-45-45 or 90-60-30) or a square, repeated until it fills the plane.
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.
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.
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:
- Sample the plane and keep points that escape late. These lie near the boundary.
- Choose a zoom depth, log-uniform from the whole set down to about 10-7 of its width.
- Choose a rotation and a palette.
- Zoom in stages. At each stage, render a small preview, score it for detail, and re-centre on the most detailed region.
- 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.
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:
- 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.
- 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.
- 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.
- 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.
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.
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.
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:
- The instrument registry lists the exact paths workers are allowed to name in a task. A task that names an unregistered instrument is refused at dispatch.
- The capability index is a searchable concept-to-code map that the Day queries when asking "do I already have something that does X?"
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
- The trigger fires rarely. Five times in its first fifteen days. The host seldom retries the same failing work item; it tends to close it and file a new one. The fifth firing (13 October) was the first in the plain-retry arm, so the §17 comparison has one sample a side once its outcome lands on 20 October (§29.5).
- Use is real but adoption is thin. Her scope has run seven jobs: two when the operator prompted her, five bought by her own concerns. She has not asked the engine anything herself since 5 October. When she wants ideas she uses the direct
ideatetool instead (§29.3). Most traffic now arrives throughidea_watch, from the operator's messages. - Quick-form promotion is saturated. Every quick job so far has ended with three promoted out of four judged, which is the cap, so promotion counts cannot distinguish one arm or requester from another (§28.4). That still held on 14 October.
- The image is not shown to matter. On the held-out benchmark a blank grey image did about as well as a real stimulus (§29.2).
- The Scientist runs only offline tests. Its executor settles what a read-only script can settle from existing data, or what a small simulation can settle against a baseline. Tests that need a model's judgement, a build or a live experiment get a proxy test, labelled as a proxy, or none. A simulation is only as good as the model that wrote it; its value is in killing ideas that fail even in their own model world.
- Judges are models. Novelty, plausibility and "more worthwhile" are model judgements, from a different family than the generator, but still models.
- The Mandelbrot generator uses 64-bit floating point, which limits zoom to a view width of about 10-13. The generator stays well above that.
- The edge-dimension measure is a proxy. It is a box count on an automatic figure/ground split. It follows the property Taylor et al. measured, but it has not been validated against human responses.
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) | high-volume interpreter | |
| Gemma 3 4B | 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:
- the goal;
- the lens;
- an interpretation policy: describe what is actually seen, then generate many competing interpretations. For each one, give the visual trigger, the analogy, the mapping onto the goal, an implementable mechanism, and second-order consequences. Do not converge early.
One interpreter typically writes 8,000–12,000 characters.
Magician.
- 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.
- 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:
- writes literature queries and code keywords;
- gathers evidence from two open literature indexes, the host's own code and documents, and a written sheet of the host's existing mechanisms;
- answers the questions of §12.
Two calibration rules keep it honest:
- a standard technique under a new name is capped at low world-novelty;
- most ideas must end as park or reject.
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:
- its intent loop proposes mostly backlog chores;
- its curiosity scorer has been silent for a month;
- its idea composer has stalled;
- its motivation drives run only in shadow.
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:
- Hand-written SQL against the work ledger, about 150 times a week. Goal: a single command to list, show and transition deliverables.
- Ad-hoc opening of the memory database in throwaway scripts. Goal: a small helper with a working connection and the common queries. (The labelling model summarised these scripts as failing 84 % of the time. The host's own count, made while building the fix, is about 8 % per call: 475 of 5,740. The figure was not checked against the counts before it was repeated, and is corrected here.)
- Code search wrapped in pipes, timeouts and retry boilerplate, about 250 times a week. Goal: a search tool that takes a scope, a limit and its own timeout.
- Hand-written queries against the document table, often three in a row. Goal: a document command.
- Core tests run through a hand-built environment pipeline that mostly fails. Goal: one test script.
Limits of this result:
- The intent-loop baseline is weak: it mostly proposes chores. Winning thirty of thirty against it shows the paving goals are better than what the host produces today, not that they are the best goals available.
- Build costs and weekly use counts are model estimates.
- The full test in the Scientist's verdict is to build at least three paving tools and measure a drop of 30 % or more in steps on the paved paths. That test changes the host and has not been run.
26.5 What the first runs taught about the machinery
- An unconstrained Scientist agrees. Its first version promoted nine of nine ideas. It also missed that the host's delegation tool already asks for "alternatives considered", and that its coding harness already uses three-way voting. Two changes were needed: giving it a written sheet of the host's existing mechanisms, and rules that cap standard techniques at low novelty. After both, it named the standard techniques and settled at three promoted, six parked.
- A comparative pass that fails silently is worse than none. When the batch-ranking answer could not be parsed, every first-pass "promote" stood: twelve of twelve. The pass now retries, falls back to a deterministic rule, and enforces the cap regardless.
- Evidence volume matters. With two or three papers in front of it, the Scientist promotes freely. An idea now cannot be promoted on fewer than five papers, and the free literature indexes are queried with back-off.
- Agreement across routes is a signal. Two different operators led to the same family (workarounds as the source of goals). Cross-lens families in generation 1 were likewise the ones the Magician built on.
- The demonstration goal must be a real problem, but not one under test elsewhere. A design problem unrelated to the host taught nothing about the host. A goal identical to a capability the operator was benchmarking at the same time made it hard to tell idea generation from troubleshooting.
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. |
- Assignment. A fixed hash of the item's id puts each stuck item in a serendipity arm (a pipeline run, with surviving ideas attached as evidence on the item and a full write-up in the document store) or a retry arm (a neutral "flagged stuck" note, so both arms get the same attention).
- Outcome. Seven days later the runner records whether the item moved.
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:
- A deterministic filter first rejects tests that need a model's judgement, a build, a deployment or a live experiment.
- For those, the skeptic may propose a model-free proxy test, which is always reported as a proxy.
- Success and kill criteria are frozen and hashed before any code exists.
- A model writes one analysis script.
- 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.
- 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:
- Nothing was broken. The tools its workers kept walking around were not missing. The work-ledger reader and the read-only self-state reader existed, but were not registered, so workers could not name them in a task. That is why there were 4,997 raw database calls against 552 uses of the ledger tool.
- What it shipped: six read commands on the ledger tool, registration of both tools, a code-search tool with its own result limit that works from any directory, and a fix for read-only access from confined workers.
- Verified live: a real confined worker named and ran both tools, checked by its acceptance harness.
- It corrected a figure carried into its brief (§26.4), and stated what it does not yet claim: that wrapped search calls have actually fallen.
The external measurement compares the week after the tools became nameable with the four-week baseline:
- Success: hand-typed occurrences per 100 worker sessions fall by 30 % or more on at least two of the three paths.
- Killed: the new commands are unused, or the patterns do not drop.
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
- the §17 stuck-item comparison, which has its first plain-retry sample (13 October; outcome due 20 October, §29.5; read as moved on 20 October, §31.6);
- execution for tests that need a model's judgement, a build or a live experiment;
- a local vision model; the interpreters are still reached through a paid model router, and the call that reaches them is the single point to swap.
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:
- the operator's command line, which can also run a job in the background and watch it;
- an editors-only web page, where an editor types a question and sees results with the stimulus image; each editor may have at most three jobs outstanding;
- Piper's own
serendipitytool in her conversational seat (§25.2). Her requests are billed to her $2-a-day scope and the results are filed in her document store as well as returned to her.
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:
- Last rites (idea 2; lenses biology, mechanical, neuroscience, urban). Every salience concern goes into a claimable pool with a half-life. A concern that decays below a floor without being claimed triggers a short session that must either take the smallest real step or write a justified discard. Dying concerns, not rising ones, wake the agent.
- The agent opens its own door (idea 5; lenses economics, mechanical, urban). A charged concern's cheapest available action is a question to this engine, paid for from its charge, and the charge is forfeited unless the ideas become at least one work item with a check.
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:
- Last rites. A delivered bulge becomes a concern with a twelve-hour half-life. If nothing claims it (a step filed when it was composed, or a work item tagged with it) and its charge falls below a quarter, one small work item is filed. That item passes on a note that names either the step taken or the reason for the discard.
- Explore. A concern that has already been shown to her within two weeks, and whose pressure has not dropped, may buy one quick brainstorm on her own $2 scope, at most one a day. The ideas come back to her as a notice and become a concern in the same pool. A discard ends the right to explore that concern for two weeks.
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:
- Two of six signatures separate cleanly. "Already green": 30 refusals where the acceptance bar already passed before any work was done. "Unregistered instrument": 17 tasks that named a path missing from the instrument registry (§25.1). Each carries a recorded verdict that successful runs never do, so a precondition is possible.
- "Cannot pass" is three faults under one name: a bar that times out (12), a path missing on the host (6), a command that does not exist (6). A check keyed on the name alone cannot choose a remedy.
- Worker timeouts (9) all fell between 21:00 and 04:00, against about 17 % of successful runs in that window, but no recorded field states the cause.
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.
- The ideas converge across routes. Resolving a cluster by one representative appears in the first run and again, unjudged, in the direct test. A bulk void, the jubilee and an aggregate "amnesty" are one family. The admission gate and the contracts at creation are one family, found once with an image and once without. Agreement across independent routes was a signal in §26.5; here it says the solution space for this problem is small and has been mapped.
- None of the twelve promoted ideas has been built. The first seven-day trigger outcome is "still stuck". On this problem, ideas are not the bottleneck; acting on them is. Until the last-rites item of §28.2 is closed, nothing on the host is obliged to act on the engine's output.
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:
- Promotion counts cannot separate the arms. Every quick job the engine has run, nine of them across all requesters and both arms, has ended with exactly three promoted out of four judged, which is the cap. The comparison has to rest on what the pre-registration already names: whether ideas are built, whether they survive review, their measured effect, and whether they were already retrievable from her memory.
- The direct arm stays closer to the evidence. Its ideas cite forecast ids from the evidence pack by number; the image arm's ideas are more often mechanisms that could apply to any agent. That is the expected difference, one sample, and not a result.
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:
- "any ideas for making the overnight digest less noisy without missing real problems?" (inkblot, $0.12). Promoted: an alert allowance per source, spent only on deviation from that source's own baseline; two detectors with different views, with disagreements held in a quarantine tray; and a digest made of proposed commands instead of observations.
- "whats your plan to solve the gate problem" (inkblot, $0.15). Promoted: a done-gate whose verification effort scales with the recent error rate; an attention currency that drives, jobs and people spend to wake the Day; and known-answer canary tasks slipped into the worker stream to calibrate the gate.
-
On 8 October, at more length:
lets talk goals. right now, it seems that you spend a lot of time doing logging and housekeeping tasks. thats fine, but I wanted to skew you more in the direction of enhancing your own codebase. how can we do this? … how do we add aa sphere or spheres, or increase the pressure they exude on your salience engine to push more towards core codebase enhancements? or does this come out of a perceived pain (like I fail at x too often), which leads a pressure on its own to fix Y?
A kaleidoscope, eight of eight readings ($0.13). Promoted: a friction ledger as a salience sphere (workers record retries, rework, corrections and workarounds per code module, and the hottest module exerts the pressure); an architect twin that reads only the scars, a read-only clone that sees incident records and friction and drafts refactors; and a capability-gap wishlist whose weight is the pressure, cleared only by shipped changes. Its answer to the operator's either/or was "pain is the fuel and the sphere is the channel".
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:
- The engine runs unattended on the host's own concerns: at night, within its budget, with every step recorded.
- One result became verified work with no operator involved (§28.2, 2).
- The rule that a concern must end in a step or a justified discard has filed its first item (§28.2, 1).
Not shown:
- Whether the image matters. The A/B has three samples, and promotion counts cannot settle it (§28.4). Update, 15 October: a held-out benchmark now answers this better than the live A/B can. A blank image does about as well (§29.2).
- Whether the ideas improve outcomes. On the one problem asked four times, nothing has been built and the backlog is still stuck (§28.3).
- Whether the first rites end in a step or a discard, and whether discards will dominate: the falsifier of §27.3 is still more than 80 % discards over ten rites. Update, 15 October: the first two rites closed one each way (§29.4).
- That paving a desire path removes it. The one idea that went from the engine to a built change failed its pre-registered seven-day reading: the new tools are used, and the hand-typed paths barely fell (§26.6).
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:
- direct: the Magician's model asked straight from the goal;
- ese: the live engine (stimulus, lenses, six vision families, mechanism extraction, Magician), with state isolated from the host;
- placebo: the same pipeline fed a blank mid-grey image, the test §21's H8 implies;
- forge: a structured text-only generator that seeds operators on standard answers;
- piper: her conversational seat, given the problem in the operator's wording;
- bare: her base model with no seat.
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.
- The pipeline works; the picture is not shown to. The engine beats a direct prompt on non-obvious yield with an interval that excludes zero. But a blank grey image run through the same lenses and interpreters gets most of that gain, and the real image's remaining edge is within noise. The development round showed the same order (ese 70.6, placebo 68.6, direct 59.8). §14 argued that the image is what makes the engine more than a prompt. On this evidence the lenses and the forced over-interpretation through several model families are doing that work. The interpreters will "see" mechanisms in a grey square when told to read it through a goal and a lens.
- The engine trades accuracy for distance. Direct prompting recalled more of the hidden strong answers (0.59 against 0.44). The engine's ideas are less obvious and more numerous, but it finds the known-good answer less often. §18.6 named this risk.
- Her seat is far behind both. Asked for her eight best options, her seat scored 39.0, with under one valid non-obvious family per problem. On the held-out problems it called
serendipity0 times in 24. The engine is asynchronous and takes about ten minutes, so it cannot serve a reply she is writing now. That finding produced the two doors of §29.3.
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:
- The pipeline beats a direct prompt on non-obvious yield, on held-out problems with blind judges (§29.2).
- A blank image does about as well as a real one. The gain is in the lenses, the interpreter ensemble and the Magician (§29.2).
- The rites rule works as written. Both closed rites produced a checkable answer, and one was a verified build that no one asked for (§29.4).
- Relief caused by a code change can now be told apart from relief in the world (§29.4).
Not shown:
- That any built idea changes the behaviour it targets. One build failed its test (§26.6); the other moved part of the way, short of its bar (§30.2).
- That the host will open the engine herself. She chose the direct tool four times and the engine none (§29.3).
- That the trigger beats plain retry. There is one retry sample, with its outcome due 20 October (§29.5). (It was read as moved on 20 October; see §31.6.)
- That the Scientist's promotions mean anything. Every quick job still ends at the cap of three of four.
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:
- 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.
- 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.
- 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
- The outcome ledger, daily. The next built idea with an engine tag is registered automatically. The first one registered before its after-window exists will be the ledger's first clean test.
- Ready steps. Of the next explorations, how many are claimed by sending the step unchanged, and how many still reach rites.
- Second opinions. How often she acts on the second notice, and whether the tagged work items come from the direct list or the engine's.
- The explore A/B, now three arms (image, direct, lens), on whether ideas are built and survive the ledger rather than on promotion counts. (Stopped at 11 jobs when the explore trigger was switched off on 25 October; see §31.3.)
- Promotion saturation. On the first live job after the track record was added, the Scientist still promoted three of four. One job is not a reading.
- Still due from §29: the first plain-retry outcome (20 October) and the rites falsifier (ten closed rites). (The retry outcome landed; the falsifier was not reached before rites were switched off. See §31.6.)
References
-
Mednick, S. A. (1962). The associative basis of the creative process. Psychological Review, 69(3), 220–232. https://doi.org/10.1037/h0048850
-
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
-
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
-
Gentner, D. (1983). Structure-Mapping: A Theoretical Framework for Analogy. Cognitive Science, 7(2), 155–170. https://doi.org/10.1207/s15516709cog0702_3
-
Fauconnier, G., & Turner, M. (1998). Conceptual Integration Networks. Cognitive Science, 22(2), 133–187. https://doi.org/10.1207/s15516709cog2202_1
-
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
-
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
-
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
-
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
-
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
-
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
-
Mouret, J.-B., & Clune, J. (2015). Illuminating search spaces by mapping elites. arXiv:1504.04909. https://arxiv.org/abs/1504.04909
-
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
-
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
-
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
-
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
-
Rorschach, H. (1921). Psychodiagnostik: Methodik und Ergebnisse eines wahrnehmungsdiagnostischen Experiments. Bern: Ernst Bircher.
-
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:
- One pass and three fails is not a verdict on the engine. Every one of the four builds is a note, not a change to the dispatch path. d-31ad0bec and d-f0422e56 are go/no-go verdicts written from existing records. The pass is a discard note saying that a baseline "already exists". None of them could plausibly alter how many dispatches get refused, which is the thing measured. The ready step added in §30.4 asks for exactly this kind of evidence-first note. The ledger then judges it on behaviour, which it was never going to move. The pass should not be counted as an idea that worked.
- Window noise. In the pass and in d-f0422e56 the script used a file's modification time as the finish time for most records (1,766 of 2,112 and 1,766 of 2,111). The windows are therefore only approximate.
- No ledger reading has been added after 1 November. The ledger's own log shows daily runs through 9 November with nothing new registered or read.
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.
- 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.
- 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.
- 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:
- The side doors carry the use. Twenty-four of 38 jobs were routed by
idea_watchfrom the operator's messages. Her own door was used once. - The second opinion works as plumbing: six delivered, none broken, three ideas in each.
- The outcome ledger works as designed on registration (three clean registrations), and it also exposed that evidence-only builds cannot be measured by behaviour metrics.
- Engine ideas are being turned into trials with real controls, and the harness does not turn every trial green (6 KEEP, 6 NULL, 1 REVERT).
Not shown:
- That the lens default is better or worse than the image. The measurements did not change; one lens run has been made under the new default.
- That any built idea changed the behaviour it targeted. Of five ledger readings: three fails, one between, one pass, and the pass is a discard note.
- That the second opinion's ideas get built. Zero tagged work items.
- That the trigger beats plain retry. One retry sample, one clean outcome, nothing to compare.
- That rites make a good motivator. The falsifier was left at five of ten when rites were switched off.
- That promotion means anything. 33 of 38 jobs still end at three promoted.
31.9 What to read next
- The lens default's own readout against the image: jobs by arm, with the ledger and the trial route as the outcome, not the promotion count.
- The first ledger reading on a build that changes the dispatch path itself, rather than a note about it.
- Whether the first notice that carries a divergence list (
claim_divergence) is acted on, and whether any second opinion gets a tag. - Whether the trigger fires again, and if it does not, why.
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














































