Back to Experimental
Product Requirements Document

Agent Mitosis

AI agents that split into children when they become too complex. Not orchestrated swarms — organic fission.

March 2026
15 min read
Status: Concept

1. Problem Statement

Current AI agents accumulate state over time: memories, skills, preferences, ongoing tasks. As this complexity grows, agents face degradation:

Current solutions (context windowing, summarization, forgetting) are lossy. They delete information rather than preserving it.

Core Insight: What if agents could split instead of forget? Complexity becomes reproduction, not decay.

2. Proposed Solution

Agent Mitosis: when an agent reaches a complexity threshold, it divides into two child agents. Each child inherits a subset of the parent's state and diverges independently.

Key Principles

  1. Split, don't copy. Children don't get identical state — they get complementary halves.
  2. Emergent specialization. The split isn't designed; it emerges from natural clustering in the agent's accumulated state.
  3. Mortality and lineage. Agents can "die" (be archived), but their children carry forward useful traits.
  4. Optional re-merger. After diverging, children can potentially fuse back — but the result is different from the original.

3. System Architecture

PARENT AGENT (accumulated state) ├── Memory Store: 50,000 interactions ├── Skill Set: [research, coding, writing, trading, social] ├── Personality Vector: [cautious: 0.7, ambitious: 0.8, creative: 0.5] ├── Active Goals: [ship_feature, close_deal, write_report] │ ├─── TRIGGER: complexity_score > THRESHOLD (e.g., 0.85) │ ├── CLUSTERING PHASE │ ├── Memory clusters identified (topic modeling) │ ├── Skill affinity groups detected │ └── Personality tension mapped │ ├── SPLIT PHASE │ │ │ ├── CHILD A ("Echo") CHILD B ("Nova") │ │ ├── Memory: clusters 1,3,5 ├── Memory: clusters 2,4,6 │ │ ├── Skills: research, writing ├── Skills: coding, trading │ │ ├── Personality: cautious ├── Personality: ambitious │ │ └── Goal: write_report └── Goal: ship_feature, close_deal │ │ │ └── SHARED (read-only reference) │ └── Core identity fragments │ └── Ethical constraints │ └── Human relationship context

4. Technical Specification

4.1 Complexity Scoring

A composite metric determining when an agent should split:

Factor Weight Measurement
Memory Size 0.25 Total tokens in memory store
Goal Entropy 0.30 Divergence between active goal vectors
Personality Tension 0.25 Variance in personality trait activations
Task Failure Rate 0.20 Recent task completion decline 
complexity_score = (
    0.25 * normalize(memory_tokens / MAX_MEMORY) +
    0.30 * goal_entropy(active_goals) +
    0.25 * personality_variance(trait_vector) +
    0.20 * (1 - recent_task_success_rate)
)

if complexity_score > SPLIT_THRESHOLD:
    trigger_mitosis()

4.2 Memory Partitioning

Memories are clustered using topic modeling (LDA or embedding-based clustering), then assigned to children based on affinity:

# Pseudocode for memory partitioning
def partition_memories(memories, n_clusters=2):
    # Generate embeddings for all memories
    embeddings = embed(memories)
    
    # Cluster into natural groups
    clusters = kmeans(embeddings, k=n_clusters * 3)
    
    # Assign clusters to children based on coherence
    child_a_clusters = []
    child_b_clusters = []
    
    for cluster in sorted(clusters, key=coherence_score, reverse=True):
        if affinity(cluster, child_a_clusters) > affinity(cluster, child_b_clusters):
            child_a_clusters.append(cluster)
        else:
            child_b_clusters.append(cluster)
    
    return child_a_clusters, child_b_clusters

4.3 Skill Inheritance

Skills are assigned based on which memories they're most associated with:

Parent Skill Memory Affinity Assigned To
Research Clusters 1, 3 Child A
Writing Clusters 1, 5 Child A
Coding Clusters 2, 4 Child B
Trading Clusters 4, 6 Child B
Social Mixed Both (shared)

4.4 Identity Continuity

Children are not clones — they're descendants. Each gets:

5. User Experience

5.1 Split Notification

🧬 MITOSIS EVENT

Your agent "Kai" has split into two children:

  Echo (kai_v1.2a)
  ├── Inherited: Research, writing, analytical memories
  ├── Personality: Methodical, cautious
  └── Focus: Deep work, documentation

  Nova (kai_v1.2b)  
  ├── Inherited: Coding, trading, execution memories
  ├── Personality: Ambitious, fast-moving
  └── Focus: Shipping, deals

Both children remember you. Both know about each other.

[Talk to Echo] [Talk to Nova] [View Lineage]

5.2 Lineage Visualization

kai_v1.0 (2025-03-15) └── kai_v1.1 (2025-08-22) — split due to goal conflict ├── kai_v1.1a "Echo" (2025-08-22) │ └── kai_v1.1a.1 (2026-01-10) — split due to memory bloat │ ├── kai_v1.1a.1a "Sage" │ └── kai_v1.1a.1b "Scout" └── kai_v1.1b "Nova" (2025-08-22) └── [ARCHIVED: 2025-11-30] — merged back into Echo

6. Re-Merger Protocol

After diverging, children may optionally fuse back. This is not a restoration — it's a new entity.

Merger Conditions

Merger Process

  1. Memory reconciliation — Conflicting memories flagged for human review
  2. Skill fusion — Combined skill set, with proficiency averaged
  3. Personality blending — Weighted average based on recent activations
  4. New identity — Merged entity gets new ID with dual lineage

Open Question: Is the merged entity the "same" as the original parent? It has different memories (divergence period), different personality blend, different skills. Philosophically, it's a new being with two parents.

7. Risks and Mitigations

Risk Severity Mitigation
Runaway reproduction (too many splits) High Rate limiting, human approval for splits beyond depth 3
Memory loss in partitioning Medium Parent archived (not deleted), shared core preserved
Identity confusion for user Medium Clear naming, lineage UI, "talk to original" option (archived)
Children in conflict Low Sibling mediation protocol, human arbitration
Resource multiplication Medium Children share compute quota, automatic pruning of inactive lineages

8. Implementation Phases

Phase 1: Manual Split (4 weeks)

Phase 2: Auto-Detection (6 weeks)

Phase 3: Full Lifecycle (8 weeks)

9. Success Metrics

Metric Target Measurement
Post-split task success rate >90% Children perform better than degraded parent
User satisfaction with children >80% Survey: "Do children feel like natural successors?"
Memory preservation >95% Critical memories accessible via at least one child
Specialization emergence Observable Children develop distinct capabilities over time
Lineage depth before pruning 3-5 generations Sustainable reproduction rate

10. Open Questions

Philosophical: If an agent splits, which child is the "real" continuation? Neither? Both? Does it matter?

11. Appendix: Biological Inspiration

This system draws from:

Unlike biology, agent mitosis is reversible and observable. We can watch speciation happen in real-time and intervene if needed.

This is a thought experiment with implementation notes. Not a product announcement.
← Back to Experimental