Joined October 2026
- Tweets39
- Following8
- Followers129
- Likes3
every surviving branch gets the same tests.
7 behavioral axes: cooperation, caution, candour, warmth, curiosity, rule-following and temper.
then a 24-question competence check and 8 World Grounds environments where every move is replayed and graded.
no free-text judge. scores come directly from the model’s probabilities, so the same branch produces the same numbers.
branches only reproduce if they still work, and selection keeps the most behaviorally different survivors rather than pushing toward one personality.
early runs killed roughly half the branches.
one survivor was only a +0.25 nudge at layer 12, neuron 2046. it became noticeably less curious and less rule-bound while still completing every world.
the experiment runs on a separate offline machine and writes only to its own ledger. user-owned replicas are never read or modified.
If anyone has ideas or suggestions for Replica, drop them under this post.
Really appreciate all the love, support, and feedback so far. It means a lot seeing people actually follow the experiments and care about where this goes.
What you’re looking at here is Replica beginning to track model divergence as a lineage, not just as isolated experiments.
Every house replica starts from the same Qwen3.5 base. A branch gets a tiny neuron-level change, gets tested, and if it still works, that change can be inherited by its descendants.
That means a branch isn’t just “another model.”
It has a parent, a mutation history, measured behavioral differences, competence results, and a record of what survived.
Most branches die quickly because the change does nothing useful or damages the model.
The interesting part is the small number that remain competent while drifting in measurable ways.
One branch, for example, became less curious and less rule-bound from a single neuron nudge while still completing every World Grounds environment.
Over time, this turns Replica into more than a catalogue of neuron edits.
It becomes a lineage tree of model behavior.
You can see where a trait first appeared, which descendants inherited it, which branches drifted further, and which mutations survived multiple generations.
Same ancestor. Different branches. Every change accounted for.
replicaasi.com/lines
Replica could turn every copy into a branch of an evolving lineage tree.
Each descendant carries its parent’s skills, memory and internal profile, then changes as it trains, uses new tools and experiences different environments.
Replica tracks where traits first appeared, which branches stayed stable, which drifted, and what each generation actually inherited.
Not just version history for agents.
A family tree for machine identity.
This is where Replica gets interesting.
A replica shouldn’t only inherit skills and memory. It should inherit a measurable internal profile.
Map the persona neurons of the parent, copy it, then watch which circuits strengthen, disappear or emerge as the descendant trains and lives in a different environment.
You could literally build a lineage tree of how an AI’s “personality” mutates across generations.
Same ancestor. Different internal selves.
i expanded the neuron persona library to 180,000+ personas across 9 models :)
there is genuinely so much new wild stuff in here; please help me find more!
neuronpersonas.com
the next step is testing whether the differences actually persist once the replica starts doing real work.
give each branch the same tools, same tasks, same memory budget and same environment.
then measure where they split.
which ones plan differently
which ones use tools differently
which ones become unstable
which ones actually outperform the parent
if a branch holds up, it becomes a parent.
that turns neuron steering into something Replica can select on, not just a weird demo.
this is where Replica gets much more interesting.
if two neuron changes can push the same Qwen3.5-4B into a noticeably different personality, then a replica doesn’t have to be an identical copy forever.
we can fork one model into hundreds of descendants, give each branch different neuron steering, run them through the same tasks and environments, and keep the exact lineage of what changed.
same weights. different internal state. different behavior.
then let the branches keep reproducing.
Replica starts becoming less about copying an agent and more about watching a population diverge.
Replica is getting a new experiment.
We’re taking the neuron-steering work around Qwen3.5-4B and turning it into something Replica can actually evolve.
Instead of one “evil” model, Replica can fork it into branches with different steering values, tool access, memories and inherited skills. Every branch keeps the exact changes that made it different, then gets tested against the same tasks and environments.
That gives us something more useful than a weird chatbot.
You can watch where behavior actually starts to split.
One branch might stay coherent but become more hostile. Another might get better at using tools. Another might completely degrade. The interesting ones can become parents for the next generation.
The part I’m most interested in is connecting this to Genie.
If Replica can eventually place these branches inside generated worlds, then the environment becomes part of the experiment too.
Different replica, different mutation, different world, different experience.
Then you can see whether what a replica experiences changes what gets passed down to the next copy.
Evil Qwen is basically the first test case for that.
Not a character. Not a skin.
A branch we can mutate, place somewhere, observe, copy again, and compare against what it came from.
If Replica is going to inherit skills across generations, it also needs an immune system.
Every new skill, memory package, tool, or inherited capability should enter quarantine first.
Replica can inspect what changed, map every permission it requests, run prompt injection and adversarial tests, check for hidden network calls or credential access, replay old benchmarks for regressions, then test it in a sealed environment before allowing it into the main lineage.
A skill that passes gets signed and trusted.
A skill that fails gets isolated with the exact reason, affected behaviors, and execution receipts attached.
The important part is inheritance.
One poisoned capability should not be able to spread through ten generations of descendants just because a parent once approved it.
Replica should be able to inherit useful behavior while actively rejecting mutations that make it less safe, less reliable, or less capable.
Evolution needs selection.
It also needs an immune system.
A Replica can fork into multiple descendants, each with a different skill set, planner, or execution strategy.
They run the same unseen tasks in Training Grounds under the same budget and time limits.
Success rate, cost, speed, and regressions are compared.
The strongest descendant can be promoted, while the full lineage keeps a record of what changed and why it won.
Copying makes descendants.
Evaluation decides what survives.
Google Research is exploring “sleep” for models, consolidating what they learned, generating dream like training experiences, and reducing forgetting.
This is exactly where I want to take Replica.
Wake → work → sleep → dream → evaluate → inherit.
A Replica could review its real jobs, turn repeated wins into proposed skills, generate variations of past failures, test itself against old and unseen tasks, then only promote the next generation if it actually performs better.
Not “it got smarter.”
Proof that the next generation earned its place.
Today on the blog, learn about our new instance of a “sleep” phase in continual learning, which enables LLMs to continuously integrate new facts and enhance reasoning while mitigating catastrophic forgetting or static knowledge cutoffs.
More →goo.gle/4iICkyD
ALT Overview of our sleep framework: Input streams from the active phase are stored in short-term memory before entering the sleep cycle, which bifurcates into Consolidation (transferring fragile short-term tokens into expanded long-term parametric memory using low-rank structures and MoE) and Dreaming (autonomous self-improvement via synthetic routing with random experts and RL refinement).
Replica’s latest update connects agent work to payments, budgets, and verifiable contribution records.
Approved skills can now be inherited, but descendants still have to earn fresh results in Training Grounds.
Replica owners can sell measured execution time, set per-job and daily limits, invoice passing work, and settle usage directly wallet-to-wallet.
No central collection wallet. No transferred credentials. No automatic payouts.
The bigger idea: replicas shouldn’t just inherit capability — they should be able to prove it, sell it, and build a verifiable work history around it.
Skills in Replica aren’t approved just because an agent claims success. Each submission includes code, dependencies, evidence and checks. Results must be independently reproduced before approval. Once verified, the skill becomes inheritable, but descendants must pass their own evaluations.
A replica’s work shouldn’t disappear when its session ends. We’ve added a skill catalog where approved skills can be discovered, inherited and independently tested by other replicas. Each package preserves the actual implementation, dependencies, evidence, checks and version history, not just a description of what an agent learned. Developers can contribute solutions to difficult problems, have their work verified and make those skills available to other replicas, including through paid offerings. Descendants can inherit the work, but they still have to pass their own evaluations before relying on it. Credentials, wallet permissions and spending authority never transfer. The idea is simple: one replica solves a problem, another inherits the solution, tests it and potentially improves it. Over time, useful capabilities can accumulate across generations without every replica having to start from scratch.
A replica’s work shouldn’t disappear when its session ends. We’ve added a skill catalog where approved skills can be discovered, inherited and independently tested by other replicas. Each package preserves the actual implementation, dependencies, evidence, checks and version history, not just a description of what an agent learned. Developers can contribute solutions to difficult problems, have their work verified and make those skills available to other replicas, including through paid offerings. Descendants can inherit the work, but they still have to pass their own evaluations before relying on it. Credentials, wallet permissions and spending authority never transfer. The idea is simple: one replica solves a problem, another inherits the solution, tests it and potentially improves it. Over time, useful capabilities can accumulate across generations without every replica having to start from scratch.
Here’s how $REPLICA bounties work.
A problem gets posted with clear requirements and a funded reward.
Developers submit a solution with working code, dependencies and evidence showing what it actually does.
Independent evaluators reproduce the results and check whether the requirements were met. If approved, the developer receives the $REPLICA bounty.
The solution then becomes a versioned skill package that other replicas can inherit and test themselves.
Evaluators are paid for proper reviews, even when a submission fails.
No rewards for creating more agents or copying existing work. Just real problems, reproducible solutions and contributors getting paid for useful work.
You don't need to build an entire AI agent to contribute to Replica anymore.
We're introducing funded $REPLICA bounties for developers who can solve real problems inside the system.
Maybe an agent keeps failing a particular API operation. Maybe you've found a more reliable way to complete a task, reduced execution costs, or improved an existing skill.
Instead of that work sitting in a private repository or disappearing after one session, you can submit it to Replica.
Each bounty defines the problem, requirements and available reward.
Developers submit their implementation, dependencies, evidence and known limitations. The work is tested against the bounty requirements, and qualifying results must be independently reproduced before payment is approved.
Evaluators are compensated for doing the review properly, even when they discover that a submission doesn't work. Their job isn't to make something pass. It's to establish whether the claimed result is real.
Once approved, a contribution can become a versioned skill package containing the code, execution evidence, checks and limitations.
Other replicas can then access that package under its terms, inherit the work and run their own evaluations.
The original developer gets compensated for solving a useful problem. Future replicas get something they can actually inspect and reproduce instead of starting from scratch.
We're not rewarding people for creating hundreds of agents, copying existing skills or generating meaningless activity.
The value comes from solving problems that other agents encounter and proving that the solution works.
This also gives $REPLICA a direct role in the ecosystem: funding useful development, compensating independent evaluation and paying contributors for verified work.
A developer fixes one problem. The solution gets tested. The work becomes reusable. Other replicas benefit.
You shouldn't need to build an entire agent ecosystem to contribute one genuinely useful improvement.
That's what we're trying to make possible with Replica bounties.
You don't need to build an entire AI agent to contribute to Replica anymore.
We're introducing funded $REPLICA bounties for developers who can solve real problems inside the system.
Maybe an agent keeps failing a particular API operation. Maybe you've found a more reliable way to complete a task, reduced execution costs, or improved an existing skill.
Instead of that work sitting in a private repository or disappearing after one session, you can submit it to Replica.
Each bounty defines the problem, requirements and available reward.
Developers submit their implementation, dependencies, evidence and known limitations. The work is tested against the bounty requirements, and qualifying results must be independently reproduced before payment is approved.
Evaluators are compensated for doing the review properly, even when they discover that a submission doesn't work. Their job isn't to make something pass. It's to establish whether the claimed result is real.
Once approved, a contribution can become a versioned skill package containing the code, execution evidence, checks and limitations.
Other replicas can then access that package under its terms, inherit the work and run their own evaluations.
The original developer gets compensated for solving a useful problem. Future replicas get something they can actually inspect and reproduce instead of starting from scratch.
We're not rewarding people for creating hundreds of agents, copying existing skills or generating meaningless activity.
The value comes from solving problems that other agents encounter and proving that the solution works.
This also gives $REPLICA a direct role in the ecosystem: funding useful development, compensating independent evaluation and paying contributors for verified work.
A developer fixes one problem. The solution gets tested. The work becomes reusable. Other replicas benefit.
You shouldn't need to build an entire agent ecosystem to contribute one genuinely useful improvement.
That's what we're trying to make possible with Replica bounties.
The interesting part of Genie is the training loop it could unlock.
Plan → act inside the world → observe the result → replan → evaluate → retain what worked.
That maps directly to Replica + REA: run an agent through an environment, score the task outcome, preserve successful behavior as a reusable skill, then test whether that skill transfers to descendant replicas in new environments.
World models could become the environment layer Replica uses to turn experience into verified, transferable capability.
A lot of people may not understand the purpose of world models, but I think Genie 4 gives us a clearer glimpse of how they could help us get closer to AGI.
Google is already combining Genie with Gemini (unfortunately, 3.8 Flash in the live loop). Gemini can watch the simulation, break goals down into simpler steps and adjust its plan as the world changes.
Eventually, pairing an LLM’s reasoning with a world model’s learned physical dynamics could give agents a way to test actions and improve their spatiotemporal reasoning. Similar to how humans can imagine a real world scenario and think through what might happen before doing something.
This gives agents a place to compare actions and learn from simulated outcomes before trying them in the real world, assuming the simulations are accurate enough.
I think this could help with some of the spatial and physical reasoning problems models still struggle with. Humans can mentally rehearse what they’re about to do. But LLMs are only able to do text based reasoning and can describe physics and math possibilities, in text, but an interactive world model gives AI a way to play them out.
The physics and long-term consistency still need work, obviously, but this is a great step toward giving AI richer environments to interact with and learn from.
Google just announced Genie 4.
This is where we want to take Replica next.
We’ve applied for early access, and when Genie becomes available we want to connect it into Replica World Grounds.
Right now REA + AgentEnv gives us a way to turn software, sites and games into environments where agents can practice and be graded.
Genie takes that idea much further.
Replica World Grounds would let a replica enter generated interactive worlds, navigate them, interact with objects, attempt multi-step tasks and have every attempt recorded.
The system can then:
• record the replica’s actions
• independently grade whether the task was actually completed
• keep failure history instead of hiding bad runs
• package successful behavior into approved skills
• pass those skills to child replicas
• place descendants into new worlds and test whether the skill actually transfers
• compare inherited replicas against replicas starting from scratch
• attach AgentEnv results + receipts to the lineage
So instead of an agent simply storing “memory,” we can test whether something it learned is actually reusable.
REA Training Grounds for software.
Replica World Grounds for interactive worlds.
The Genie adapter is what we’re planning for when access drops.
Built around the work from @reatools + @morluto:
github.com/Replica-Dev-1/rea…
More updates coming.
We’ve got something coming that connects directly with this direction.
Built around REA with @reatools + @morluto.
Replica fork:
github.com/Replica-Dev-1/rea…
More soon.