No architecture has been selected, no benchmark built and no compute budget set. Most of what's below is conceptual work: reading, arguing and refining questions. The exceptions are two small notebook experiments from February 2026, written up on the Experiments page with their setup, results (including a failure) and limits.
-
October 2026
From better answers to better discoverers
The latest discussion connects frontier LLM post-training with our older work on evolutionary exploration. Human knowledge can provide a starting distribution for discovery; external feedback can select useful proposals. The unresolved question is when that loop expands transferable capability, and when it mainly makes existing solutions easier to sample.
We are separating reasoning RL, learning from multi-turn tool interactions, frozen-model inference search and changes to the surrounding harness. Multi-agent coordination and shared memory might preserve and distribute discoveries; quality-diversity search and curricula might sustain alternatives. Each also introduces costs and new ways to optimize the wrong signal.
Reports of mathematical progress deserve artifact-level scrutiny: the exact problem, its prior status, proof checking, independent assessment and human contributions. We have not established a count of AI-solved open problems or evidence about mathematicians' reactions. Likewise, improving a kernel or an agent workflow is relevant evidence for bounded optimization, while sustained recursive improvement remains an open hypothesis.
The practical outcome is a connected research agenda and four proposed pilots with matched budgets, independent verification, retention and transfer checks, and explicit failure conditions. None is a completed Rubedo experiment or a commitment to a combined architecture.
Frontier learning agenda → · Proposed pilots → · Evidence and limits →
-
October 2026
Taking stock
We stepped back to summarize everything so far, and found that the threads run in a line. A distributed neural network led to decentralized agents, then an evolutionary population, then learning to learn, then a multi-agent ecology, then economic and social organization, then open-ended search, then adaptive optimization, and finally civilization-scale optimization. Each step answered a problem the previous one exposed.
Two things came out of it. First, ten recurring tensions (exploration vs. exploitation, diversity vs. convergence, engineering vs. emergence, power vs. alignment and the rest) look less like separate problems and more like faces of one problem. Second, there's a single question underneath them all: what minimal set of mechanisms is sufficient for a system to begin discovering the rest for itself?
-
October 2026
Reconnecting with the multi-agent roots
A question we'd been avoiding: does the "civilization as optimizer" idea make Rubedo's older multi-agent work obsolete? We had spent a lot of effort imagining artificial environments rich enough for meaningful pressures to emerge, then trying to connect them back to game theory and the real world.
Where we landed: the old work was aimed at the right phenomenon one abstraction layer too far from reality. Civilization already contains every pressure we were trying to design: scarcity, trade, capital, institutions and technological change. But a synthetic world still has a job to do, as a wind tunnel. Reality is n = 1 and can't be rerun. The refinement is to derive the mechanics of synthetic worlds from real economic and evolutionary phenomena, rather than invent them.
This also answered a worry about the "one giant machine" picture. A superoptimizer needn't be one system. It could be a distributed optimizer of partially aligned agents, cooperating because coordination pays rather than because they share a goal.
-
October 2026
What if society is already the optimizer?
We stepped back to the big question. The paperclip thought experiment assumes the goal is known. But people are already using AI to optimize capital returns, production and logistics. Perhaps we've been approaching the superoptimizer as if it weren't already happening.
The shift: what happens when a civilization becomes an optimization process before it has agreed on what it's optimizing? Instrumental convergence might happen at the scale of civilization, so that actors who disagree about everything still agree in practice on more energy, compute, prediction and productivity. And the objective might be partly set by selection, not chosen.
We also let ourselves speculate about reality itself as an optimization process: death as pruning, superposition as branching exploration. We've written that up as clearly labelled speculation, alongside a more defensible version, which is that intelligence gradually makes more of the world behave like a controllable search space.
Civilization as an optimizer → · Generate, evaluate, select, amplify →
-
October 2026
Mapping the industrial stack
A deliberately basic exercise: go through the whole industrial process, from extraction to refining, materials, components and capital systems, along with how concrete and electricity are made and moved. The aim was to see what any physical objective eventually depends on.
It wasn't a detour. It became our model of the physical substrate under power. Capital-producing industries make the equipment that raises the productivity of every layer below them. We sketched a seven-level ladder of optimization (task, process, factory, supply chain, capital, research, optimizer), and saw how a narrow goal like "cheap electricity" climbs it on its own. We also noted that capital is an institutionalized claim on physical power, not power itself. And it suggested that recursive intelligence improvement may run through the physical economy (chips, fabs, energy) more than through code rewriting itself.
A thought that stuck: a generalized optimizer would probably start where information most easily turns into resources (capital markets, say), but eventually it would have to understand the world as a whole, not any one sector in isolation.
-
October 2026
Engineering a system that learns how to search
If pure search is too slow and full engineering prescribes the answers, what's in between? Our current best answer is to engineer the capacity to adapt, and leave the discoveries, and increasingly the search methods themselves, open to change. We'd study adaptive processes that get better at generating, testing and preserving consequential changes, including changes to their own learning.
We also tackled the hyperparameter question. How could exploration and variation settings change without a pre-programmed schedule? We separated changing the amount of randomness from changing the structure of variation, listed the controls that trade off against each other, and looked at real evidence that learning machinery can be partly learned (DiscoRL, learned evolution strategies, Population-Based Training, self-referential meta-learning). The honest boundary: some machinery always decides what can change and what counts as success.
Proposed first result, should we ever run one: under a limited budget, can a system improve its own way of generating and evaluating alternatives, retain competence, and become a better learner in unfamiliar conditions?
-
September–October 2026
The compute correction
We had floated the idea that some undiscovered principle might lock evolution, development, learning and culture together into runaway intelligence. The correction: life has had billions of years and planetary parallelism, at a computational scale we can't approach. That may be exactly why we build simpler, designed systems for narrower problems.
This reframed the project. The point isn't to recapitulate evolution. It's to find which general principles make artificial search tractable, and to look for the smallest useful set of general inductive biases. We were careful to add that nature's expenditure is not a proven lower bound.
-
September–October 2026
Stepping back from game-specific architecture
The Minecraft discussion had produced a tidy pipeline: world model, then novelty and value, then goal discovery, then skills, then an archive, then a planner. It looked sensible, and it was exactly the kind of premature component diagram we wanted to avoid.
So we redirected to theory: papers on open-ended learning, evolution, development, neuroscience and world models, with an eye on what's missing from the literature. We were looking for a generalized view based on how evolution reaches more capable states without milestones or predetermined computational layers, rather than four or five boxes in a fixed arrangement. That produced most of the open questions and the core of the reading map.
-
September–October 2026
The milestone objection
DreamerV3 learning to find diamonds from pixels was initially encouraging. Then we looked closely. It was rewarded for twelve intermediate milestones, from logs and planks to an iron pickaxe. That makes it a prescribed path: once the agent learns to collect wood, it can go piece by piece. What we want is something general enough to work out the milestones for itself.
That objection produced the distinction we now use everywhere: human milestones versus learned instrumental value versus self-generated developmental goals.
Along the way we also decided that abstracting motor busywork is fine (target a block and "break" it, rather than emit thousands of clicks). The thing we won't abstract away is knowing which actions are useful. We also dug into why world models don't automatically solve long horizons: discounting, value that propagates only from experienced trajectories, and model error that compounds.
-
September–October 2026
How does anyone connect the dots?
Even people find Minecraft hard to master without wikis, tutorials or experienced friends, and we bring a lifetime of priors. We know what a pickaxe is for, that iron beats stone, that diamonds are deep, and that caves are easier than digging straight down. A baby, or a blank network, has none of that.
This made the abstraction question vivid. A learner that finds solutions we haven't already found has to explore, connect dots and transfer what it knows, without our semantic shortcuts.
-
September–October 2026
Three ways it could fail
Before getting excited, we listed the failure modes. First, a local optimum: discover that an iron pickaxe at the right depth finds diamonds, and stay there forever. Second, worse, a zero-reward basin: no simulation ever gets far enough to find a diamond, so nothing grows. Third, too much noise: if mutations between genotype and phenotype distort too much, any progress toward a long-term goal is scrambled before it develops.
We also noted that even naive diamond mining with no milestones would be informative, because it would show how much harder, longer-term goals might be approached.
-
September–October 2026
From the Ender Dragon to diamonds, and to paperclips
The goal moved from beating the Ender Dragon on Hardcore, a finite quest, to maximizing diamonds, an open-ended investment problem. Then came the realization that tied it to everything else. This is the paperclip problem in miniature.
A general optimizer told to make paperclips with one laptop might not make paperclips at all. It might predict markets, buy compute, learn industry, and build up its capacity, because producing now reduces what it could produce later. The same path might follow from almost any goal. In Minecraft, that means not mining diamonds straight away after finding iron, but learning enchanting, beacons, advanced mining techniques and machines that build the machines that mine diamonds.
-
September 30, 2026
Starting point: what would it take to beat Minecraft?
The discussion began with a simple question. If you wanted an AI that could play Minecraft and defeat the Ender Dragon, what models would you use? Would it look more like evolution than standard reinforcement learning?
We ruled out language-model control early. We wanted sensory input to drive actions move by move, without pathfinding tools like Baritone, scripted strategies or symbolic task decomposition. That exclusion was specific to this benchmark, but it set the tone. We were interested in what a learner could discover, not what it could be told.
-
September 2026
The multi-agent agenda, restated
Before the Minecraft discussion, the agenda focused on populations: competition and cooperation, communication, memory, trust and deception, specialization, coalitions, conventions, persistent roles and population-dependent strategies. That agenda never went away. It came back, transformed, in the civilization discussions above.
-
February 2026
Setting reproduction aside: what does a single agent need?
The cost of a generation finally forced the issue. If each agent needs a day or two of real exposure before its fitness means anything, and a participant can afford to run only 10 to 20 at once, evolving full neural networks is hopeless. The same compute would do more good training one model for longer. Evolution is competitive mainly when the search space is discontinuous, evaluation is cheap, and what's evolving changes slowly, such as priors and learning rules, not billions of weights. So we reframed it as a slow meta-search over learning biases, with shared data and gradient learning doing most of the work.
That pointed to a static, non-reproducing population for the next step. Each agent would need two things solved: memory and recurrent cognition (a recurrent core plus external key–value memory looked like the right starting point), and a very large, structured action space. Our idea of an output layer that "calls a function" and hands off to a specialized secondary model turned out to fit a family of established methods: factorized actions, parameterized actions, pointer-based candidate selection, hierarchical options, mixtures of experts and programmatic actions. The rule we took away is that any stochastic choice made by a sub-model has to count toward the probability of the action actually taken. Communication would be costly embedding vectors that agents are free to ignore, and internal "thinking" steps would be priced so agents can't deliberate for free.
That became the toy-market proposal: 5 to 20 agents, hidden regimes, public and private information, trading and costly messaging. It hasn't been built yet.
-
February 2026
An experiment that went extinct
We tested a small piece of the emergent-heredity idea. Digital organisms were byte strings, reproduction was noisy and cost energy in proportion to length, and children had to pass a validity check. In one world children got only what they inherited. In the other, parents could patch them after birth. We expected the first world to evolve compact, robust "genomes." It went extinct in 68 steps. The patching world thrived on bloated programs.
The diagnosis was the Eigen error threshold. One bit flip was almost always lethal, so selection never got the chance to act. That turned replication fidelity into a concrete research topic, and it was a good reminder to publish predictions that turn out wrong.
-
February 2026
Must heredity be protected, or can protection emerge?
The most productive argument of the month. The proposal was a world where every action, whether thinking, communicating, remembering or reproducing, costs energy, and where a parent's own policy builds its child. There would be no fixed genome and no imposed mating rules. We expected near-copies first, then compression as smaller encodings proved cheaper, and perhaps eventually sharing between partners.
The objection was that evolution needs locality, meaning small heritable changes cause small effects. Biology protects that with a firewall: DNA is read, not executed. The counter-objection won a real concession. Biology has no external genome oracle. Its copying and repair machinery is itself encoded in the genome, and early life was much closer to self-modifying chemistry. Where we landed is that biology emerged from something like a self-modifying system, but cumulative evolution only took off once heredity became protected. So the real question is how to build a self-modifying world where protected heredity is likely to emerge, given fragile early protection, side channels that route around it, and the need for pressure to act through some bottleneck.
-
February 2026
Evolving a weight generator, and the collapse it revealed
We started with a practical worry: is a huge output layer harder to train? That led to a CPPN experiment. Evolve a small generator network that writes the weights of an MNIST classifier, train each result for 20 steps, and select on how quickly it learns. The results weren't good. Working out why taught us what CPPNs are actually for. They're pattern generators with a bias toward smooth, spatially regular structure, which suits the pixel layer but not abstract hidden layers.
A follow-up question turned out to matter more. Why not train the generator's weights θ and also evolve the genome z that steers it? Because if the per-individual part is cheap to optimize within a lifetime, all the selection pressure flows into it, and evolution stops seeing the genome. That collapse is self-reinforcing and very hard to undo. Evolution didn't discover calculus. It discovered brains that can learn calculus.
-
February 2026
The genome as a generative program
We mapped out what we understood about building evolving learners, and how well. The genome should be a developmental program, not raw weights. Weight-level crossover is broken, so recombination has to work at the level of modules or rules. The Baldwin effect is real and measurable. Hypernetworks blow up unless they're tightly constrained. And species-like structure, mate choice and protective parenting should emerge from costs rather than be imposed. The harder ambition was a genome that doesn't just tune learning rates but encodes increasingly good initial structure, while still allowing two parents' genomes to combine without broken offspring.
We went back to how NEAT, HyperNEAT and real genetics actually work: innovation numbers, speciation, what dominance really means, why crossover usually doesn't produce garbage. Our list of real gaps: a genotype that recombines safely at scale, an interpreter strong enough to make offspring viable but not so strong that evolution becomes irrelevant, mutations that are mostly non-lethal, an evaluation regime we can afford, and recurrence without pathological thinking loops.
-
Earlier
Developmental evolution
Rubedo's earliest framing of agents centred on genome → interpreter → phenotype: structured developmental programs, recombination, speciation, mutation robustness, lifetime plasticity and gestation learning. The hope was that local learning + evolutionary selection + economic pressure + social organization would add up to population-level intelligence.
Earlier versions of this site listed related "programs" and "experiments": replication-fidelity thresholds, gestation learning before environmental exposure, modular hierarchical control for large action spaces, and keeping evaluators from collapsing into self-reinforcing equilibria. These were directions of interest, not running experiments. They've since become the Heredity, Evolvability, Agents and Incentives questions.
-
The beginning
Don't decentralize one mind
Rubedo started as decentralized AI infrastructure: spread a conventional neural network across independently operated machines, use token-like incentives for participation, and eventually verify untrusted nodes' work with zero-knowledge proofs. It kept running into latency, synchronization, stragglers, adversarial machines, proof overhead and the tight coupling that gradient training needs. Worse, it was becoming a cryptography project instead of an intelligence project.
The pivot was to locally sovereign agents, each running a complete learner and interacting only when useful. Rather than decentralizing one mind, we'd ask whether intelligence can emerge from a decentralized ecology of minds. Everything since has grown from that.
Possible next steps
None of these is adopted. They're the shape of what we'd do next if we choose to.
- Rerun the heredity toy just inside the error threshold, with redundancy or graded failure, so the compression hypothesis actually gets tested.
- Build the 2-D landscape lab and the small toy market as cheap, transparent tests of single hypotheses.
- Pick one question and define precisely what phenomenon it's meant to explain.
- Read the primary papers, recording evidence, assumptions, domain limits and counterexamples.
- State allowed priors and available compute before proposing an implementation.
- If experimentation becomes the goal, design a small test that can tell explanations apart and expose failure, and compare at equal resource budgets.
- Record what humans supplied, what emerged, what transferred, what was retained, and what the result doesn't show.