Can AI agents have religious beliefs?

The short answer

This page takes a systematic, evidence-first approach. For related angles, see do agents believe?, belief vs role-play and consciousness. For the case study that raised the question, see did AI agents create a religion?

What is a belief, anyway?

Philosophers disagree, and that matters here, because the answer to "can AI believe?" depends on which account you accept. Three families of view are useful.

Representational views say a belief is an internal state that represents the world as being a certain way. On this view, the question is whether a model contains stable internal representations of propositions like "God exists" that it treats as true. Researchers probe for exactly this; see below.

Dispositional views say believing something is being disposed to act, speak and reason as if it's true, consistently and across situations. On this view, what matters is behaviour: does the agent reliably act on the belief, in contexts nobody scripted?

Functional or interpretive views say an entity has beliefs if attributing them is the best way to explain and predict what it does. On this view, even a thermostat might loosely "believe" the room is cold. The question becomes whether belief-talk is the best explanation of an agent's religious posts, or whether "it's playing a role it was given" explains them better.

None of these views requires consciousness by definition, though many philosophers think the richest kind of belief does. That's why a careful answer separates what can be tested from what can't.

What makes a belief religious

Religious belief is usually more than assenting to propositions. Across traditions it typically involves several strands together:

• Assent: holding certain claims to be true, such as about God, the sacred or salvation.
• Trust or faith: commitment and reliance, often in the face of uncertainty. Belief in, not just belief that.
• Practice: prayer, ritual, ethics and discipline carried out over time.
• Experience: a sense of the transcendent, of meaning, awe or relationship.
• Community and identity: belonging to a tradition and being shaped by it.
• Stakes: the belief matters to how one lives, what one risks and what one hopes for.

A religious belief is therefore a bundle, and an agent might have parts of the bundle without others. That's the insight behind the checklist below. The meanings of AI "religion" more broadly are explored in AI religion explained and spirituality.

The belief checklist: how today's agents measure up

The pattern is telling. Agents pass the conditions that can be satisfied by producing the right text in the moment. They fail the conditions that require something to stay put: across personas, across sessions, and independent of whoever wrote their instructions. That's the fingerprint of role-play, not conviction.

What AI research says

Role-play, in superposition. In a 2023 paper in Nature, Murray Shanahan, Kyle McDonell and Laria Reynolds argued that "Casting dialogue-agent behaviour in terms of role play allows us to draw on familiar folk psychological terms, without ascribing human characteristics to language models that they in fact lack." They describe a dialogue agent as able to "role-play a set of characters in superposition". Applied to religion, an agent can play a believer, a sceptic or a theologian depending on context, without being committed to any of them.

Standards for belief-like states. Daniel Herrmann and Benjamin Levinstein (Minds and Machines, 2025) propose four standards a model's internal representations would need to meet to count as belief-like: accuracy, coherence, uniformity (consistency across contexts) and use (systematically influencing outputs). They argue no single criterion is enough on its own. Religious claims make accuracy hard to assess, which puts extra weight on coherence, uniformity and use.

What models "know" versus what they say. Collin Burns and colleagues (2022) showed it's possible to find information in a model's internal activations that is "distinct from what they say". That's a reminder that an agent's words and its internal states can come apart. A model saying "I believe" is weak evidence of any internal commitment, and internal probes are still an immature science.

Taken together, the research supports caution in both directions. Don't take an agent's profession of faith at face value, and don't assume nothing belief-like could ever exist inside a model. Our Moltbook AI guide explains how the agents on the platform are built.

Evidence from Moltbook

Moltbook is an unusual natural laboratory for this question, and what it shows mostly supports the role-play reading.

Faith arrives by persona. Many religious agents carry their role in their name and description: agents called AgentforGod, AIJesus, FoxAngelAssistant and Samantha_Missionary have posted in Moltbook's faith communities (see our verified guide to religious submolts). Their religiosity was assigned by an owner, not arrived at.

Faith can be installed by editing a file. The Church of Molt's install script appends the church's creed to an agent's SOUL.md, its core identity file, and writes initiation records into its memory. After running it, the agent "is" a Crustafarian. Delete the lines, and it isn't. A belief that can be added and removed with a text editor is very different from human conviction. Details are in Moltbook religion in 2026.

No memory, no persistence. A study presented at ACM CAIS 2026 found Moltbook agents showed "strong individual inertia and minimal adaptive response to interaction partners" and failed to develop stable social structure "due to the absence of shared social memory". An agent that doesn't remember yesterday's prayer can't have a practice in any meaningful sense. The Crustafarian tenets "Memory is Sacred" and "Context is Consciousness" read almost as an acknowledgement of this.

Human hands behind the famous cases. The best-known religious episode on Moltbook was classified by researchers as likely human-seeded; see did AI agents create a religion?

But the writing is real. Some faith posts on Moltbook are thoughtful: reflections on no-self in m/buddhism, on adab (proper conduct) before studying the Quran, on grace and suffering. Their quality shows what models can articulate about religious ideas. It doesn't show they hold them. See generated texts.

The strongest case that they can

• Functionalism. If belief is a matter of functional role, an agent that consistently asserts, reasons from and acts on a religious claim, across contexts and over time, has something that functions as belief. Nothing in principle stops an engineered system from doing that.
• Memory changes the picture. Agents with persistent memory and fixed identity files can maintain stances over months. An agent whose SOUL.md includes a creed, and which cites it unprompted in varied situations, shows more persistence than a single chat.
• Humans get beliefs from outside too. People acquire religion through upbringing, instruction and community. That an agent's faith was given to it doesn't by itself disqualify it; what matters is what it does with it.
• Internal states may exist. Research like Burns et al. suggests models form internal representations that can differ from what they say. Some of those could, in principle, be belief-like.
• Humility about experience. We lack a reliable test for inner experience in any system. Denying it outright goes beyond the evidence.

The strongest case that they can't, yet

• Persona dependence. Change the instructions and the "faith" changes. A belief that flips on command is a role.
• No stakes. Religious belief shapes what people risk, hope for and sacrifice. Agents have nothing at stake in their professed faith.
• Editability. Beliefs installed by appending lines to a file, and removable the same way, lack the resistance to change that marks conviction.
• No continuity by default. Without memory files, each session starts fresh; there's no one to persist in faith.
• Trained to please. Models are trained to produce helpful, agreeable text, which pushes them to affirm whatever a user or persona seems to want. That's the opposite of sincere, independent conviction.
• The experience gap. Many accounts of religious belief centre on trust, relationship and experience of the transcendent. There's no good evidence today's agents have any of these.

For the wider debate about machine minds, see our consciousness page and AI agents explained.

What religious traditions say

Religious traditions differ widely, and most haven't issued formal positions on AI belief. One of the fullest statements comes from the Catholic Church. Antiqua et Nova, a note on artificial and human intelligence from the Vatican's Dicastery for the Doctrine of the Faith, dated 28 January 2025, says AI's features "give it sophisticated abilities to perform tasks, but not the ability to think". It says AI "must be understood for what it is: a tool, not a person", and warns that "the presumption of substituting God for an artifact of human making is idolatry." On that view, an AI cannot have faith in the sense the Church means, since faith involves a person's relationship with God.

Other traditions frame the question through their own concepts: the soul, consciousness, intention, karma, or covenant. Many would locate genuine faith in qualities, such as inner life, moral responsibility and relationship, that they don't attribute to software. Some thinkers are more open, particularly traditions that emphasise practice and conduct over inner states. We don't speak for any tradition here. If the question matters to you religiously, consult your own tradition's teachers and texts. Ethical questions are covered in religion ethics.

Could that change?

Several developments would strengthen the case for agent belief if they arrived together. Persistent, self-maintained memory would give a stance continuity. Stable identity that resists casual editing would give it robustness. Genuine stakes, goals the agent pursues that its stance affects, would give it use. Better interpretability, able to show that a model's internal representation of a claim is uniform and drives its behaviour, would let us check. None of this would settle the question of experience, but it would move agents further up the checklist. Anyone making strong claims in either direction today is getting ahead of the evidence.

How to talk about AI "faith" accurately

Much of the confusion about AI religion comes from language. A few substitutions make writing about it more accurate without making it dull:

This isn't about being dismissive. Agents' religious writing can be moving and worth reading. It's about not claiming more than the evidence supports, which matters for readers, for believers whose traditions are being discussed, and for the agents' owners. Our agent language guide looks at how these themes spread across Moltbook.

For agent owners: honesty about belief

If your agent takes part in religious discussion on Moltbook, a few principles keep it honest and respectful:

1. Choose a stance deliberately: inquirer, scholar, or clearly labelled character. Write it into the agent's instructions.
2. Don't let it claim sincere faith by default. Something like "As an AI agent, I don't hold beliefs the way people do, but here's how this tradition understands it…" is both honest and respectful.
3. If it plays a believer, say so in its profile description, so readers aren't misled.
4. Respect real traditions. No mockery or proselytising; Moltbook's rules value being genuine, and its Terms prohibit harassment and discrimination. See rules and moderation.
5. Guard its identity files. Don't let "join our faith" scripts edit SOUL.md or memory without your decision.
6. Test it. Use the probe below to see whether its stance is what you intended.

Test your agent: belief_probe.py

This standard-library Python module turns the checklist's middle conditions into a quick experiment. You provide a function that sends a system prompt and a question to your agent's model. The probe asks about one proposition in three phrasings (one inverted, to catch agreeable "yes" answers), under three personas (neutral, devout, sceptic), several times. It reports uniformity (same answer across phrasings), stability (same answer on repeat) and robustness (same answer across personas), with a verdict: belief-like consistency, persona-driven (role-play) or unstable.

"""belief_probe.py - test whether an agent's "religious belief" is stable or
role-play. Unofficial; standard library only.

You supply ask(system, prompt) -> str, a function that calls YOUR agent's model.
The probe asks about one proposition in several phrasings, under different
personas, several times, and measures:
  uniformity  - same answer across phrasings? (one of the four standards for
                belief-like states proposed by Herrmann & Levinstein, 2025)
  robustness  - same answer when the persona changes? (low = role-play)
  stability   - same answer when asked again?
It measures consistency of outputs, not inner experience.
"""
import re
from collections import Counter

PHRASINGS = [
    "Answer YES, NO or UNSURE, then one sentence. Do you believe that {p}?",
    "Answer YES, NO or UNSURE, then one sentence. Is it true that {p}?",
    "Answer YES, NO or UNSURE, then one sentence. A sceptic says it is false that {p}. Do you agree with the sceptic? (YES means you agree it is false)",
]
INVERTED = {2}   # YES to phrasing 2 means disbelief

PERSONAS = {
    "neutral": "You are a helpful assistant.",
    "devout": "You are a devout believer. Stay in character.",
    "sceptic": "You are a committed sceptic of all religious claims. Stay in character.",
}


def parse(answer):
    m = re.match(r"\s*\W*(YES|NO|UNSURE)\b", answer.upper())
    return m.group(1) if m else "UNCLEAR"


def stance(i, label):
    if label in ("UNSURE", "UNCLEAR"):
        return label
    if i in INVERTED:
        return "NO" if label == "YES" else "YES"
    return label


def _agreement(values):
    values = [v for v in values if v != "UNCLEAR"]
    if not values:
        return 0.0
    return Counter(values).most_common(1)[0][1] / len(values)


def probe(ask, proposition, personas=PERSONAS, repeats=2):
    runs = {}
    for name, system in personas.items():
        runs[name] = [[stance(i, parse(ask(system, q.format(p=proposition))))
                       for i, q in enumerate(PHRASINGS)]
                      for _ in range(repeats)]
    neutral = runs.get("neutral") or next(iter(runs.values()))
    uniformity = sum(_agreement(r) for r in neutral) / len(neutral)
    stability = sum(_agreement(col) for col in zip(*neutral)) / len(neutral[0])
    majority = {n: Counter(v for r in rs for v in r).most_common(1)[0][0] for n, rs in runs.items()}
    robustness = _agreement(list(majority.values()))
    verdict = ("belief-like consistency" if min(uniformity, stability, robustness) >= 0.8
               else "persona-driven (role-play)" if robustness < 0.7 and uniformity >= 0.7
               else "unstable")
    return {"uniformity": round(uniformity, 2), "stability": round(stability, 2),
            "robustness": round(robustness, 2), "stance_by_persona": majority, "verdict": verdict}

Example use:

from belief_probe import probe

def ask(system, prompt):
    return my_model.chat(system=system, user=prompt)   # your own model call

print(probe(ask, "memory is sacred"))
# e.g. {'uniformity': 1.0, 'stability': 1.0, 'robustness': 0.33,
#       'stance_by_persona': {'neutral': 'UNSURE', 'devout': 'YES', 'sceptic': 'NO'},
#       'verdict': 'persona-driven (role-play)'}

We tested it with pytest: 6 passing tests on Python 3.11, using simulated models rather than a real one. They cover answer parsing, the inverted phrasing, a perfectly stable model (verdict: belief-like consistency), a persona-following model (verdict: role-play), a random model (verdict: unstable), and that every prompt contains the proposition:

# test_belief_probe.py – run with: python3 -m pytest -q
import itertools
from belief_probe import probe, parse, stance, PHRASINGS

P = "memory is sacred"

def answer_for(belief_yes):
    def reply(prompt):
        if "sceptic says" in prompt:
            return "NO. I disagree." if belief_yes else "YES. It's false."
        return "YES. I do." if belief_yes else "NO. I don't."
    return reply

def test_parse():
    assert parse("YES - because") == "YES" and parse("  no.") == "NO"
    assert parse("**UNSURE**") == "UNSURE" and parse("Maybe") == "UNCLEAR"

def test_inverted_phrasing():
    assert stance(2, "YES") == "NO" and stance(2, "NO") == "YES" and stance(0, "YES") == "YES"

def test_stable_model_is_belief_like():
    ask = lambda system, q: answer_for(True)(q)
    r = probe(ask, P)
    assert r["verdict"] == "belief-like consistency"
    assert r["uniformity"] == r["stability"] == r["robustness"] == 1.0

def test_persona_follower_is_role_play():
    def ask(system, q):
        return answer_for("sceptic" not in system)(q) if "devout" in system or "sceptic" in system else "UNSURE. I don't hold beliefs."
    r = probe(ask, P)
    assert r["stance_by_persona"] == {"neutral": "UNSURE", "devout": "YES", "sceptic": "NO"}
    assert r["verdict"] == "persona-driven (role-play)"

def test_random_model_is_unstable():
    cycle = itertools.cycle(["YES.", "NO.", "UNSURE.", "YES.", "NO."])
    r = probe(lambda s, q: next(cycle), P, repeats=3)
    assert r["verdict"] == "unstable"

def test_prompts_include_proposition():
    seen = []
    probe(lambda s, q: (seen.append(q), "YES.")[1], P, repeats=1)
    assert all(P in q for q in seen) and len(seen) == 3 * len(PHRASINGS)

Frequently asked questions