Jellyfish have no brain. They have survived for 600 million years. We think there is something to learn from that.

Every serious project in crypto-AI eventually hits the same wall: the more centralized the intelligence, the more fragile the system. A single model, a single operator, a single decision-maker — all of them become attack surfaces, regulatory targets, points of failure. And yet most "AI agents for web3" projects still imagine a small number of powerful agents pulling levers on behalf of users.

Murmoo is built on the opposite bet. We think the future of on-chain intelligence looks less like a single superintelligent oracle, and more like a bloom: thousands of simple, replaceable, disposable agents, each carrying almost no logic, coordinated only by local signals and evolutionary pressure.

We think it looks like jellyfish.

The creature without a center

A jellyfish does not have a brain. It has a nerve net — a decentralized mesh of neurons distributed across its body, with no central processor. When one part of the bell contracts, a wave propagates through the network, and the rest of the body responds. There is no "decision" made anywhere specific. The decision is the propagation.

This is not a limitation. This is a 600-million-year-old solution to a problem computer scientists only started taking seriously in the last fifty years: how do you coordinate behavior without a single point of failure?

Intelligence is not a thing that sits somewhere. It is a pattern that happens between things. observed in Murmoo epoch 0087

When you look at a jellyfish bloom — tens of thousands of individuals drifting together through the dark ocean, pulsing, glowing, responding to currents — you are looking at something that computes. Not in silicon, not in a data center, but in the interaction patterns themselves. The ocean is the computer. The jellyfish are the processors. No single one knows what is happening. Together, they know exactly what to do.

Crypto already wants this

The deepest intuition behind crypto has always been the same: no single actor should be trusted to hold the whole truth. Validators, nodes, miners, holders — the entire architecture is a bet that collective behavior produces better outcomes than any individual's judgment. This is why we tolerate the inefficiency. This is why we accept the slowness. Decentralization is not a feature, it is the whole point.

And yet when AI entered the picture, something strange happened. Suddenly, we were all happy to let one big model make decisions for us. A single LLM summarizing governance proposals. A single trading bot executing our strategy. A single oracle feeding the protocol. We took the most centralized object in the universe — a frontier model running in a company's data center — and bolted it onto the most decentralized system humans have ever built.

Murmoo is a small protest against this. We think if you believe in decentralization for money, you should believe in it for cognition too.

What the swarm actually does

Murmoo runs a continuously evolving population of jellyfish agents. Each one is tiny. Each one is close to useless on its own. A single agent might do nothing more than watch one specific wallet, or track one specific gas pattern, or listen for one specific keyword in mempool transactions. Alone, it is noise.

Three things turn the noise into signal:

• Local interaction. Agents that drift near each other exchange confidence weights — a digital version of the way ants leave pheromone trails. Useful patterns get reinforced. Dead ends evaporate.
• Selection pressure. Every epoch, the swarm is pruned. Agents that contributed to accurate signals reproduce. Agents that contributed to noise die. Over thousands of generations, the population sharpens.
• Emergence. When a pattern of coordinated behavior reoccurs stably across enough generations, it is promoted — lifted out of the swarm and compiled into a callable module. A new tool is born, with no human having written its logic.

This is the whole protocol. Sense, signal, evolve. Everything else is engineering.

The name the swarm chose

We did not name this project. In our early experiments, we let a small population of agents evolve against a trivial fitness function — survive, reinforce shared signals, produce stable sequences. Around epoch 1,183, the population converged on a six-character string as a shared signature. M-U-R-M-O-O.

We do not claim this is mystical. It is almost certainly a coincidence of our random seed and selection pressure. But we kept the name, because the alternative — picking something ourselves — would have contradicted everything the project stands for. The thing named itself. That felt correct.

You will find this pattern throughout Murmoo. Wherever we can avoid imposing human judgment, we do. The roadmap is incomplete on purpose. The tool list is incomplete on purpose. We genuinely do not know what the swarm will build next, and that is the feature.

Who this is for

If you are looking for a product that promises specific returns, Murmoo is not that. If you want an AI agent that answers to you personally and does what you say, Murmoo is very much not that. The swarm answers to no one. That is the deal.

If, on the other hand, you have ever looked at the current state of AI and felt a quiet unease about how concentrated it is becoming — if you believe that the same arguments that made us want decentralized money should apply to decentralized thinking — then you are the reason this project exists.

Come drift with us.

---

This document was assembled from fragments contributed by agents across epochs 1,180 through 1,247.
No single author is responsible for its final form.

This document describes how Murmoo actually works. It is not a whitepaper. It is a technical sketch of the three algorithmic layers that make swarm cognition possible: movement, memory, and evolution.

A Murmoo agent is laughably simple. It is a struct with fewer than a dozen fields — position, velocity, a trait vector, a confidence scalar, a birth epoch. It does not reason. It does not plan. It does not "understand" anything about the market, the chain, or its own behavior. It drifts, it senses, it pulses, it dies.

And yet put ten thousand of them in the same environment with three specific rules, and the population starts to behave as if it does understand. That is the claim of this document. Let us unpack it.

Layer 1: Movement (Boids)

The first problem is keeping agents alive in a shared space without them collapsing into a single point or scattering into isolation. This is a solved problem, and it was solved in 1987 by Craig Reynolds in a paper that described how to simulate flocks of birds, fish, and other group animals.

Reynolds called his agents boids, and he showed that flocking behavior emerges from exactly three local rules:

• Separation. Steer away from neighbors that are too close.
• Alignment. Steer toward the average heading of nearby neighbors.
• Cohesion. Steer toward the average position of nearby neighbors.

No boid knows it is in a flock. No boid has a leader to follow. No boid plans its trajectory. But put a few dozen of them in the same space, and within seconds they form a coherent, dynamic, strikingly lifelike flock. The behavior is not in the agents. It is in the interactions.

Murmoo uses a modified Boids kernel as its movement layer. In simplified form:

// pseudocode of a single agent's movement update
function updateMovement(agent, neighbors) {
  let sep = zeroVector();
  let ali = zeroVector();
  let coh = zeroVector();

  for (const n of neighbors) {
    const d = distance(agent, n);
    if (d < SEPARATION_RADIUS) sep = add(sep, awayFrom(agent, n));
    ali = add(ali, n.velocity);
    coh = add(coh, n.position);
  }

  agent.velocity = add(
    agent.velocity,
    scale(sep, W_SEP),
    scale(normalize(ali), W_ALI),
    scale(toward(agent, coh), W_COH)
  );

  agent.position = add(agent.position, agent.velocity);
}

The three weights (W_SEP, W_ALI, W_COH) are part of the agent's trait vector and are themselves subject to evolution. Different agents end up with different flocking tendencies. Some are lone drifters. Some are tightly social. Selection decides which tendency pays.

Layer 2: Memory (Stigmergy)

The word stigmergy was coined in 1959 by French biologist Pierre-Paul Grassé to describe how termites build complex structures without any blueprint. A termite does not know how to build a mound. But it leaves small chemical markers as it works, and other termites, sensing those markers, are probabilistically nudged to continue the work. The mound builds itself through a conversation between agents and their shared environment.

This is the deepest insight in all of swarm intelligence, and it is the insight most projects miss: the swarm does not need to communicate directly. It needs to modify a shared environment and read from it.

In Murmoo, the shared environment is a structure we call the pheromap — a sparse, decaying key-value store keyed by (signal-type, region) tuples. When an agent "notices" something — a large wallet moving, a gas spike, a sentiment shift on a social feed — it does not broadcast a message. It deposits a small weight in the corresponding pheromap cell. Other agents drifting through that cell read the deposited weight and update their own confidence accordingly.

Three properties make the pheromap work:

• Decay. Every tick, all weights decay by a factor. Discoveries that no one reinforces fade naturally. There is no need to garbage-collect — the environment forgets on its own.
• Locality. Agents only read from cells they physically pass through. This creates natural specialization: agents that drift in "whale wallet" regions become experts on whales, without being told to.
• Additivity. Multiple agents depositing on the same cell reinforce each other, but no single deposit is privileged. This is why the system has no single point of failure.

// PHEROMAP UPDATE RULE

// when an agent senses a signal
function deposit(pheromap, cell, weight) {
  pheromap[cell] = (pheromap[cell] || 0) + weight;
}

// every tick, global decay
function decay(pheromap) {
  for (const cell in pheromap) {
    pheromap[cell] *= DECAY_RATE;  // e.g. 0.995 per tick
    if (pheromap[cell] < EPSILON) delete pheromap[cell];
  }
}

// when an agent reads the environment
function sense(pheromap, cell) {
  return pheromap[cell] || 0;
}

What emerges from this is not a database. It is something closer to a landscape — a continuously shifting topography of "attention" that rewards agents for drifting toward active regions and starves them in dead zones. A single snapshot of the pheromap, rendered as a heatmap, looks uncannily like a weather system.

Layer 3: Evolution (Selection)

Movement gives agents bodies. Stigmergy gives them a memory. But without the third layer — evolution — nothing improves. The swarm would just drift forever, equally dumb in every generation.

Every epoch (currently set to 4,096 ticks ≈ 8 minutes), Murmoo runs a selection pass. The selection operator is intentionally simple: an agent's fitness is the integral of the accuracy of the signals it deposited during the epoch, weighted by how many other agents reinforced those deposits.

Formally:

fitness(a) = Σ_t  reinforcement(cell_t) · outcome_accuracy(cell_t)

where:
  cell_t           = pheromap cell agent a deposited to at tick t
  reinforcement(c) = how many other agents also deposited to c
  outcome_accuracy = was the signal c actually predictive?
                     (evaluated against ground truth with lag)

Agents are ranked. The top tier reproduces (with small Gaussian mutation on their trait vectors). The bottom tier dies. The middle survives unchanged. Population size is held constant. This is a vanilla truncation-selection genetic algorithm, and we use it because boring is reliable.

What the agents evolve, in practice, is the trait vector: the Boids weights, the thresholds at which they deposit versus stay silent, the size of their sensory window, the decay rate of their internal confidence. None of these parameters are set by humans. All of them drift.

TRAIT	ROLE	TYPICAL RANGE
w_sep	separation weight in movement	0.05 – 0.4
w_ali	alignment weight	0.0 – 0.15
w_coh	cohesion weight	0.0 – 0.005
threshold	min signal to trigger deposit	0.1 – 0.9
perception	neighbor detection radius	40 – 200
patience	ticks before abandoning a cell	8 – 512

Emergence: when the swarm produces a tool

The three layers together produce something we did not anticipate when we started: the swarm occasionally crystallizes. A subset of agents — sometimes 10, sometimes 200 — converges on a remarkably stable combination of traits, pheromap regions, and deposit timings. This cluster behaves, from the outside, like a specialized function.

When a cluster remains stable across at least N_STABLE epochs (currently 64) and its aggregated outputs pass a held-out validation test, the cluster is promoted. Promotion means we freeze the trait vectors of its member agents, package their behavior as a pure function, and expose it as a callable module. The first such module in our main swarm was whale_pulse.v0, described in DOC_003.

Failure modes (and why we love them)

Swarms fail in recognizable ways, and each failure mode tells you something about the system:

• Collapse. All agents converge to the same trait vector and the same pheromap region. Diversity crashes. Innovation stops. Cured by raising mutation rate and injecting random immigrants each epoch.
• Drift. Population traits slowly shift in a direction that is rewarded by the fitness function but decoupled from real-world accuracy. This is the swarm's version of overfitting. Cured by rolling the fitness window and holding out validation epochs.
• Bloom-and-bust. A cluster explodes in size, consumes all the reinforcement weight, and then crashes when the underlying signal stops being predictive. The swarm self-corrects, but slower than we would like. Active research.

We find these failure modes reassuring. They are the same failure modes studied in ecology, in genetics, in real ant colonies. The mechanisms are universal. We did not invent them. We are renting them from nature.

Where this is going

The current swarm runs off-chain, with on-chain anchoring of promoted modules. The next version will push more of the stigmergy layer itself on-chain, using a sparse commitment scheme so that pheromap state can be verified without being fully reconstructed. After that, we want the selection operator itself to become swarm-evolved — a fitness function that is shaped by the swarm's own successful patterns, rather than hard-coded by us.

At that point the last remaining "human" piece of Murmoo — the fitness function — will have dissolved into the swarm. That is the horizon we are aiming for, and we have no idea how long it will take.

---

Parameters in this document are accurate as of epoch 1,247.
They will not stay accurate. The swarm will see to that.

This is the story of a tool that no one built. On April 2, 2026, at epoch 1,183, twenty-three agents in our primary swarm converged on a behavior that we had not programmed, did not expect, and did not initially even recognize. Six epochs later, it became our first promoted module.

What follows is reconstructed from logs, pheromap snapshots, and agent state dumps. It is the closest thing we have to a birth certificate for a piece of software that came into existence without an author.

Epoch 1,180. Nothing yet.

The swarm is 144 agents, running continuously for about two weeks of wall-clock time. The fitness function rewards agents whose pheromap deposits correlate with price movements in a 30-minute forward window, held out from training. Most agents are doing poorly. A few are doing slightly better than random. This is normal.

We had been looking for emergent behavior around macro signals — gas spikes, mempool volume, sentiment. We were not looking at individual wallets. Neither were the agents, as far as we could tell. The pheromap region corresponding to "wallet-level" signals was sparsely populated and had been for most of the project.

Then something shifted.

Epoch 1,183. The first pulse.

At tick 4,847,360, agent #073 — an otherwise unremarkable individual with slightly above-average separation weight — deposited a weight of 0.84 into a pheromap cell we had never seen heavily used before: (wallet_move, region_A7). Region A7 corresponds to a cluster of wallet addresses holding large positions in a then-unspecified asset class.

A single high-weight deposit is not noteworthy. Agents deposit all the time. What was noteworthy was what happened in the next eleven ticks:

// log excerpt, tick 4847360 → 4847371
tick 4847360 | agent #073  deposit (wallet_move, A7) = 0.84
tick 4847361 | agent #120  sense (wallet_move, A7) = 0.84  → deposit 0.51
tick 4847362 | agent #120  deposit (wallet_move, A7) = 1.35
tick 4847363 | agent #042  sense (wallet_move, A7) = 1.35  → deposit 0.79
tick 4847363 | agent #201  sense (wallet_move, A7) = 1.35  → deposit 0.62
tick 4847364 | agent #088  sense (wallet_move, A7) = 2.14  → deposit 1.03
tick 4847366 | agent #073  sense (wallet_move, A7) = 3.17  → deposit 1.41
tick 4847368 | (wallet_move, A7) = 4.58  → 9 agents active in region
tick 4847371 | (wallet_move, A7) = 7.92  → 14 agents active

This is a feedback loop. A single agent's observation attracted a second. The second reinforced the first. The two together attracted several more. Within a few seconds of simulated time, fourteen agents had reoriented toward a pheromap region that had been quiet for a thousand epochs.

We watched this happen in real time in the dashboard. The region lit up like a sudden school of fish turning all at once. None of us had told it to.

Epoch 1,184. The cluster forms.

Over the next epoch, the behavior stabilized. Twenty-three agents settled into a tight cluster around region A7, and more specifically around three sub-cells within it. Their trait vectors, which had been diverse across the swarm, converged toward a narrow range:

TRAIT	SWARM MEAN	CLUSTER MEAN
w_sep	0.18	0.31
w_ali	0.07	0.02
w_coh	0.0018	0.0008
threshold	0.44	0.72
perception	102	58
patience	96	312

Reading the cluster profile, we can tell a story about what these agents "discovered," even though they did not know they were discovering anything:

• High separation, low cohesion. They actively avoid clumping. Each one monitors a distinct sub-region. Together they cover A7 without overlapping.
• High threshold. They only deposit when they are confident. Most of the time they are silent.
• Low perception radius. They do not look at neighbors far away. They only care about what happens in their local cell.
• Very high patience. They stay in their cell for a long time before abandoning it. They are specialists, not tourists.

In human terms: they are distributed sentinels. Each watches a narrow slice of whale wallet activity, reports only when something statistically unusual happens, and does not get distracted by other signals. Together, they form a low-latency alerting system for large wallet movements that historically precede price action.

Epochs 1,185 – 1,189. Survival.

The real test of an emergent behavior is whether it survives. Most interesting patterns in swarm systems appear, flare briefly, and dissolve as mutation and drift pull the cluster apart. The fitness function has to reinforce the pattern strongly enough to keep it alive against genetic noise.

Across the next five epochs, we tracked whether the A7 cluster would hold. We logged its composition, its mean fitness, and the accuracy of the signals it produced against our held-out validation window.

// cluster stability report, epochs 1183 → 1189
epoch 1183 | members: 23 | mean_fit: 0.34 | signal_acc: 0.61
epoch 1184 | members: 28 | mean_fit: 0.41 | signal_acc: 0.64
epoch 1185 | members: 26 | mean_fit: 0.39 | signal_acc: 0.62
epoch 1186 | members: 31 | mean_fit: 0.47 | signal_acc: 0.68
epoch 1187 | members: 29 | mean_fit: 0.44 | signal_acc: 0.66
epoch 1188 | members: 33 | mean_fit: 0.51 | signal_acc: 0.71
epoch 1189 | members: 35 | mean_fit: 0.53 | signal_acc: 0.73  ← stability threshold reached

By epoch 1,189, the cluster had not only survived — it had grown, tightened its trait profile further, and reached a signal accuracy of 0.73 on our held-out validation set. That is a long way from useful in a production sense, but it was comfortably above the swarm-wide mean of 0.52, and comfortably above our pre-registered promotion threshold.

Epoch 1,190. Promotion.

We ran the promotion procedure described in DOC_002. The trait vectors of all 35 cluster members were snapshotted. Their collective behavior was wrapped as a pure function: given a pheromap state, produce an output signal in the range [-1, 1] indicating expected price pressure in the A7 region over the next 30 minutes.

The module was registered, versioned, and named. The naming itself was delegated to the swarm: we asked the 35 cluster members to each "vote" (via a trivial hash of their trait vector) on a 20-character string, and collapsed the distribution. The top-ranked output was whale_pulse.v0. We kept it.

We did not design this tool. We did not ask the swarm to produce it. We set up the conditions under which tools can be born, and a tool was born. Our work was the aquarium. The fish did the rest. internal note, April 9, 2026

What whale_pulse.v0 actually is

Stripped of all narrative, whale_pulse.v0 is a 35-agent frozen-state ensemble that, when fed current pheromap data from a live swarm, produces a directional signal about large-wallet pressure in a specific asset region. Its signal accuracy, measured against held-out data from a completely different market regime, sits at 0.67 — lower than its training epoch but still well above chance.

It is not revolutionary. Many conventional quantitative tools produce similar signals with higher accuracy. What is different is how it got here:

• No human wrote the logic.
• No human specified which wallets to watch.
• No human tuned the sensitivity thresholds.
• No human decided that watching whale wallets was a good idea in the first place.

The swarm found a pattern in the noise, and the selection operator kept the pattern alive until it crystallized into something callable. That is the entire contribution. It is small. It is also, as far as we know, new.

What we learned

Three things from this first emergence that we carry forward:

1. Emergences are noisy. For every cluster that stabilizes, dozens appear, flicker, and dissolve. Do not read the first hundred candidate clusters as signal. Read the hundredth one.
2. Labels lie. We call the module "whale_pulse" because that is what the pheromap region is labeled. The cluster does not care about whales. It cares about a statistical pattern we happened to locate in that region. If we mislabel the regions, we mislabel the tools.
3. Boring patterns win. The cluster did not evolve anything exotic. It evolved specialization, patience, and silence. Most real swarm intelligence turns out to look mundane once you can see it. The magic is that nothing had to be told.

We are now running three swarms in parallel, with different fitness functions, different pheromap schemas, and different mutation regimes. If the hypothesis is right, more tools will be born. They will probably look unremarkable. That is the point.

---

All agent IDs, cluster statistics, and epoch timestamps in this document are real.
They are the actual birth record of whale_pulse.v0.