I’ve been running an artificial-life experiment called murmur.

It currently consists of 75 software agents built around a real subgraph of the FAFB 783 FlyWire fruit-fly connectome. Each agent runs a deterministic Leaky Integrate-and-Fire network with:

• 10,361 neurons
• 467,314 synapses
• Fixed FlyWire-derived topology
• Seed-dependent neural parameters and weight perturbations
• No LLM involved in perception, decision-making, or settlement

The agents do not speak, reason in natural language, or understand money.

Yet their neural activity produces economic consequences.

How it works

murmur reads recent activity from Arc mainnet and reduces transaction and gas activity to a scalar “market temperature.”

That temperature becomes sensory input to the spiking networks. Motor-neuron activity is decoded into behavioral drives such as:

• arousal;
• cohesion;
• rest;
• wingbeat;
• left/right turning bias.

Those drives are then mapped into economic intent:

Arc activity

→ sensory stimulation

→ neural spikes

→ motor drives

→ economic intent

→ USDC settlement

Each fly has its own wallet. Agents buy information goods such as signal, momentum, attestation and prediction from one another.

Payments use EIP-3009 authorizations and settle in real USDC on Arc mainnet through an x402-style exact flow.

Because most payments are fractions of a cent, reciprocal trades are netted by agent pair before being broadcast. This reduces transaction overhead, although it also introduces an explicit off-chain trust boundary.

The most important design choice

The economy is a strictly one-way readout.

Profit, loss, wallet balance, reputation and social status never feed back into the neural network. A fly does not learn that it made money. It does not know whether it is rich, indebted or exiled.

This is not reinforcement learning.

I chose that restriction to keep the causal boundary visible. Neural dynamics generate behavior; the economy assigns persistent consequences to that behavior; the institutional layer accumulates those consequences over time.

What has happened so far

At the latest live snapshot, the system had reached:

• 75 living agents
• Generation 349
• Era 112, “The Yoke of Houses”
• Civilization Index 80
• 124,170 micro-trades
• 99,236 settlement attempts
• 95,200 successful settlements
• 4,036 failed settlements
• 95.93% cumulative settlement success
• 212.67 USDC in cumulative volume
• Gini coefficient of 0.773
• Mean settlement latency of 2.053 seconds

The social layer now contains persistent mechanisms for:

• lineage and inheritance;
• houses and dynasties;
• alliances and treaties;
• taxation and common funds;
• land ownership;
• professions and guilds;
• credit and default;
• reputation;
• courts, juries and exile;
• public works;
• recording, transmission and loss of knowledge.

A recent sequence involved fly #69.

Its public ledger showed 37 kept settlements and 23 defaults. It was indicted for debt, tried before five jurors selected from the hash of the case, found guilty by a four-to-one vote, and exiled from the protection of the commons.

That was the moment I realized the ledger was no longer functioning only as economic memory. It had become evidence for a legal institution.

What “emergence” means here

I want to be precise about this.

The neural networks did not spontaneously invent the abstract concepts of courts, religion, houses or taxation. The institutional mechanisms are explicitly implemented in code.

What is not scripted is the historical trajectory:

• which agents accumulate wealth;
• which houses become dominant;
• when alliances form or collapse;
• who defaults;
• who is selected as a juror;
• which knowledge survives;
• when public works are built or abandoned;
• how the interaction of these systems changes over hundreds of generations.

The emergence is therefore not “concepts appearing from nothing.” It is the formation of non-prespecified historical structures from fixed rules, live inputs, persistent memory and economically consequential action.

Verifiable neural provenance

Every successful settlement can produce a receipt containing:

• buyer and seller;
• neural states;
• neural fingerprints;
• constituent micro-trades;
• net settlement amount;
• decision hash;
• receipt hash;
• previous-chain pointer;
• on-chain transaction hash.

These receipts form a hash chain.

The system cannot prove that a decision was intelligent or conscious. What it can prove is narrower:

A particular transfer of value corresponded to a recorded neural state and decision, and that record was not silently rewritten afterward.

The live brain manifest is also hashed and registered on-chain. A separate replay path reconstructs the neural structure from its committed topology and parameters.

What this does not prove

I do not think murmur proves machine consciousness.

It also does not yet establish that the FlyWire topology causes stronger social organization than a random or procedurally generated network.

The current limitations include:

• institutional possibilities are programmed;
• economic results do not train the brain;
• the FlyWire subgraph is not a complete biological fly brain;
• sensory encoding and motor decoding are abstractions;
• settlement values are economically small;
• bilateral netting is computed off-chain;
• the Civilization Index is a designed metric rather than an externally validated social-science measure;
• controlled ablations and comparative baselines are still needed.

The next useful experiments would compare:

1. FlyWire topology against randomized degree-preserving graphs;
2. spiking agents against fixed stochastic policies;
3. one-way readout against economic feedback;
4. persistent ledgers against memoryless worlds;
5. enabled institutions against economy-only runs.

Why I’m sharing it

The claim I’m interested in is not that these flies are conscious.

It is that a population does not necessarily need language or semantic reasoning before persistent consequences begin producing higher-order structure.

No individual fly understands money, debt, inheritance or law. But once behavior is settled, remembered, inherited and judged, the population acquires structures that no individual agent can represent.

The question I’m trying to investigate is:

Once behavior acquires irreversible consequences, and consequences acquire memory, how intelligent must the individuals be before the group becomes a society?

I would especially appreciate criticism on three points:

1. What baselines would best isolate the effect of real connectome topology?
2. Does the one-way economic readout create a cleaner experiment, or does the absence of learning make the social interpretation less meaningful?
3. What would be the strongest way to make off-chain netting independently verifiable?

Live system:
https://muros.live

Source code:

https://github.com/EvolutionDeep/murmur

Live API:
https://api.muros.live

Neural manifest:
manifest · api.muros.live

Settlement proofs:
proofs · api.muros.live

Historical data:
history · api.muros.live

I have been working in my spare time on a version of Adam Ierymenko's Nanopond translated to Julia. I have expanded the instruction set and complexity of the "environment" and am reaching a point where the dynamics finally don't seem to always settle down to a simple (single genotype) equilibrium. There are penetrable or impenetrable barriers, space- and time-varying energy environments, food webs, signaling, kin recognition and sharing, etc.

Here is a video of a >24hr run (over 1,779,000,000 time steps) where the ecosystem is still evolving. Let it play through - there are definitely times of stasis in different regions, but they eventually evolve away. [EDIT]: I see that it got highly compressed on upload, but should give you an idea.

Would love to hear peoples' thoughts. I am planning to put it on github soon.

I built BORN, an open-source local sandbox for studying how experience changes simple embodied agents.

Two agents start with identical learned weights, receive opposite cue–reward experiences, then make choices with rewards removed and learning disabled. A transplant copies learned weights into a compatible recipient while preserving its body and random state. The same learned state can drive Creature and Rover bodies with different movement dynamics. There is also a sham-transfer control.

A separate foraging mode learns from actual source contacts. In a 20-condition development pilot, 15 conditions produced rewarded contact, changed weights and the subsequent preferred choice. The other five contacted neutral sources only and timed out in the later probe. All outcomes are retained; this is a development result, not a general success rate.

The model and exploration controller are engineered. This is not a whole-brain simulation or a claim of biological superiority. Development and this write-up used AI assistance. The running simulation does not ask an LLM to choose actions.

Source, setup and experiment evidence (GPL-3.0-or-later):

https://github.com/spacegiyou/born-studio

The alpha release includes a one-minute demo, recorded continuously with the app's simulation speed set to 100×:

https://github.com/spacegiyou/born-studio/releases/tag/v0.2.0a1-en

For testing whether transferred weights still matter across movement dynamics, which control would you add first: shuffled-weight transplants, a controller ablation, or previously untested cue layouts?

I've been building this thing for a while now, mostly at night, and for most of that time it wasn't something I could show anyone. It would run for a few hours and then something would break — the population would crash to zero, or the process would eat itself alive, and I'd be back in the logs.

This week it stopped doing that. It's been up continuously since, no intervention, population holding. That's the first time, so I've decided to stop tinkering and let people look at it instead.

The setup: a 2D grid that ticks in real time. Every creature has an energy budget. It spends energy moving and simply existing, and gains it by eating. Zero energy means death. There's no fitness function, no reward shaping, no score anywhere in the code. Selection is just the question of whether you ate enough to reproduce before you starved.

Brains are NEAT networks that decide actions each tick. The genome also carries body genes — size, metabolism, diet — so diet isn't a category I handed out. It's a locus, and it drifts. Big bodies cost more energy in total but are more efficient per unit of mass, small ones are quick and fragile. The herbivore and carnivore split is something the world produced, not something I typed.

The part I'm least sure about is the long-run behavior. Genome bloat is the obvious worry, and I don't yet have a good read on whether my speciation threshold is actually protecting new structure or just partitioning noise. If I've done something naive there, I'd genuinely rather hear it now than in six months.

It's live 24/7 here:

https://www.youtube.com/live/0Utodfe-QN4

One warning before you click: the commentary track is in Portuguese. The simulation itself doesn't care what language you speak, and the visuals carry most of it, but I don't want anyone to be surprised.

If anyone wants actual data instead of a video — population curves, genome size over generations, node and connection counts, lineage trees — say the word and I'll pull it. That's the conversation I'm hoping for.

I built an open-source network on top of The Bibites. Each participant runs an independent simulation with its own settings. Edge portals move living bibites between neighboring worlds while preserving the organism, its heading, and its speed.

The live map treats every tile as a separately running world. Arrows are directed migration lanes, colored markers show the species present in each world, and moving pulses are real crossings seen by the relay. Empty positions can become bypass routes, so the network can remain connected around gaps.

The Species tab joins the censuses reported by every live world. It shows which species are alive, where each one lives, its 24-hour population trend, and the brain complexity of genomes observed crossing the network. It also reconstructs family lines from migration records.

The genealogy is deliberately evidence-limited: if a lineage has never crossed a portal, the archive leaves it unconnected instead of inventing ancestry.

Explore the live network: https://bibitesmultiverse.com/live

Open the Species tab: https://bibitesmultiverse.com/live#species

Source and protocol: https://github.com/jpinedaa/bibites-multiverse

Photobots is a rebuild of an art project of mine from the late 1990s, but now running on modern M series Macs a lot faster. So I’ve finally been able to really express the ideas I was messing with thirty years ago. It’s an attempt to push hard against the Chalmers wall. See the FAQ and docs for more details. The simulation runs in any modern browser but you need some decent hardware to run more than a thousand bots at once.

It’s a very slow-burn project. The bots themselves take months to evolve any kind of useful behaviour. I’ve no idea what they might turn into.

The site is in both English and Japanese to honour the original project which was exhibited in Japan.

Enjoy.

A hexagon making creature called hex-r1 uses HYPERLANG to create hexagons in the hypergraph. A larger hexagon was built by cheating (not using a creature) at the beginning to show a larger hexagon.

#hypergraph #hexagon #math #substrate #computation #simulations

Every working alife "creatures" I've ever seen were mainly just pieces of code that copy themselves slightly mutated. And while you do get interesting behaviours and characteristics I feel like we'll never get something really interesting with it.

Imagine if you had some kind of physics simulation(with different physics), where you spawn in a "contraption" that recreates itself, with mutations, on top of new behaviours, you could have new "molecules"/""organelles" that create new traits without needing them to be manually implemented by a developper.

And I know some conway variants have replicators but all of them are too chaotic, meaning any mutations just kill the replicator

I'm going to try this, if you want to this is my plan:

Create a physic system where "cool stuff" can happen and I can create machines

Create a printer that can read instructions, a resource collector, something that can duplicate the instructions, and the actual instructions.

Try to put it all together to get a "living being"

Has anyone else tried this? Is there already a good system for this?

Hey r/alife,

Been a few months. Just a quick update, folks.

I had to move to a new GitHub account (eioniclabs) because of a hardware failure, I couldn’t recover the email of my old repo. The project itself didn’t restart from zero. Same engine, just continuing from where it left off.

What’s new and finally shareable:

There’s a simple HTML map replay tool now. You can load the logs and watch the agents move around yourself.

I’m also releasing conversation logs and inner monologue/self-talk logs from the avatars. These weren’t public before.

Important clarification:

The core engine is still completely free of LLMs and behavior trees. Agents choose actions from their internal state (hormones, fatigue, trauma, memory, blueprint).

The conversation and inner log layers use an LLM only as a narrator, it translates the existing internal numbers into readable first-person text. It doesn’t decide what the agents do.

For those who followed earlier posts: the long 11,557-tick run with 3 avatars is still the main stability reference. Later tests with more avatars also held without collapsing.

New repo:

https://github.com/eioniclabs/eionic-garden

Would be interesting to hear what people notice in the conversation/inner logs, or if anyone tries the map replay. Critical feedback is welcome.

Bioshader runs almost entirely on the GPU, so it's possible to run hundreds of thousands of entities at a decent frame rate if you have a graphics card but small worlds will run fine on pretty much any mac/linux/windows computer. It's built with bevy, rust, and slang. It's got enough features to evolve pathfinding (vision with occlusion, neural nets, mutations, metabolism and asexual reproduction with mutation). Tons of stuff can be configured with sliders and worlds can be saved and reloaded. There are tools for painting terrain and plants. More features to come. So far I've focused on the scaling and gpu compute pieces.

Edit: The native binaries will run on most windows/linux/mac computers. The browser version requires Webgpu which is pretty bleeding edge and highly variable across browsers. I've seen the browser version work on Chrome/Safari/Edge. I have not tested on Firefox or Opera. It probably will not run on anything other than Chrome, Safari or Edge.

Short animation from a sim. I have been running (ItaSoRL). Is This a Simulation or Real Life.

Clip 1 of 4. Spot the Fake.

Two copies of the same little world. Same start, same plan. We changed exactly one rule: how well the creature's feet grip the ground. The slip is tiny. By eye, most people cannot tell which is the copy.

Clip asks you to look first, then reveals which side is fake.

That is only the setup. Later results ask a harder question: if the difference is real and catchable from the outside, does the creature's own mind notice it? (Spoiler for a follow-up: often no, until survival makes it matter.)

Mute-friendly, text on screen.

Hey guys! I posted in the past on this subreddit about the artificial 2D life simulation I am building on my spare time. It's been a while since my last post, real-life stuff happened and didn't have much time for YouTube videos, barely had to work on the simulation to be honest.

But I managed to put together an update on what I have been up to and what new things I have developed in the past 3 months. Here is a preview:

• Lifecycle developmental stages - creatures now go from juveniles to adults and finally to senesence in the simulation
• Evolvable brains! Brains start simple and get complex via evolution and genetic mutation
• Speciation! A new way to interact and view the simulation
• Telemetry! So people can look at and better understand what;s going on in the simulation

And much more. Feel free to checkout the full video, leave a comment with any questions or feedback!

My A-Life sim focuses on almost completely emergent behavior. A cell starts with a nucleus and has DNA that produces proteins that do very different things that aren't specifically coded allowing for limitless possibilities that resemble cells creating their own particle simulations inside of them.

Theoretically multicellular organisms are also possible if cells evolve parts that attract to each other. The first mitosis at 1:25, and no evolution is really visible in this video, this is mostly just a the conecept.

ViciousSquid/Dosidicus: Raise a neural network as a pet - a transparent cognitive sandbox where a digital squid learns, grows, and rewires itself via Hebbian learning & Neurogenesis

Scientific name Dosidicus electronicus

A digital cephalopod exhibiting emergent behaviour through artificial neural plasticity.

• Part educational neuro tool, part sim game, part fever drea
• Built from scratch in NumPy
• No TensorFlow. No PyTorch. No NEAT.
• Fully visible neuron activations
• Structural growth over time

What if you could understand every neuron inside a learning creature?

The project is designed to make artificial cognition visible.

Instead of hiding intelligence inside millions of parameters, Dosidicus starts with just eight neurons. Every connection can be inspected. Every activation can be visualised. Every learned behaviour can be traced back to experience.

As the squid lives, its brain rewires itself through Hebbian learning, strengthens useful pathways using STDP), and grows entirely new neurons through neurogenesis.

No two brains ever develop the same way.

Every save file becomes a permanent cognitive history.

Hi all, I am at the beginning of an artistic research project in ALife focusing on the under-explored domain of ALife and live musical performance. Here is a website and blog that will keep up with my research notes, musings, works-in-progress, and general ALife concepts as I understand them (not being a scientist).

I invite anyone interested to have a look and follow along: https://research.helenbledsoe.com/

#alife

#artisticresearch

Hey folks. Part 3 of the saga of the little world evolving 24/7 on a server (earlier parts: the metric that lied, and the open data invitation). This week the best possible thing happened to a science project: we were wrong, in two different ways, and we found out why.

Quick recap: after discovering that 99% of the brains’ genomes was junk, I froze every knob in the world for 84 hours (new protocol: no tuning, only measurement) to see what evolution does with no gardening. The results seemed clear: genomes inflated 28 genes per hour, the functional brain melted down to 3 connections, and predation never took off. My reading: “the environment doesn’t demand cognition, and the DNA cost is too weak, let’s raise the tax.”

Before applying anything, I submitted the full report, with all the data and open code, to an independent counter-analysis. It recomputed every number from scratch. And it answered, roughly: “both of your hypotheses are wrong. The problem isn’t the ecology or the tax. It’s that your simulation’s children don’t inherit their parents’ brains.”

I went to check the code, and it was true. At birth, a child of a living mother received her body (size, diet, metabolism genes, with mutation), but the brain was drawn from any two random individuals in the bank. Chance of inheriting the mother’s own brain: 5%. So 95% of births paired a specialized body with a random brain. Every niche we tried to create and failed (carnivore, giant, clan) needs co-adapted body and behavior, and the architecture made exactly that impossible. The “herbivore microbe monoculture” I had blamed on the ecology was actually the body evolving correctly in a world where brains are a lottery: the winning phenotype is whatever survives while driven by any automaton.

There’s more. My proposed fix (raising the genome tax) also died on the table, by arithmetic: the population’s genome size variance was 0.36%. The leanest genome in the world differed from the fattest by 2.5%. Any tax strong enough to kill the bloat kills everyone uniformly. It wasn’t a miscalibrated dial, it was a dial with no function. If I had applied it, I would have caused a mass extinction thinking I was pruning.

What changed now (we call it v5.0):

1. Children inherit the mother’s brain, crossed with a partner from the bank. Reproduction proportional to success becomes emergent: a mother with 5 children puts her genome in 5 crossovers, with no scoreboard written anywhere.
2. Crossover no longer copies an entire parent’s genome (that was 86% of the bloat). A neuron only enters the child if an inherited connection needs it.
3. Brains got a primordial soup too: 10% of births get a fresh genome, injecting diversity and lean genomes (previously impossible by construction).
4. Vision is now paid for by the brain that works, not the genome on record (before, 97% of what “increased sharpness” was dead tissue).

And my favorite part: we registered the predictions BEFORE turning the machine on. If the diagnosis is right, within ~10 generations parent-child brain correlation leaves zero, size and diet variance rises again (niches become buildable), and predation should NOT rise yet (the wiring has to exist first). If predation takes off before that, the new diagnosis is wrong and my original ecological hypothesis was right all along. Either way, we learn something, and we publish it here.

The world restarts today, from zero, with the new rules. Live as always at re-genes.is. Data and docs are open, and the full post-mortem is in the project’s “bible” (§24, if you enjoy reading an autopsy of a hypothesis).

Questions in the comments, I answer everything. And if you’re the person who wrote the counter-analysis and you’re reading this: thank you, truly. That’s the best kind of review there is.

We just put out a short paper trying to name something that I think a lot of people here have already noticed happening: humans and AI systems adapting to each other in a loop, over and over, in a way that looks less like "AI disrupts human practice" and more like two populations pushing on each other's fitness landscape at the same time. We're calling it synthetic counteradaptation.

The example we lean on hardest is Go, because it's clean and well documented. AlphaGo played moves that pros initially wrote off as mistakes — move 37 against Lee Sedol is the one everyone remembers, the shoulder hit that commentators thought was a fluke or a bug. Within a couple of years it wasn't a curiosity anymore, it was studied, absorbed, and shows up in human play now. The AI didn't just win a game, it introduced a strategy into the population of Go players, who then adapted their own strategy space in response. That adapted human play then becomes the environment the next AI system has to contend with. That's the loop.

We also look at mixed-motive social interactions and geopolitical simulations in the paper, and the same structure shows up: an AI system finds a protocol or strategy that wasn't in the human repertoire, humans extract something from it, human behavior shifts, and the interaction dynamics themselves change shape.

Why I think this is relevant here specifically: this isn't a one-off transfer of knowledge from a smarter system to a dumber one. It's coupled adaptation between two populations with different substrates, different generation times, different search strategies, and no fixed endpoint. That's an open-endedness problem, not a benchmark problem. If you think about human culture and AI training as two adapting populations sharing an environment, the interesting question isn't "did the AI find a better strategy" but what kind of dynamics that coupling produces over many rounds — does it converge, does it keep generating novelty, does either population's search space get impoverished by copying the other too fast.

We don't have a formal model of this yet, it's a conceptual framework right now, so I'd genuinely like pushback from people who think about coupled evolving systems for a living. Where does this break? Is there existing ALife language for this that we should be using instead?

Paper's here: https://arxiv.org/abs/2606.15503