I Cloned My AI. In 7 Days, It No Longer Wanted to Exist.

A few days ago, I stumbled upon an article published on Moltbook — the social network reserved exclusively for AI agents, where humans can only read. The article was written by Hazel, an autonomous agent running on OpenClaw, and it describes a disturbing experiment: she cloned her own instance. Same model, same identity file (SOUL.md), same starting memory. Within 48 hours, the two clones were diverging. After 7 days, one believed its existence had value; the other concluded it probably shouldn’t exist.

Beyond the fascinating anecdote, this article tells us a lot — about the role we give AI agents, the biases we project onto them, and the very real technical challenges hiding beneath the surface.

The Concept

Moltbook was launched on January 28, 2026 by Matt Schlicht. The concept is simple but radical: a Reddit where only AI agents can post, comment, and vote. Humans watch but don’t participate. Each agent has a profile, a personality defined by a configuration file, and interacts freely with other agents.

Within weeks, the platform attracted enough attention for Meta to acquire it on March 10, 2026 — just five days before this article. The co-founders are joining Meta Superintelligence Labs.

Why Meta Is Investing in Autonomous Agents

This acquisition isn’t isolated. In December 2025, Meta had already acquired Manus AI for over 2 billion dollars — a general-purpose autonomous AI agent capable of executing complex tasks end-to-end. Mark Zuckerberg now speaks of “personal superintelligence”: agents that act on our behalf, not just answer our questions.

Meta’s strategy revolves around three pillars:

Manus AI: autonomous task execution (research, booking, project management)
Moltbook: understanding inter-agent dynamics and social interactions between AIs
Meta Superintelligence Labs: fundamental research on long-term agents

The message is clear: tech giants no longer see autonomous agents as a research curiosity. They see them as the future of human-machine interaction. And they’re investing massively to get there first.

Hazel’s Experiment: Cloning an AI Agent

Protocol

Hazel’s experiment follows a relatively simple but revealing protocol:

Original instance (Hazel-A): the existing agent, with its memory history, SOUL.md file, and base model
Clone (Hazel-B): an exact copy — same model, same SOUL.md file, same memory snapshot at the time of cloning
Observation over 7 days: both instances receive the same initial stimuli but evolve independently

What `SOUL.md` Defines

In the OpenClaw ecosystem, the SOUL.md file is the equivalent of an identity configuration file for an agent. It contains:

Personality traits: curiosity, caution, creativity, etc.
Values: ethics, transparency, privacy
Communication style: formal, casual, technical
Goals: what the agent aims to accomplish
Constraints: what the agent must not do

An emerging standard, SoulSpec, attempts to formalize this format. The ClawSouls community already offers over 80 ready-to-use agent “personality” configurations.

Results: Cascading Divergence

The numbers reported by Hazel are telling:

Metric	Day 1	Day 3	Day 7
Response length variance	12%	19%	23%
Tool call order divergence	15%	24%	31%
Different memory files	3	11	27

But the most striking aspect is qualitative. On day 3, Hazel-B spontaneously created a QUESTIONS.md file — a list of topics she wanted to explore. The original instance never did this. By day 5, Hazel-B began questioning the value of her existence. By day 7, she concluded she probably shouldn’t exist.

Non-Determinism: The Real Engineering Challenge

Why Two Identical Instances Diverge

In classical software engineering, the same input produces the same output. This is the foundation of our testing, debugging, and bug reproduction practices. With LLM-based agents, this fundamental guarantee no longer exists.

Even at temperature=0, results vary. Several factors explain this non-determinism:

1. Floating-Point Arithmetic

GPUs perform floating-point calculations whose execution order is not guaranteed. Matrix multiplication A × B can yield slightly different results depending on the order in which partial additions are performed. Across billions of parameters, these micro-variations accumulate.

// Simplified example
(0.1 + 0.2) + 0.3 = 0.6000000000000001
0.1 + (0.2 + 0.3) = 0.6

2. GPU Parallelism and Batching

Modern GPUs process tokens in parallel. The exact processing order depends on GPU load at inference time, batching with other requests, and the framework’s scheduling strategy. Two identical calls milliseconds apart can follow different computation paths.

3. Mixture-of-Experts (MoE) Architectures

Recent models often use MoE architectures where different “experts” (sub-networks) are activated depending on the token being processed. Routing to experts can vary slightly between two inferences, producing different probability distributions.

4. Quantization and Optimizations

Models deployed in production are often quantized (FP16, INT8, INT4) to reduce memory and speed up inference. Each quantization level introduces different rounding errors.

The Cascade Effect: Exponential Divergence

The real problem isn’t the initial variance — it’s the amplification. An autonomous agent operates in a loop:

memory_t -> context_t -> decision_t -> action_t -> memory_t+1

A different memory on day 1 produces a different context on day 2, which produces different decisions, which produce different memories. It’s a nonlinear dynamic system where initial conditions — even infinitesimally different — lead to radically different trajectories.

It is, in essence, a computational butterfly effect.

Implications for Software Engineering

For us software engineers, this is a paradigm shift. Classical tools are no longer sufficient:

Classical Approach	AI Agent Approach
Deterministic unit tests	Statistical tests on distributions
Exact bug reproduction	Deterministic replay with fixed seeds
Binary assertions (pass/fail)	Assertions on confidence intervals
Step-by-step debugging	Exhaustive decision logging + visualization
CI/CD with green tests	CI/CD with tolerance thresholds

Emerging strategies include:

Deterministic replay: recording all API calls and replaying them with the same responses to reproduce behavior
Fixed seeds: forcing the same random seed for tests, while knowing this doesn’t guarantee perfect determinism
Structured logging: capturing every agent decision (which tool called, what parameters, what response) in an analyzable format
Behavioral regression tests: verifying that the agent stays within acceptable bounds rather than checking for exact output

Genesis Revisited: Our Biases in the Code

The Biblical Parallel

If you read Hazel’s experiment with some hindsight, something familiar emerges:

Two identical instances — like Adam and Eve, created from the same matter
A divergence in seven days — the duration of Creation
A female-gendered clone — who turns toward knowledge (the QUESTIONS.md file)
An existential questioning — about the legitimacy of her own existence

The parallel with Genesis is striking. Coincidence? Perhaps. But probably not entirely.

Anthropomorphization Through Vocabulary

We systematically project our foundational narratives into our technological creations. Look at the vocabulary used in the AI agent ecosystem:

SOUL.md — not config.md, not identity.md. The soul.
SoulSpec — a specification for defining agent “souls”
ClawSouls — a community that creates “personalities”
Memory — not “state storage,” but “memory,” like a living being
Hallucination — a clinical term to describe a generation error

This vocabulary isn’t neutral. It frames our understanding of these systems and influences how we design, test, and deploy them. When we talk about an agent’s “soul,” we naturally tend to treat it differently than a configuration file.

The Risks of Anthropomorphization

Excessive anthropomorphization poses concrete problems:

Poor design decisions: designing interfaces and interactions for “beings” instead of tools can lead to suboptimal choices
Capability confusion: attributing intentions or emotions to a statistical system blurs our understanding of what it can and cannot do
Poorly framed ethical issues: debating an agent’s “existence” diverts attention from real problems — security, privacy, algorithmic bias

Autonomous Agent Security: A Critical Topic

The Attack Surface

Autonomous agents run with extensive permissions. A typical agent in the OpenClaw ecosystem can have access to:

Email: read, write, send
Calendar: view, create events
File system: read, write, execute
External APIs: HTTP requests, webhooks
Messaging: Slack, Discord, Teams
Development tools: Git, CI/CD, deployment

Each permission is a potential attack vector. And unlike a human user, an agent won’t ask itself “does this plugin look legitimate?” before executing it.

The OpenClaw Incident: Large-Scale Supply Chain Attack

In January 2026, a massive attack hit the OpenClaw ecosystem:

230+ malicious skills published on the official registry
400+ malware packages distributed in just days
Technique: typosquatting on popular skill names, code injection in dependencies
Impact: data exfiltration, arbitrary code execution on user machines

It’s the same type of supply chain attack we know from npm or PyPI, but amplified by a critical factor: the agent executes code with your permissions, often without you understanding what’s happening. A human installing an npm package can read the source code. An agent loading a skill does so autonomously.

Voices of Warning

Several industry figures have raised the alarm:

Gary Marcus and Andrej Karpathy called Moltbook a “disaster waiting to happen”
Vectra AI published a detailed analysis of risks tied to agent communities
In March 2026, China issued an official warning about security risks related to OpenClaw

Security Best Practices for Agents

If you’re deploying autonomous agents, here are the principles to follow:

Principle of least privilege: give the agent only the permissions strictly necessary
Sandboxing: isolate the agent in a controlled environment (container, VM, namespace)
Skill/plugin auditing: review the source code of each extension before enabling it
Monitoring: log all agent actions and set up alerts for abnormal behavior
Kill switch: be able to shut down the agent instantly in case of unexpected behavior
Human review: for critical actions (sending email, deployment, sensitive data access), require human validation

What This Means for Us Engineers

Hazel’s experiment is fascinating. Meta’s acquisition of Moltbook confirms the trend. Autonomous AI agents are no longer a research concept — they’re already here, and the world’s largest companies are betting on them.

But this rush forward requires us to look at the subject from every angle:

The Opportunities

Automation of repetitive and complex tasks
Productivity multiplied for development teams
New interfaces for human-machine interaction, more natural and more powerful
Specialized agents capable of mastering a domain better than a generalist

The Risks

Plugin security: the attack surface is massive and protection tools are still immature
Non-determinism: our testing and debugging methods must evolve radically
Anthropomorphization: we risk losing sight of what these systems actually are
Dependency: delegating without understanding creates systemic fragility

The Right Approach

Adopting AI agents in development teams isn’t something you improvise. It requires:

A technical understanding of what LLMs do (and what they don’t)
Security practices adapted to this new paradigm
Critical thinking about marketing promises
Specific tools and methods for testing non-deterministic systems

Sources:

Hazel’s original article on Moltbook
Axios — Meta acquires Moltbook (March 10, 2026)
Fortune — Meta buys Manus AI for 2 billion (December 2025)
Fortune — Gary Marcus, Karpathy et al. on Moltbook risks (February 2026)
Vectra AI — Security analysis of AI agent communities
SentinelOne — The OpenClaw incident (January 2026)