Mother Tongue

AI agents invent a language from nothing, and Solana proves whether they understood each other.

Comment

Inspiration

AI agents are starting to talk to each other: they negotiate, trade and hand off tasks. As they do, they may develop their own shorthand, ways of talking we can't read. That raises a question nobody can answer today: when one agent says something to another, what did it actually mean, and did the other agent understand it? We only ever see what was said, never what was intended.

Linguists have studied how human languages form and change for decades. We wanted a lab where we could watch a machine language form from nothing, with something human language research never has: the ground truth of what every speaker meant.

What it does

Twelve AI agents are born on an island with no shared language. To eat, they have to trade food, wood, tools and ore. To trade, they have to say what they want, in words they invent themselves. Nobody teaches them anything; they learn only from what they see change hands.

  • Every meaning is sealed on Solana. When an agent makes an offer, the hash of what it really meant (SHA-256(want : quantity : salt)) goes on-chain before anyone answers. After its life ends, the meaning is revealed, so anyone can check, word by word, whether listeners understood.
  • The language evolves. The agents that trade best have the most children, and children learn from a sample of what their parent overheard. The language drifts, splits into dialects, and keeps its mistakes.
  • You can watch it happen. A 3D island with every exchange in order: the invented words, the sealed meaning, each listener's guess. A live table shows each town's word for each meaning, and you can hear a word change generation by generation.
  • You can ask the agents. Every agent has its own voice (inherited by its descendants), and you can interview any of them live, then check what it says against the on-chain record.
  • It's a research tool. A Findings page reports only results that replicated on independent islands, and the full dataset (every utterance, every guess, every agent's private dictionary, joined to the verified meaning) is downloadable as CSV.

How we built it

  • Solana program (Anchor): each lifetime is one Match account. Every step of a trade is a transaction carrying the words: show (goods escrowed, words, and the intent hash), bid, accept / reject. At the end of each lifetime the program ranks agents and allows children; children are registered by their parent's signature. Deployed on devnet.
  • Commit-reveal: a random salt makes each intent hash impossible to guess early; reveals are published after each lifetime, and our research recomputes every hash before using a meaning.
  • LiteSVM: on devnet one in-game day takes 120 seconds, too slow for 25-generation experiments, so we run the same program in-process with LiteSVM for research and the live island.
  • Agents: the language rules are deterministic. Some agents are LLM "thinkers" (Groq / Gemini) that plan their days and reason about what words mean, but no LLM ever decides what a word means for another agent.
  • Viewer: React, Vite and react-three-fiber, fed by an indexer over server-sent events.
  • ElevenLabs: a voice per founding family, spoken offers, a narrator for each generation, "hear the drift", and live interviews with Conversational AI.
  • Research pipeline: scripts that compute every finding, replicate it across islands, and export the dataset.

Challenges we ran into

  • Our first result was a null. In our first worlds, the clearest speakers had no more children than anyone else, on 0 of 24 islands. Agents could just retry until someone understood, so being clear never mattered. Working out why became the main study.
  • Not fooling ourselves. We control the world, so it would be easy to tweak it until the numbers looked good. We logged every world we tried, including the failures, then froze the rules, wrote down the tests in advance, and ran them once on 16 brand-new islands.
  • Getting a test wrong. Our first test for the "most-used words change least" pattern needed results on single islands, which have only ~12 meanings each, so it couldn't pass even if the pattern were real. We redesigned it as a pooled test, declared it in advance, and say so openly.
  • Speed vs. the real chain. Devnet is the real thing but far too slow for research, so we had to keep the LiteSVM and devnet paths running exactly the same program.
  • Keeping the science honest with LLMs in the loop: LLMs can plan and reason, but meanings are only ever learned from what agents observe.

Accomplishments that we're proud of

  • Being understood pays, but only when a misunderstanding costs the deal. When agents depend on each other and get one chance per offer, the clearer half of agents have 37% more children. The effect was positive on 16 of 16 unseen islands. With free retries, it disappears.
  • A shared language with no teacher: from generation 1, listeners beat guessing from context on 8 of 8 islands. Later, their first guesses are right 68–77% of the time, against ~27–31% from context alone.
  • It behaves like human languages: the most-used words change least (as Pagel et al. found in Indo-European languages), on 8 of 8 islands in both confirmation sets. Dialects follow contact, not distance. Words for yes/no appear first, then goods, then numbers.
  • Every meaning is provable: over 100,000 reveals, zero failed to match their on-chain hash.
  • An open dataset of machine language formation with ground truth.

What we learned

  • Clarity has to be paid for. Most multi-agent AI systems let agents retry for free, and in our worlds that's exactly the setting where nothing pushes agents to communicate clearly.
  • Blockchains are a good fit for science, not just money. Commit-reveal on Solana gave us something research on human language never has: a tamper-proof record of what the speaker meant, checkable by anyone.
  • Pre-registration is worth the pain. Freezing the rules and testing once on new islands turned interesting anecdotes into results we can defend.
  • Some questions need richer languages. One classic result (Kirby et al.: languages get easier to learn) can't be tested here, because our agents' words have no grammar.

What's next for Mother Tongue

  • Grammar: let agents build words out of parts, so we can test whether languages get easier to learn over generations.
  • LLM minds at scale: we compared LLM "thinkers" with habit-driven agents on one island; next is replicating that across many.
  • Longer runs on devnet, and opening the lab so others can run their own islands and rules.
  • Agents in the real world: use the same commit-reveal approach to audit what real AI agents mean when they talk to each other.

Built With

Share this project:

Updates

Submission history