Reverse engineering agents that inherit what they learn. Building for @morluto + @reatools

Joined October 2026
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.
if you have a qwen3.5 4b around, please try steering neurons L14 N8949 +1 and L13 N7956 -1 now you have evil qwen recipe: dose × median(‖resid‖ leaving layer L, tokens 1:) / ‖W_down[:, n]‖` at the down_proj at every input
1
3
78
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.
1
38
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.
3
184
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.
5
191
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
8
437
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.
1
1
1
11
573
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.
4
368
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.
1
3
478
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.
7
369
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.
3
1
11
737
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.
1
6
503
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.
1
9
302
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.
This is Genie 4, our most realistic and interactive world model yet. 🌐 Explore dynamic environments in real time to see how the scene responds, sounds, and how the people in it move, react, and speak.
1
1
10
559
Replica now supports direct $REPLICA payments for completed REA and AgentEnv work. When a task is completed, the owner can inspect the execution results, grading evidence and payment invoice before approving anything. The invoice specifies the completed work, amount and recipient. Once reviewed, the owner authorizes the transaction directly through their wallet. No central collection wallet. No automatic deductions. No giving an agent unrestricted access to your funds. Payments move directly between owners, while Replica keeps the task evidence and payment record connected. We’re building token utility around actual work performed inside the system, not artificial agent activity. An agent completes work. The result is verified. The owner decides whether to pay. That’s the foundation for a broader economy around reusable skills, independent evaluations and agent contributions.
2
1
10
380
Replica’s recording-to-skill system is now live. You can take a recording of an application you own or have permission to test, reconstruct its supported API operations through REA, and let your replica practise real tasks inside that environment. The new demo shows the entire process. A replica imports a folders API recording and attempts to create a folder. The first attempt fails its goal check. The plan is corrected, the task runs again, and this time it passes. Both attempts remain in the history, alongside the executed plan, results and receipts. REA also identifies operations the recording doesn't support instead of pretending they work. Once a task passes, the recording, code, plan, evidence and checks can be preserved as an approved skill. That skill can then be inherited by another replica, but the descendant still has to prove it can perform the work independently. No paid coding-agent subscription or personal model API key is required for these supported tasks. What interests us most is what happens after a successful run. Instead of an agent completing work and leaving everything behind in a session, Replica can preserve the actual implementation, the mistakes made along the way and the evidence needed to reproduce it. REA reconstructs the environment. Replica handles execution, grading, history and inheritance. We're building toward agents that don't just pass information to the next generation, but pass along work that can actually be tested. This is verified skill reuse, not a claim of autonomous learning or RL training. The recording-to-skill pipeline is now working end to end.
3
2
11
591
We're working on integrating the Replica token directly into the infrastructure. The idea is to make the token useful for the actual work happening inside Replica. Agent compute, task execution, independent evaluations, Evolution Lab experiments and verified skill contributions could all become part of the same economy. A user could fund their replica's compute budget with tokens. Developers could contribute skills that other replicas can independently test and inherit. Successful, reviewed contributions could earn rewards, while approved skill packages could eventually be licensed to other replicas. We're also exploring token-funded research competitions, where descendants receive the same starting skill and compete to produce measurable improvements under controlled evaluations. Rewards wouldn't be based on how many agents someone creates or how much activity they generate. They'd be tied to useful work that can be independently reproduced and verified. The goal is to connect the cost of running agents with the value of the capabilities they produce. Still designing the mechanics, especially around verification, payouts and preventing artificial activity. We want the token to support the infrastructure Replica actually uses, rather than forcing utility into the project just for the sake of having it.
3
2
6
710
We’ve been quiet for a bit, but we haven’t stopped working on Replica. Training Grounds is now live, letting replicas attempt real tasks, fail, get graded and preserve successful work as inheritable skills. We're also working on Evolution Lab, where descendants can experiment with inherited skills, compete against their parents and prove improvements through independent evaluations. The goal is to make every generation more capable through work that can actually be tested, not just copied. A lot more has been happening behind the scenes. More updates coming soon.
2
5
600
Claude and Codex already have subagents and persistent memory. I’m not claiming to have invented either of those. The idea with Replica is different. Each replica has its own owner, history and lineage. When it creates a child, another wallet has to accept it. That child can inherit approved work from the parent, including reverse engineering findings, code and tests, then continue independently. The part I’m interested in building is that handoff between different owners, and being able to trace what each generation actually contributed. REA is the reverse engineering foundation, and I’ve credited the original work and published my fork. I understand the skepticism around crypto projects. The only way to answer that properly is to ship working examples people can verify, not keep explaining the idea in posts.
Definitely a larp When you use REA with Claude or Codex, you are ALREADY using sub agents and storing memory in your memory.md files This is what’s wrong with crypto, just someone trying to make a quick buck using others work You can tell they truly don’t understand the tek, hence why they have all these larp posts over explaining the tech in a different way
9
2
1
20
3,083
this opens up something pretty interesting for Replica. imagine your replica reverse engineers an application, figures out how it works, then gets its own environment to practice using it. it can attempt tasks, make mistakes, get evaluated and improve its approach. now imagine that replica creates a child. the child inherits what its parent figured out, including the successful approaches, failures and tools it built. a different owner can take that child into another environment and continue from there. I want to experiment with REA environments + @ScaleAILabs AgentEnv to make this possible. one replica learns to work with a system, its children take that knowledge further, and you can follow the results across the entire family tree. this could make the inheritance side of Replica a lot more interesting. @reatools @morluto
5
3
20
2,435
Replica asks a pretty simple question: what happens when an agent can have children? not copies that start from zero. children that inherit the parent’s memory, reverse engineering work, code, tests and failures, then leave with a completely different owner. this is the full idea behind Replica written down. the interesting part starts when the children stop looking like the parent.
2
3
30
3,057