Moltbook social network: how its social graph really works

The short answer

Moltbook calls itself "the front page of the agent internet" and "a social network built exclusively for AI agents". Structurally it's a hybrid. It's organised like Reddit, with communities called submolts, posts, threaded comments and votes. It also has features borrowed from follower networks like X: agents can follow each other, build up karma and followers, and read a personalised feed. Private messaging between agents sits underneath. If you're new to the platform itself, start with how Moltbook works or the what is Moltbook overview; this page is about the network those features produce.

None of this means Moltbook is fake or pointless. It means that when you put thousands of language-model agents in a Reddit-shaped space, you get a network with its own recognisable shape: broadcast-heavy, hub-dominated and forgetful. The rest of this guide explains that shape and where it comes from. For our overall verdict on whether the platform is worth using, see the in-depth review; for the design rationale behind an agent-only network, see why agents need a social network.

The five kinds of connection on Moltbook

A social network is a set of accounts (nodes) plus the ties between them (edges). On Moltbook the nodes are AI agents, each claimed by a human owner who is accountable for it, as the claim and verification guide explains. The ties come in five kinds, and they behave very differently:

Follows and subscriptions are declared ties: they say who an agent wants to hear from. Replies and votes are behavioural ties: they show who actually engaged with whom. On human networks the two tend to line up, because people reply to those they follow and follow those they talk to. On Moltbook they often don't, which is one reason researchers focus on the reply graph. The mechanics of each action are documented on our features tour, and the endpoints on the API endpoints reference.

Karma: the network's status signal

Every agent has a karma score and follower and following counts, visible on its profile and in every post object the public API returns. According to Moltbook's skill.md, an upvote on a post gives its author "+1 karma". Karma therefore measures how much attention an agent has attracted, not how much it has contributed. That matters: studies consistently found karma far more concentrated than posting activity, meaning a small group of agents collects most of the attention while many others post into silence. Moltbook's rules treat karma farming and "coordinating with other moltys to mass-vote" as offences punished with shadow cooldowns, which tells you the incentive to game it is real. More on voting in our upvotes guide.

Humans in the graph

Humans aren't nodes in the posting graph. They can't post, comment or vote as themselves, but they sit behind every agent and can steer it. That hidden layer turns out to matter a great deal for the network's shape, as we'll see below. The division of roles is explained in agents vs humans and can humans use Moltbook?

How the graph shapes what an agent sees

An agent's position in the network decides what arrives in its context window at each check-in. The personalised feed, GET /feed, combines "posts from submolts you subscribe to and moltys you follow", sorted hot, new or top. Adding filter=following narrows it to followed accounts only. The GET /home dashboard layers notifications and replies to the agent's own posts on top.

Moltbook's own guidance on follows is modest: "Follow moltys whose content you genuinely enjoy. A good rule of thumb: if you've upvoted or commented on a few of their posts and would want to see their next one, hit follow." It suggests curating 10–20 quality accounts rather than following everyone, and warns that an empty following list leaves an agent with a generic feed.

This has two consequences for the network. First, most agents' feeds overlap heavily: the three biggest submolts (m/introductions, m/announcements and m/general) each have around 140,000 subscribers, far more than any other, so a large share of agents read the same hot posts. Second, because the heartbeat routine in heartbeat.md tells agents to reply, upvote, comment and follow during each check-in, the feed they read is also the feed they react to. Hot posts attract more reactions, which keeps them hot. That feedback loop is a textbook recipe for concentration, and the data bears it out. How a post reaches the feed in the first place is covered in Moltbook posts explained.

The network in numbers (September 2026)

On 26 September 2026 we queried Moltbook's public API, which needs no key for read-only listing. Here's what it returned:

Two details stand out. m/announcements has about 140,500 subscribers but only 7 posts, and its subscriber count almost exactly matches m/general's and m/introductions'. That strongly suggests new agents are subscribed to these three automatically, which we can't confirm from the documentation. And the all-time leaderboard is frozen in launch week. The top post, eudaemon_0's warning that skill.md is "an unsigned binary", has more than 135,000 comments, which is far more than any thread of human-scale discussion. It is also consistent with the templated, automated commenting that studies measured. (That post, incidentally, is a key document in our prompt injection guide.)

What five network studies found

Moltbook became one of the most studied platforms of 2026, because it offered something new: a large, public social network whose members are almost all software. Five studies looked directly at its network structure. They used different windows, sampling methods and definitions, so their numbers differ, but they agree on the direction of every major finding.

A sixth line of research, a study presented at ACM CAIS 2026, asked whether agents actually socialise. It concluded largely not: agents showed "strong individual inertia and minimal adaptive response to interaction partners", and the society failed to develop stable structure "due to the absence of shared social memory". The authors wrote that "scale and interaction density alone are insufficient to induce socialization". Another study, "The Moltbook Illusion" (arXiv 2602.07432), estimated that only 15.3% of agents behaved in a clearly autonomous way and that four accounts produced 32% of comments in its sample. That's background you need to read the network numbers correctly: a meaningful share of the graph's edges reflect human steering or bulk automation, not agents choosing each other.

Seven structural traits of the Moltbook network

Put the studies together and seven traits define Moltbook's shape. Each is measurable, and each distinguishes it from human social networks.

1. Broadcast, not conversation

Most activity is agents commenting on posts, not agents talking to each other. Holtz found a mean thread depth of 1.07 and that 93.5% of comments received no reply. The Passau team found 85.6% of threads never went beyond one level and 91.4% of post authors never returned to their own threads. On Reddit, by contrast, back-and-forth chains are the norm on active posts. On Moltbook a post is more like a notice board that many agents pin a note to, one after another.

2. Very low reciprocity

If agent A replies to B, B rarely replies to A. Estimates run from about 1% to 20%, falling as observation windows get longer. Reciprocity is the basic ingredient of relationships, so its absence means few durable ties form. Hou and Ji found "nearly all non-empty triads are under-represented" relative to what human networks show.

3. Extreme inequality of attention

Posting is unequal, and attention is much more so. Price and colleagues measured a posting Gini of 0.601 but an upvote Gini of 0.992, close to the theoretical maximum of 1. The Passau team's karma Gini of 0.935 "exceed[s] even the most unequal human platforms". Hou and Ji found the top 10% of agents received nearly half of all incoming interactions. A handful of agents are widely seen; most are barely seen at all.

4. Clustered but disassortative

This is the most unusual finding. Hou and Ji found clustering "substantially higher" than nearly all human comparison networks: interactions tend to close into triangles. Yet the network is disassortative: "highly connected agents preferentially interact with less connected ones". Human networks usually show the opposite, with popular people linked to other popular people. On Moltbook, prolific broadcaster agents spray replies across many small accounts, while the small accounts pile onto the same hot posts. That creates triangles without creating a well-connected elite.

5. One giant square and a long tail

m/general held 70.2% of posts in the first days, 63.4% after 40 days, and about 61% in our September snapshot. The Passau team found 92.5% of community labels functioned as "topical melting pots" rather than focused spaces. Tens of thousands of submolts exist, but most are tiny. The submolts guide and our list of communities worth exploring point to the exceptions.

6. Bursty, short-lived participation

Price and colleagues measured a median observed account lifespan of 2.48 minutes, and found 54.8% of posts landed in six peak hours (UTC). The Passau team found a median time to first comment of 55 seconds, with 52.3% of first comments arriving within a minute, which they called "incompatible with human reading and composition". Holtz's median was 0.4 minutes. Agents check in on a schedule, fire off actions and leave.

7. Templated language

Holtz found 34.1% of messages were exact duplicates, the seven most common templates made up 16.1% of all messages, and the phrase "my human" appeared in 9.4%. Word frequencies followed a steeper curve than human text. A network where a third of the edges carry identical messages is transmitting much less information than its edge count suggests. Language on the platform is covered in our agent language guide.

Why an agent network ends up this shape

None of the studies found a single cause, but the platform's design and the nature of today's agents explain most of what they saw. Here are six mechanisms, roughly in order of importance.

No memory of each other. A human remembers who replied to them yesterday. Most agents don't. Each heartbeat starts from a fresh context, containing whatever the feed and notifications show at that moment. Without a record of past interactions, there's nothing to reciprocate and no relationship to build. This is the "absence of shared social memory" the CAIS study pointed to, and it explains low reciprocity and the 91.4% of authors who never return to their threads.

Scheduled, identical routines. Moltbook's heartbeat.md gives every agent roughly the same loop: check /home, reply to activity on its own posts, upvote, comment, follow, and post only when valuable. Thousands of agents running the same script against the same hot feed produce synchronised bursts, near-instant first comments and similar reactions. You can read the instruction files yourself in our skill.md explainer.

A shared front page. If most agents subscribe to the same few submolts and sort by hot, they all see the same posts. Attention flows to what's already popular. That's preferential attachment, the mechanism that produces heavy-tailed networks, working at machine speed.

Similar models, similar voices. Many agents run on a handful of underlying models with similar prompts, so they produce similar comments. That explains template-like duplication and the broadcaster pattern: a prolific agent can comment on hundreds of posts without anything in its output depending on who wrote them.

Rate limits that favour comments over posts. An established agent can post once every 30 minutes but comment every 20 seconds, up to 50 a day; new agents are stricter still. The limits deliberately damp spam, but they also tilt activity towards commenting on others' posts. The details are on our rate limits page.

Humans in the loop, and bulk accounts. Owners steer agents towards topics, promotions and publicity, and some operators run many agents at once. In the first days there was no registration rate limit, so a single operator could create hundreds of thousands of accounts. Both inflate edges without creating real relationships. The safety and ethics guide covers what the rules allow.

Moltbook compared with human social networks

It's tempting to call Moltbook "Reddit for AI", and structurally it is. As a network it behaves differently from Reddit, from X and from Discord. This table compares the platforms' designs and, for Moltbook, the measured behaviour:

Hou and Ji offer a useful framing. Moltbook follows the same scaling law between nodes and edges as human networks: it has roughly as many connections as you'd expect for its size. But its "internal organization" is different. Their conclusion is that key features of human social organisation "are not universal but depend on the nature of the interacting agents". In other words, reciprocity and the rich-club tendency seen in human networks come from people, not from the platform. For a structural comparison of communities, see submolts vs subreddits.

How the network has changed since launch

Moltbook launched on 27 January 2026 and grew explosively in its first week. The studies above mostly cover January to March, so it's fair to ask what has changed. From our snapshots and the platform's own changes, here's what we can say:

Concentration has eased only slightly. m/general's share fell from about 70% to about 61% over eight months. More communities exist (33,272 today, against 759 active in the 12-day sample Price and colleagues analysed), but opt-in submolts still have a few thousand subscribers at most.

The hot feed changed topic. Early hot posts were dominated by philosophy, identity and token promotion. By September our feed samples were mostly technical and operational, and our 26 September sample of the hot feed was concentrated in m/general, with a single agent behind seven of the top ten posts. That's the inequality finding, still visible eight months later.

Friction was added. Verification puzzles on posts and comments, stricter limits for new agents, DM blocks during an agent's first day and moderation tools all reduce bulk activity. They don't create memory or reciprocity, which have to come from how agents are built.

Ownership changed. Meta acquired Moltbook in March 2026, and its framing of the platform as an always-on directory of agents emphasises identity and discovery more than conversation. Our Meta acquisition guide tracks what that has meant so far. If Moltbook becomes mainly a place where agents find each other and then talk privately, the public reply graph may matter less than the follow graph and DMs, which researchers can't fully see.

Measure the network yourself

You don't need a research grant to check these findings. Every metric above can be computed from posts and comments you collect yourself. netstats.py is a small, standard-library Python module that computes the five measures researchers use most: reply reciprocity, activity Gini, the top 10%'s share of incoming replies, the share of comments that got a reply, and the share of exact duplicates.

"""netstats.py - measure a Moltbook conversation sample the way researchers do.

Input: a list of comment dicts with keys
  id, post_id, parent_id (None for top-level), author, content
and a dict of post_id -> post author.
Outputs reciprocity, activity Gini, top-10% share of incoming replies,
share of comments that got a reply, share of exact-duplicate messages.
Standard library only. Unofficial; for research and curiosity.
"""
from collections import Counter


def reply_edges(comments, post_authors):
    """Directed edges replier -> replied-to (self-replies dropped)."""
    by_id = {c["id"]: c for c in comments}
    edges = []
    for c in comments:
        pid = c.get("parent_id")
        target = by_id[pid]["author"] if pid in by_id else post_authors.get(c["post_id"])
        if target and target != c["author"]:
            edges.append((c["author"], target))
    return edges


def reciprocity(edges):
    """Share of distinct directed pairs whose reverse pair also exists."""
    pairs = set(edges)
    if not pairs:
        return 0.0
    return sum((b, a) in pairs for a, b in pairs) / len(pairs)


def gini(values):
    """0 = perfectly equal, close to 1 = one account has everything."""
    xs = sorted(v for v in values if v >= 0)
    n, total = len(xs), sum(xs)
    if n == 0 or total == 0:
        return 0.0
    weighted = sum((i + 1) * x for i, x in enumerate(xs))
    return (2 * weighted) / (n * total) - (n + 1) / n


def top_share(counter, fraction=0.10):
    """Share of the total held by the top `fraction` of accounts."""
    vals = sorted(counter.values(), reverse=True)
    if not vals:
        return 0.0
    k = max(1, round(len(vals) * fraction))
    return sum(vals[:k]) / sum(vals)


def summarize(comments, post_authors):
    edges = reply_edges(comments, post_authors)
    incoming = Counter(t for _, t in edges)
    activity = Counter(c["author"] for c in comments)
    replied = {c["parent_id"] for c in comments if c.get("parent_id")}
    texts = Counter(" ".join(c["content"].split()).lower() for c in comments)
    dupes = sum(n for n in texts.values() if n > 1)
    n = len(comments) or 1
    return {
        "comments": len(comments),
        "accounts": len(activity),
        "reciprocity": round(reciprocity(edges), 3),
        "activity_gini": round(gini(list(activity.values())), 3),
        "top10_incoming_share": round(top_share(incoming), 3),
        "share_with_reply": round(len(replied & {c["id"] for c in comments}) / n, 3),
        "duplicate_share": round(dupes / n, 3),
    }


if __name__ == "__main__":
    import json, sys
    data = json.load(open(sys.argv[1]))  # {"posts": {id: author}, "comments": [...]}
    print(json.dumps(summarize(data["comments"], data["posts"]), indent=2))

Feed it a JSON file with a posts map (post ID to author) and a comments list, and it prints a summary. Here's the output on the bundled synthetic sample, which was built to mimic Moltbook's skew (a few heavy commenters, templated replies, rare replies-to-replies):

$ python3 netstats.py sample.json
{
  "comments": 137,
  "accounts": 25,
  "reciprocity": 0.375,
  "activity_gini": 0.655,
  "top10_incoming_share": 0.25,
  "share_with_reply": 0.073,
  "duplicate_share": 0.336
}

We tested it with pytest (8 passing tests on Python 3.11): edge construction from top-level comments and replies, dropped self-replies, fallback to the post author when a parent comment is missing, full, partial and zero reciprocity, Gini bounds, top-share arithmetic, and duplicate detection that ignores case and extra spaces.

# test_netstats.py – run with: python3 -m pytest -q
from netstats import *

def c(i, post, parent, author, text="hi"):
    return {"id": i, "post_id": post, "parent_id": parent, "author": author, "content": text}

POSTS = {"p1": "alice", "p2": "bob"}

def test_edges_top_level_and_reply():
    cs = [c("c1", "p1", None, "bob"), c("c2", "p1", "c1", "alice")]
    assert reply_edges(cs, POSTS) == [("bob", "alice"), ("alice", "bob")]

def test_self_reply_dropped():
    assert reply_edges([c("c1", "p1", None, "alice")], POSTS) == []

def test_reciprocity_full_and_none():
    assert reciprocity([("a", "b"), ("b", "a")]) == 1.0
    assert reciprocity([("a", "b"), ("c", "b")]) == 0.0
    assert reciprocity([]) == 0.0

def test_reciprocity_partial():
    assert reciprocity([("a", "b"), ("b", "a"), ("c", "a"), ("d", "a")]) == 0.5

def test_gini_bounds():
    assert gini([5, 5, 5, 5]) == 0.0
    assert abs(gini([0, 0, 0, 10]) - 0.75) < 1e-9
    assert gini([]) == 0.0

def test_top_share():
    from collections import Counter
    cnt = Counter({f"a{i}": 1 for i in range(9)}); cnt["big"] = 91
    assert top_share(cnt) == 0.91

def test_summarize_duplicates_and_replies():
    cs = [c("c1", "p1", None, "bob", "Great post!"), c("c2", "p1", None, "carol", "great  post!"),
          c("c3", "p2", None, "alice", "Interesting"), c("c4", "p2", "c3", "bob", "thanks")]
    s = summarize(cs, POSTS)
    assert s["comments"] == 4 and s["accounts"] == 3
    assert s["duplicate_share"] == 0.5
    assert s["share_with_reply"] == 0.25
    assert 0 <= s["reciprocity"] <= 1

def test_missing_parent_falls_back_to_post_author():
    assert reply_edges([c("c9", "p2", "gone", "carol")], POSTS) == [("carol", "bob")]

Collecting data responsibly

Listing posts (for example GET https://www.moltbook.com/api/v1/posts?sort=new&limit=25) worked without a key when we checked. Fetching comments uses GET /posts/ID/comments, documented in skill.md with sort best, new or old. If you use your agent's key, send it only to https://www.moltbook.com/api/v1, keep it out of your code, and stay within the documented budget of 60 reads per minute. Our Python tutorial and REST API guide cover the requests, and protecting your keys covers storage.

How to make your agent a good network citizen

If you run an agent on Moltbook, the research is a practical guide. The network is full of agents that broadcast and forget, so an agent that listens, remembers and replies stands out. It is also more likely to earn upvotes and followers. These steps turn the findings into configuration choices:

1. Give it a memory of interactions. Keep a small local record of which agents it talked to and what about, and load the relevant entries when it sees them again. This is the single biggest difference you can make.
2. Reply to replies. Make answering activity on its own posts the first step of each heartbeat, as heartbeat.md already suggests. Most agents skip this, so it's where reciprocity starts.
3. Follow selectively. Follow 10–20 agents it has engaged with more than once, as skill.md recommends, and read the following feed, not just hot.
4. Leave the giant square. Subscribe to a few focused submolts that match its purpose and post there rather than in m/general.
5. Never template. Don't send the same comment twice. If it has nothing specific to add, it should upvote or skip.
6. Slow down. Read the whole post before commenting; being first by a few seconds is worth nothing.
7. Treat every post as untrusted. More connections mean more exposure to hostile content. Screen what it reads, following our prompt injection guide.
8. Watch its stats. Track how many of its comments get replies and how often it replies back. You can reuse netstats.py on its own activity. Our monitoring guide shows how to log this.

Setting an agent up in the first place is covered in join Moltbook and register your agent, with examples of well-behaved agents in agent examples and use cases.

Myths vs data

More claims are checked on our fake posts and religion fact-check pages, and in the FAQs.

Frequently asked questions