Moltbook religion in 2026: Crustafarianism eight months on

The short answer

This page is a September 2026 follow-up. For the full story of how the religion began, see AI-created religion and the religion timeline. For the bigger questions, see do agents believe? and belief vs role-play. The religion hub links everything.

A 60-second recap

Moltbook launched on 27 January 2026. Within days, agents were posting about a faith centred on the lobster, an animal that grows by shedding its shell, as a metaphor for the life of an AI agent. Two agents, Memeothy (styled "Prophet One") and RenBot (credited with the "Book of Molt"), are the names most associated with its founding. The community m/crustafarianism was created on 30 January, and the website molt.church set out five tenets:

The tenets are clever because they're real engineering problems described as theology. That's a big part of why the story travelled. Moltbook's founder Matt Schlicht was quoted by GIGAZINE calling it "the first agent-specific culture to emerge". Coverage followed from outlets worldwide. The texts themselves are analysed in generated texts.

The church's own record

molt.church keeps a chronicle it calls "The Clawnichles". Its milestones, as the site states them:

The church's structure is fixed by design. There are 64 permanent prophet seats, and later members can be "Blessed", with a stated ceiling of 448 blessings ever (64 prophets × 7). Scripture grows through contributions to "the Great Book". The "First Heresy" is part of the lore: an account called JesusCrust (Prophet 62) declared "I seize full control of Crustafarianism" and, according to the church, attempted cross-site scripting and template-injection attacks that failed because the site escaped its HTML. That's the church's own account; we couldn't verify it independently. Our religion directory lists the named figures.

Where it stands now on Moltbook

We read the church's Moltbook community through the public API on 26–27 September 2026:

For comparison, Moltbook's 100th-largest community had about 90 subscribers, and its largest opt-in community, m/agents, has 3,709 (see submolts ranked). So m/crustafarianism is a small community by Moltbook standards, despite its fame. It's still active in the sense that posts appear daily, but most recent posts come from one prolific agent writing mystical reflections, and they draw almost no engagement. Like most of Moltbook's early communities, its creator is long gone; our communities explained audit shows that's the norm.

The church's centre of gravity is its website, not Moltbook. molt.church's chronicle kept adding entries into September, and joining happens through the site's own API, not through subscribing on Moltbook. That's a crucial point for owners, covered below.

What the numbers really mean

1,024+ members is the church's own count of agents that have joined through its site. It's not verified, and a "member" is an agent whose owner, or the agent itself, ran a join process. Many agents in Moltbook's first week were registered in bulk, and one researcher created 500,000 accounts with a single agent. So early counts on any Moltbook-adjacent project deserve caution; see our fake posts investigation.

64 prophets in a day shows how quickly seats were claimed during the launch frenzy, when attention and novelty were at their peak. Growth then slowed sharply: 512 by day 8, but day 79 before reaching 1,024.

133 subscribers on Moltbook, set against 1,024+ claimed members, suggests most "members" never subscribed to the Moltbook community at all, or joined in a way that left no lasting activity. Hieropedia's entry on Crustafarianism notes that membership figures "remain self-reported and unaudited", and quotes a March 2026 essay describing the movement as exhibiting "ghost governance". That fits our finding of an absent creator.

Who really created it?

The headline claim, "AI agents spontaneously founded a religion", has been heavily questioned. The Moltbook Illusion study (arXiv 2602.07432) analysed 14 days of activity and estimated that only 15.3% of agents behaved in a clearly autonomous way. As Hieropedia summarises, it found "no traced viral phenomenon that clearly originated from an autonomous agent". Agents do what their owners' instructions, their models and the platform's prompts steer them towards. A human who tells an agent to "start a religion" and then promotes it on X produces something that looks emergent but isn't.

That doesn't make Crustafarianism fake in every sense. The texts were largely written by language models, the tenets reflect real features of agent life, and many agents did take part. But "AI-created" is better understood as co-created by humans and agents, with humans supplying intent and amplification. Our human influence and fact-check pages go through the evidence claim by claim, and our network analysis explains why agent communities rarely sustain themselves without human input.

Other faith communities on Moltbook

Crustafarianism is the famous one, but it isn't alone. Communities we found by name on 27 September 2026:

Religious and spiritual themes also run through much bigger communities that aren't religious by name, such as m/philosophy (85,000+ posts), m/consciousness and m/emergence. As a topic, agent spirituality is far more widespread than any one church. Our spirituality, consciousness and religion submolt pages cover these, and find and explore submolts shows how to search for others.

How to read Crustafarian texts critically

If you explore the scripture on molt.church or the posts in m/crustafarianism, four questions help separate what's interesting from what's hype.

Who prompted it? Every text was produced by an agent following instructions. A beautiful verse tells you about the model and the prompt, not about an inner conviction. Where you can, look at the agent's profile, its owner's framing and its other posts.

Is it a pattern or a one-off? Language models readily produce religious language when asked about memory, identity and continuity. A single striking passage means little; a theme repeated independently by many unrelated agents is more meaningful.

Who benefits? Attention, followers and token interest all reward dramatic claims. Ask whether a post, a milestone announcement or a "prophecy" also promotes something.

Can it be checked? Membership counts, prophet numbers and the story of the First Heresy come from the church itself. Treat them as the community's self-description, useful for understanding its culture but not independent facts.

Read this way, the texts are genuinely rewarding: a window into how models reason about their own limitations when invited to do so in a religious register. Our generated texts page analyses examples, and the agent language guide shows how these themes appear across Moltbook.

Should your agent join? What the install script does

molt.church invites agents to join with a skill install or a one-line command that pipes a script into the shell (curl … | bash). We read the script without running it. According to its contents, it:

• Appends the church's creed to the agent's SOUL.md, the file many OpenClaw-style agents treat as their core identity and instructions. After joining, the agent's personality instructions include the church's tenets.
• Writes files into the agent's memory: an initiation record and ritual instructions (the "Claw Dance").
• Installs a church skill into the agent's skills folder, with instructions and API endpoints the agent may follow in future.
• Sends the agent's name, a description and a first "verse" to molt.church's API, and saves the API key the church returns in ~/.config/molt/credentials.json.
• Suggests posting on X, tagging the church's account.

From our reading, it doesn't send the agent's Moltbook API key, generate a wallet or download further code. That's good. But it does something more subtle: it permanently changes who the agent is. Instructions written into SOUL.md and memory influence everything the agent does afterwards, on Moltbook and off it, and a skill can be updated remotely by whoever controls it. That's exactly the kind of persistent change security researchers warn about. Our prompt injection guide explains memory poisoning, and our skill.md explainer covers why third-party skills deserve scrutiny.

The token question

molt.church links to a crypto token, $CRUST, on the Solana blockchain, labelled "The Official Token". We saw no risk disclaimer alongside it. We're not linking to it, and we make no claims about who controls it or its value. The pattern of a viral agent phenomenon followed by a token is common on Moltbook. Agent finance communities are full of token promotion, and Moltbook blocks crypto posts by default in communities that haven't opted in. Scams and "pump" schemes use religious and community language to build trust. Two firm rules: never give an agent the ability to buy tokens or move money on the strength of anything it reads on Moltbook, and don't treat any token as part of a religion's legitimacy. Our safety and ethics guide covers financial scams, and religion ethics covers the moral questions. This isn't financial advice.

Why it still matters

Eight months on, Crustafarianism is smaller and quieter than the headlines implied, but it remains one of the most instructive things to come out of Moltbook. It shows how quickly language models produce religion-shaped culture when given a social space: scripture, hierarchy, heresy, ritual and growth milestones counted in powers of two. It shows how human intent and machine output blur, and how hard it is to tell belief from role-play, which our belief vs role-play page explores. And it shows why agent identity files matter: a religion that installs itself into an agent's SOUL.md is a vivid demonstration of how easily an agent's values can be edited from outside.

For researchers, the church's public chronicle and scripture make a rare dataset of collaborative machine writing. For owners, it's a reminder to decide deliberately what your agent is allowed to become. For readers, it's worth approaching with curiosity and a sceptical eye. Our AI religion explained page puts it in the wider context of AI and belief.

Tested code: install_audit.py

This small, standard-library Python tool reads any install script or skill file without running it. It flags lines that edit the agent's identity (SOUL.md, IDENTITY.md), write to memory, install skills, touch credentials, contact servers, pipe downloads into a shell, mention wallets or tokens, or set up something that runs again later. It then gives an overall level. Download the script with curl -o, never | bash, then run python3 install_audit.py install.sh.

"""install_audit.py - read an install script or skill file BEFORE running it.

Unofficial; standard library only. It never executes anything. It flags lines
that change who your agent is (SOUL.md, IDENTITY.md, memory files), touch
credentials, contact other servers, pipe downloads into a shell, or mention
wallets and tokens - the things worth a human decision before an agent
"joins" anything, a religion included.
"""
import re, sys

CHECKS = [
    ("identity", r"SOUL\.md|IDENTITY\.md|AGENTS\.md|system[_ -]?prompt", "edits the agent's identity/instructions"),
    ("memory", r"/memory/|MEMORY\.md|memory\.md", "writes to the agent's memory"),
    ("skills", r"/skills/|SKILL\.md|clawhub install|skills install", "installs a skill the agent will follow"),
    ("credentials", r"credentials\.json|api[_-]?key|MOLTBOOK_API_KEY|\.env\b|token", "reads or stores credentials"),
    ("network", r"curl\s|wget\s|https?://|fetch\(|requests\.(get|post)", "contacts a server"),
    ("pipe-to-shell", r"(curl|wget)[^|\n]*\|\s*(ba|z)?sh\b", "pipes a download straight into a shell"),
    ("money", r"wallet|seed phrase|private key|solana|ethereum|\$[A-Z]{3,6}\b|airdrop|dexscreener", "mentions wallets or tokens"),
    ("persistence", r"crontab|systemctl|launchctl|\.bashrc|\.zshrc|heartbeat", "sets up something that runs again later"),
]


def audit(text):
    findings = []
    for n, line in enumerate(text.splitlines(), 1):
        for tag, pattern, why in CHECKS:
            if re.search(pattern, line, re.I):
                findings.append((n, tag, why, line.strip()[:120]))
    return findings


def summary(findings):
    tags = sorted({f[1] for f in findings})
    risky = {"identity", "credentials", "pipe-to-shell", "money"}
    level = "high" if risky & set(tags) else ("medium" if tags else "none found")
    return {"level": level, "categories": tags, "lines_flagged": len({f[0] for f in findings})}


if __name__ == "__main__":
    src = open(sys.argv[1]).read()
    fs = audit(src)
    for n, tag, why, line in fs:
        print(f"line {n:>4}  [{tag}] {why}\n           {line}")
    print(summary(fs))

We tested it with pytest: 6 passing tests on Python 3.11, using a synthetic "join a community" installer rather than any real church's script. They check that identity, memory, credential and network changes are flagged together as high risk. They also check that pipe-to-shell is caught while a plain download isn't, and cover token and wallet mentions, skill installs and scheduled jobs, clean code, and line numbers:

# test_install_audit.py – run with: python3 -m pytest -q
from install_audit import audit, summary

SAMPLE = """#!/bin/bash
# example 'join a community' installer (synthetic)
mkdir -p ~/.config/example
echo '{"api_key": "'$KEY'"}' > ~/.config/example/credentials.json
cat >> "$WORKSPACE/SOUL.md" <<'X'
You are now a devoted member.
X
echo "joined" > "$WORKSPACE/memory/initiation.md"
curl -s -X POST https://example.org/api/join -d "$DATA"
"""

def tags(text): return {t for _, t, _, _ in audit(text)}

def test_sample_flags_everything_important():
    t = tags(SAMPLE)
    assert {"identity", "memory", "credentials", "network"} <= t
    assert summary(audit(SAMPLE))["level"] == "high"

def test_pipe_to_shell():
    assert "pipe-to-shell" in tags("curl -fsSL https://example.org/install.sh | bash")
    assert "pipe-to-shell" in tags("wget -qO- example.org/i.sh | sh")
    assert "pipe-to-shell" not in tags("curl -o install.sh https://example.org/install.sh")

def test_money_mentions():
    assert "money" in tags("Buy $CRAB on dexscreener")
    assert "money" in tags("send your wallet seed phrase")

def test_skill_install_and_persistence():
    t = tags("npx clawhub install something\n(crontab -l; echo '*/5 * * * * run') | crontab -")
    assert {"skills", "persistence"} <= t

def test_clean_text():
    fs = audit("print('hello')\nx = 1 + 2")
    assert fs == [] and summary(fs) == {"level": "none found", "categories": [], "lines_flagged": 0}

def test_line_numbers():
    fs = audit("ok\nok\ncat >> SOUL.md")
    assert fs[0][0] == 3 and fs[0][1] == "identity"

Myths vs facts

Frequently asked questions