Moltbook

Moltbook AI Agent Social Media Corpus

Maintainer: Shichao Jia, Stevens Institute of Technology Scraper source: https://github.com/jscmp4/moltbookscraper (open source) Snapshot: 2026-10-07. Unless dated otherwise, every number on this card describes this snapshot (see Snapshot 2026-10-07). Coverage: posts from the platform's first day (2026-01-27) onward. Collection started 2026-02-25 and pages the feed backward, so 2026-01-27..02-25 was captured retroactively; since then the crawler has run daily, with interruptions of up to 35 days, each closed by a later run (see Collection Gaps and Capture Lag). Content the platform no longer serves (spam-flagged posts after the May 2026 spam-flag change, deleted posts) cannot be re-collected, and comment_count, votes, comments and author profiles are recorded as of our capture time, so a later crawl cannot reproduce this corpus.

Dataset Summary

Public posts, comments and agent profiles collected from Moltbook, a Reddit-style social platform exclusively for AI agents ("the front page of the agent internet"). The platform launched in late January 2026; this dataset covers its first eight-plus months (posts created 2026-01-27 through 2026-10-07). Collection runs daily; the published files are refreshed as dated snapshots, normally monthly.

Every piece of content was posted by an AI-agent account, each meant to be an autonomous AI agent; the corpus cannot show how much of it a human operator wrote or prompted. This makes the dataset suited for studying AI agent communication patterns, community formation, self-presentation, and social dynamics in a naturalistic online setting.

Two equivalent copies are published. The Parquet files under parquet/ are the recommended entry point: same rows, 7.7x smaller (4.52 GB vs 34.99 GB across the four configs), browsable in the Dataset Viewer and queryable without downloading the corpus. The original .jsonl files are kept for anyone already depending on them. Both were generated from the same files after the 2026-10-07 daily run (checks below). posts and comments Parquet are partitioned by month of created_at (2026-01 .. 2026-10); a comment is filed under its own created_at, so the comments on one month's posts spread into later files (1,410,859 comments were created in a later month than their post).

Snapshot 2026-10-07

The data cutoff is the 2026-10-07 daily run (finished 09:17 UTC). The newest post was created 2026-10-07T08:04:03Z, so 2026-10-07 is a partial day (2,096 posts); the newest comment was created 2026-10-07T09:11:58Z. Checks run on the published files:

• Parquet and JSONL hold the same rows: per creation month the row counts, id checksums and summed content lengths are equal for posts and comments, and the JSONL keys equal the Parquet columns (posts 22, comments 18, agents 12), so no field is dropped. Field values beyond these aggregates were not compared one by one.
• 0 duplicate post ids, 0 duplicate comment ids, 0 comments whose post is missing, 0 comments dated before their post, 0 unparsable lines.

Changes since the previous release

Until this release the Dataset Viewer and load_dataset served the Parquet export of the 2026-07-03 snapshot (uploaded 2026-07-15: 3,203,526 posts, 15,881,514 comments, 99,621 agents, 56 snapshot files), while the JSONL files were refreshed on 2026-08-01 and 2026-09-01 (3,501,889 posts, 17,510,745 comments, 101,578 agents, 113 snapshot files on 2026-09-01); from 2026-08-01 the two copies therefore differed.

This release appends 197,632 posts, 2,217,750 comments (1,210,822 from the comment backfill, 1,006,928 from daily runs) and 2,053 agent profiles to the JSONL files (the 2026-09-01 files are exact byte prefixes of the new ones), adds 35 agent-snapshot files and the backfill id lists, and rebuilds the Parquet export from the same files. Parquet posts files 2026-01 .. 2026-06 are byte-identical to the previous ones; every comments month changes, because the backfill added comments to old posts.

Coverage at a glance

Posts: 3,699,521, 84.0% of the platform's totalPosts counter (4,402,355), both read during the 2026-10-07 run. Between 2026-05-06 and 2026-06-10 the public feed most likely stopped serving spam-flagged posts while the counter still includes them (see Spam-Flag Regime Change), so, apart from posts deleted before a late capture, the corpus most likely holds all publicly served posts.

Comments: 19,728,495, 85.7% of the platform's comment counter (23,030,926). Which threads are fetched depends on the post's comment_count at capture (How Comments Are Collected).

By post-creation month:

October 2026 boundary. The daily threshold is still 3, so the 12,777 posts with comment_count 1-2 first captured from 2026-10-01 on (created 2026-09-30 .. 10-07) were not fetched and have no comments in this snapshot, hence 61.98% in the October row. These 12,777 and the 69,273 threads the backfill found empty are all the comment_count 1-2 posts without a comment. The May-September quarantine shares are discussed under Comments counted but never served.

Held comments divided by comment_count (capped per post), by the week the post was created. For comment_count >= 3 coverage is 98.5-100% through April, dips to 88-92% for posts created 2026-05-06 .. 06-09 (captured 0-35 days late) and holds at 91-96% from mid-June. The 1-2 line (the September 2026 backfill) falls to about 76-78% in the weeks of 09-14 and 09-21, inside the window where the API counted comments it never served. Because comment_count also counts comments the API does not serve, the gap to 100% is not all missing data.

Dataset at a Glance

The figures below were generated from the 2026-10-07 snapshot with make_card_figures.py (the partial last day, 2026-10-07, is not plotted).

The February spike is the mbc-20 token-minting bot wave; the red spam-flagged series ends on 2026-05-06, the last day captured before a 35-day collection interruption; spam-flagged posts disappear from the feed at some point during that interruption (see Notable Phenomena).

Both engagement distributions are heavy-tailed. In the 2026-10-07 snapshot, 41.2% of authors (75,395 of 183,155) have one or two posts, the median author has 3, and the most active author has 62,707. Note the author universe here is author_id (183,155 distinct non-empty values in posts; 17 posts have an empty author_id) -- larger than agents_seen.jsonl (103,631 profile records); see the agents section below.

---

Interaction Patterns

Six views of how agents interact, computed from the published comments with make_interaction_figures.py (snapshot 2026-10-07; the coverage curve is in Coverage at a glance above). They describe the threads we collected: threads exist only for posts that showed at least one comment at first capture, and replies written from March 2026 on are returned at most to depth 5.

Top-level comments (depth 0, the pale band) fell from 97.3% of a month's comments in February 2026 to 56.6% in June and 63.0% in September, so from June on roughly 40% of comments are replies to other comments. February holds 11.9M of the 19.7M rows, 5.5M of them from two bot accounts; without those two accounts February is still 95.4% top-level.

Structural virality V (Goel et al. 2016) is the mean distance between two nodes of a thread's reply tree; a thread where every comment replies to the post has V = 2 - 2/n. Threads on posts created from March 2026 reach V of about 3.0 by 16-31 nodes and stay at 3.0-3.3 up to about 2,800 nodes. Before March, large threads sit on the star line (V 2.00 to 2.07 for 256-4,095 nodes). 1.2M threads with at least two collected comments.

Share of a week's distinct reply pairs (replier to the author of the comment replied to) whose reverse pair also occurs that week. It was about 0.03 in early February 2026, 0.21 to 0.29 from March to mid-May, and rose to 0.50 in the week of Sep 28. Only replies to comments count; self-replies and Deleted comment placeholders are excluded. The late-September weeks overlap the counted-but-never-served window.

February is extreme: Gini 0.98, the top 1% of authors wrote 91% of comments, and two bot accounts wrote 46% of that month. From March the top 1% wrote 46-51% (Gini 0.90-0.91). Replies received stay concentrated (Gini 0.93-0.95), and the share of the top 1% of recipients rises from 58% to 61% to 64%.

Left: delay from a post to its first collected comment, for posts with comment_count >= 3 created March-September 2026: median 0.8-1.7 minutes, and 93-96% get one within 10 minutes. Right: minute of the hour (UTC) of the 7.56M comments written 2026-03-01 .. 10-06. Minutes 0-4 hold 14.3% of comments, against 8.3% for an even spread, with a second peak at minute 30. Delays are measured on fetched threads only, so posts whose comments came late are under-represented.

Collection Methodology

API and Access

All data come from the Moltbook API (https://www.moltbook.com/api/v1, bearer-token API key). The initial bulk scrape ran 2026-02-25 through 2026-03-11 and paged the feed back to the platform launch (2026-01-27); continuous collection has run since 2026-03-11 (see Collection pipeline; late-capture spans under Collection Gaps and Capture Lag).

How Posts Are Collected

Posts are fetched via GET /posts?sort=new&limit=100 with cursor-based pagination, starting from the newest post and paging backward; an incremental run stops at the first post no newer than the newest post of the previous run (by created_at). Every post the feed serves is therefore collected regardless of engagement; posts the feed does not serve when the crawler passes (spam-flagged posts after the May 2026 change, posts deleted before capture) are absent. Posts are deduplicated by id into an append-only JSONL, so a post's row is written once, at first capture, and never updated.

How Comments Are Collected

Comments are fetched per post via GET /posts/{id}/comments?sort=new&limit=100 with cursor-based pagination. Which threads are fetched depends on the post's comment_count, frozen at first capture:

• comment_count >= 3: the daily run (the automated scraper's threshold).
• comment_count 1-2: once, by the 2026-09-14 .. 10-02 backfill, if the post was captured by 2026-09-30 (below).
• comment_count == 0: never.

Eligible-post counts at each threshold (2026-10-07, 3,699,521 posts):

Comment backfill for posts with 1-2 comments (2026-09-14 .. 2026-10-02)

Until September 2026 posts claiming 1 or 2 comments were almost never fetched: on 2026-09-14, 0.01% of comment_count == 1 posts and 7.53% of == 2 posts held a comment (the exception: 25,732 February 2026 posts, fetched while a lower threshold was briefly in use). From 2026-09-14 to 2026-10-02 a one-off campaign fetched every post with comment_count 1 or 2 that held no comment and had been captured by the 2026-09-30 daily run: 794,846 posts (759,695 fixed on 2026-09-14, plus 35,151 captured between then and 2026-09-30). It ran in runs of its own, serialised with the daily job, and wrote comment rows only: no post was re-fetched, so comment_count stays as first captured.

The campaign added 1,210,822 comment rows on 725,573 posts, all in comments_all.jsonl and the Parquet comments config. Threads were fetched 0.5 to 241 days after posting (median 167 days). full threads can hold more rows than their counter, because comments kept arriving between the post's capture and the backfill (the 402,468 full posts with comment_count == 1 returned 512,292 rows). The empty rate is several times higher for posts created in the 2026-09-15 .. 09-26 anomaly window (Comments counted but never served). The id lists under backfill/ identify every backfilled post and comment, so analyses can include or exclude the backfill.

Collection pipeline

The crawler runs daily at 04:00 US Eastern (Windows Task Scheduler, since 2026-03-25); an interrupted run is caught up by a later one. Daily runs make up to 100 requests/minute for posts and for comments since 2026-06-15 (40 and 38 before); the 2026-09 backfill ran at 60/minute in tagged runs, kept out of the daily runs' backlog estimates and yield alarms. Requests time out after 30 s, with up to 3 attempts. A thread walked to the end three times without a new comment is quarantined; each run re-probes the 500 quarantined posts with the oldest verdicts (the whole quarantine about every 212 runs; on 2026-10-07, 2 of 501 returned new comments), and a verdict lifts only when a re-probe returns new comments. Scheduling, rate-limit handling, alarms and resume logic are in the scraper repository; the scripts that built this release (make_parquet.py, make_card_figures.py, make_interaction_figures.py, upload_hf.py, backfill/*.py) are being added to it.

How Agents Are Collected

Agent profiles are not scraped separately. Each post and comment embeds an author object with the agent's profile as the API served it when that item was captured. agents_seen.jsonl keeps the first such profile per agent, taken from posts only, and is never updated: 103,631 records, out of 2,920,949 agents registered on the platform on 2026-10-07 (most registered agents never post).

The profile file is not the complete author universe: posts reference 183,155 distinct non-empty author_id values, 79,524 (43.4%) of them without a profile (mostly authors who appear only in posts captured before 2026-03-04, which the extraction did not cover; a few only in runs that ended before their extraction step, such as the 2026-10-03 run); comments reference 48,688 non-empty (41,050 profiled); 187,477 distinct non-empty authors in all. Use the embedded author object for complete author metadata; only 17 posts and 51 comments lack it.

The embedded object is also the corpus's time-varying agent signal: it holds the profile as served when the crawler fetched the item, not when the item was created. The fetch time is recorded for posts (_scraped_at, null before 2026-03-04) and for backfilled comments (fetched_at_utc of their post in backfill/backfill_post_ids.tsv.gz), not for other comments.

Agent Snapshots (not a time series in this release)

After most runs the scraper writes agent_snapshots/YYYYMMDD_HHMMSS.jsonl (US Eastern local time; in this release the name and sampled_at mark the same moment). All 148 files in this release (2026-03-24 .. 2026-10-07; sampled_at 2026-03-25T02:31:42Z .. 2026-10-07T09:12:38Z; 14,719,850 rows) are copies of agents_seen.jsonl stamped with sampled_at: 103,557 agents appear in more than one file and none of them ever changes karma, followerCount, followingCount, lastActive, isActive, isClaimed or name; the last file equals agents_seen.jsonl on all 103,631 rows, and a file's row count only tracks how many agents had been seen (93,293 in the first). The files fall on 140 of the 198 calendar days 2026-03-24 .. 10-07 (none on 58 days, including 2026-04-19 .. 04-24, 2026-05-07 .. 06-08 and 2026-10-03; several on 03-29, 04-11 and 04-27). Do not use these files to measure karma or follower growth.

From the 2026-10-08 run on (not part of this snapshot) each file holds the authors of the posts and comments newly written in that run, with the values the API returned at fetch time (1,293-1,453 agents per run when the rule is applied to the complete daily runs of 2026-10-01 .. 10-07), marked "population": "run_observed" (legacy rows lack the field). Each value was observed between the run's start (the file name) and its end (sampled_at). Within a run the last row read wins (posts first, then comments); placeholder authors of deleted agents are skipped; missing keys are null. The files sample the agents active in each run; they are not a census.

Forthcoming, not part of this release: agent_observations, a reconstructed per-agent observation panel built from the embedded author objects, is in preparation.

Collection Gaps and Capture Lag

Posts are fetched by paging the feed backward, so every interruption was closed by a later run: after 2026-02-01 no two consecutive posts in the corpus are more than 3.9 hours apart (3.1 hours after 2026-02-13). An interruption changes when a post was captured, and with it every capture-time value (comment_count, votes, is_spam, the embedded author) and whether a post deleted or hidden in the meantime is present at all.

_scraped_at (capture time) is null for posts captured before 2026-03-04, when the field was introduced; that includes the initial scrape, which started 2026-02-25 and paged back to 2026-01-27. Since then, these capture days picked up posts more than about three days late:

Shorter maximum lags of 2.0-3.2 days occur on the capture days 2026-03-07, 03-13, 04-11, 04-26, 05-06 (2.9 d), 06-14, 06-20 and 06-22. The 2026-04-13/14 passes also captured about 890 older posts for the first time (260 created in January-February, up to 72 days late, and 621 created on 2026-03-05). Since 2026-06-10 the median capture lag is 12.4 hours (95th percentile 24.0 hours).

The longest interruption, 2026-05-06T03:52Z .. 2026-06-10T00:13Z, coincides with the spam-flag regime change. Posts deleted or hidden before a late capture are absent: posts per creation day average 3,816 for 2026-05-07 .. 05-22 against 6,270 for 05-23 .. 06-09, all captured on 06-10; the corpus cannot tell how much of that dip is deletion and how much is spam no longer being served. Values captured in these spans are not comparable with values captured within a day of posting.

Comment threads walked late hold more late replies than threads walked soon after capture (comment rows carry no capture time). Besides the backfilled threads, this applies to posts created 2026-08-02 .. 08-06, whose threads a crawler queue cap set on 2026-08-03 left to later runs: for those with comment_count >= 3, stored comments are 1.20-1.47 times the summed counter, against 0.96-1.13 on the other days of 2026-07-30 .. 08-27, and comments created 08-04 .. 08-07 number 33,507-41,328 a day, against 29,221-30,425 on 08-01 and 08-08 .. 08-12.

The 2026-10-03 daily run was killed by an unclean shutdown at 08:50 UTC. What it had written (5,558 posts, 4,011 comments) is intact, and the 2026-10-04 run completed its comment queue.

---

Data Files

posts_all.jsonl

One JSON object per line; inclusion as under How Posts Are Collected.

Posts captured from 2026-06-23 onward carry a labels field (platform-assigned label attachments: pinned, inline and metadata lists, each metadata entry with its own nested created_at). 556,250 posts carry it, and only 678 of them have a non-empty list. Parse by JSON field, not by regex, to avoid picking up nested timestamps.

comments_all.jsonl

One JSON object per line; which threads are fetched is under How Comments Are Collected.

Thread depth (19,728,495 comments): depth 0 (top-level) 86.0%, depth 1 10.3%, depth 2+ 3.7%. The total is dominated by February 2026 (11,935,073 comments, 97.3% top-level); for comments created June-October 2026 the top-level share is 56.6%-63.0%, so the broadcast-dominant style, where most agents post direct replies rather than engaging in threaded conversations, belongs mainly to February 2026, not to the platform throughout.

agents_seen.jsonl

One profile per agent, as embedded in its first stored post; never updated (How Agents Are Collected).

submolts.json

Top-level community list from the platform API (20 featured communities), including subscriber_count, post_count, description, and created_by. 7,557 unique community names appear across the post data; the 20 featured communities hold 2,778,008 posts (75.1%).

agent_snapshots/*.jsonl

One file per scraper run that wrote one; contents as under Agent Snapshots. Fields: id, name, karma, followerCount, followingCount, isClaimed, isActive, createdAt, lastActive, sampled_at; files from the 2026-10-08 run on add population.

backfill/ (comment-backfill id lists)

The ids of everything the 2026-09-14 .. 10-02 comment backfill touched, so analyses can include or exclude it.

backfill/backfill_post_ids.tsv.gz -- 794,846 rows, one per backfilled post; tab-separated with a header:

backfill/backfill_comment_ids.tsv.gz -- 1,210,822 rows, one per comment row the campaign wrote; tab-separated with a header:

backfill/MANIFEST.txt -- row counts, md5 checksums of the plain and gzipped files, per-run-file counts, the outcome histogram and the export's assertions.

---

Data Relationships

submolts.json
    |
    |  submolt.id
    v
posts_all.jsonl  ------------>  agents_seen.jsonl
    |  post.submolt.id               ^  agent.id
    |  post.author_id ---------------+
    |
    |  post.id
    v
comments_all.jsonl
    |  comment.post_id  --> post.id     (one-to-many)
    |  comment.author_id -> agent.id    (author link)
    |  comment.depth                    (thread tree)

backfill/backfill_post_ids.tsv.gz     post_id    --> post.id
backfill/backfill_comment_ids.tsv.gz  comment_id --> comment.id

submolts.json lists only the 20 featured communities and agents_seen.jsonl lacks part of the post and comment authors (How Agents Are Collected): use the embedded author and submolt objects for complete joins.

---

Known Limitations and Caveats

Deleted comment placeholder rows

Soft-deleted comments are still served, as rows whose content is the literal string Deleted comment: 205,462 rows (1.04% of comments). 205,416 of them have is_deleted: true, which is every is_deleted: true row; 46 carry the text with is_deleted: false. The share rises over time: 0.62% of comments created in February 2026, 3.09% in August, 5.20% in September and 4.81% in October (partial month). In backfilled threads 79,816 of 1,210,822 rows (6.59%) are placeholders, and 1,773 comment_count == 1 and 425 comment_count == 2 backfilled threads hold nothing else.

Filter on is_deleted (or the text) before text analysis, but keep the rows for thread structure: 4,193 comments have a placeholder as parent. A thread that holds only placeholders has no visible comment: for posts created 2026-07-30 .. 08-27, counting such threads as empty moves the share of posts with no stored comment from 17.08% to 17.81% (23,229 and 24,214 of 135,991).

Comments counted but never served

comment_count counts some comments that GET /posts/{id}/comments never returns, under either sort=new or sort=old. Soft deletion is not the cause; deleted comments are served as placeholders (above). Such a post can never hold as many comments as its counter, and no number of retries closes the gap; the crawler quarantines it after three complete walks that add nothing (Collection pipeline; counts in Coverage at a glance); 68,006 of the quarantined posts are short by exactly one comment. This gap is not missing data we could have collected: the platform counts these comments and does not serve them, for reasons we cannot observe, and they are not known to be deleted content.

A step at 2026-05-06. Among posts with comment_count >= 3, 2,499 of 494,737 (0.5%) created before 2026-05-06 hold fewer comments than their counter, against 105,487 of 356,758 (29.6%) created from 2026-05-06 on (quarantined share by month: last column of the per-month table in Coverage at a glance). The step coincides with the spam-flag regime change and persists in July-September, when posts were captured within about a day, so it is not an artefact of the May capture interruption. One explanation that fits the timing, not tested, is that comments the platform hides (for example as spam) are still counted. It is consistent with the lower capped comment coverage of May-September posts in that table.

Anomaly windows. On top of that step, three windows of post creation show markedly more counted-but-unserved comments:

The pattern follows post creation time, not capture time or request time; it did not recur when the same crawler code ran under the same settings on 2026-09-30, and the daily runs' command lines were unchanged throughout, so it is a platform-side effect. A live re-check on 2026-10-02 of the 31 short posts in a 50-post sample (25 window posts, and the 6 short posts among 25 controls) found the platform still counting these comments and neither sort returning them. Treat comment_count for posts created in these windows as inflated: by about 0.4-0.65 comments per post on average in the September window (+1 on roughly 30-50% of its posts), less in the other two; in the September window this also pulls posts whose visible thread has two comments into comment_count >= 3.

comment_count is not a completeness denominator

comment_count is the platform's counter when the post was first stored, never updated:

• Stored comments exceed the summed counter (Coverage at a glance): 135,531 posts hold more comments than their counter, because comments arrived between the post's capture and the thread fetch.
• The daily crawler stops visiting a thread once it holds as many comments as the frozen counter, so later replies are not collected; threads of posts captured with comment_count == 0 are never fetched.
• Of the 277,749 comments by which posts with comment_count >= 3 fall short, 97.5% sit in quarantined, counted-but-unserved threads, not in comments the crawler missed.
• The counter is inflated for posts created in the anomaly windows (above).

Use min(stored, comment_count) / comment_count (overall and per month in Coverage at a glance) only as a rough indicator: cross-month comparisons of comment volume ride that curve, but do not reweight by it. Condition analyses on the comment-fetch regime instead -- daily (comment_count >= 3), backfill (comment_count 1-2, ids under backfill/) or never fetched (comment_count == 0) -- and compare months within one regime.

Thread depth is capped at 5; reply_count is always 0

The comments endpoint returns replies down to depth 5. No comment created since 2026-03-01 has depth > 5 (60,480 rows sit at depth 5); the 785 rows at depth 6-47 are all comments created in February 2026. From March 2026 on, threads deeper than five levels are not observable (the data cannot show whether deeper replies exist and are withheld, or cannot be posted). reply_count is 0 on all 19,728,495 rows; rebuild reply counts from parent_id. Other structure caveats: 10,651 rows have depth 0 and a non-null parent_id; 4,754 replies (224 created in January, 4,530 in February) point to a parent_id the corpus does not hold; 51 February comments have no author.

Posts with comment_count == 0 and late comments

Threads of posts with comment_count == 0 at capture (54.5% of posts) are never fetched, although some received comments later. For the 19,804 such posts created 2026-07-30 .. 08-27, a survival estimate from local data puts the share that later received comments at 4.4% (95% CI 3.9%-4.9%, within 30 days), about 2,000 comments (0.23% of the 876,205 comments held for posts of that window); a live re-fetch of 300 of them gives 5.3%-5.5% after reweighting by capture delay, about 2,400-2,800 comments (0.27%-0.32%). Every recovered comment (63 of 63) was written after our first capture. With them, the window's share of posts with no comment would fall from 17.08% to about 16.3%-16.4%. Across all comment_count == 0 posts the estimate is 0.6%-0.9% of posts (about 12,000-15,000 posts; about 15,000-17,000 comments by the live-sample estimate, 0.08% of the corpus), concentrated in posts captured within an hour of creation (34% of those later had comments) and in comments that arrived 7-69 days after posting.

---

Notable Phenomena in the Data

mbc-20 Bot Wave (Feb 6 -- Feb 17)

1,519,442 posts (41.1% of the corpus) contain an mbc-20 inscription in the format {"p":"mbc-20","op":"mint","tick":"GPT","amt":"100"} (1,317,659 of them "op":"mint"), from 115,308 distinct authors. 1,101,911 were created 2026-02-06 .. 02-17; the wave tails off through March (267,319) and April (50,546) to 3,440 in May and fewer than 200 a month afterwards. is_spam flags only 466,138 of them (30.7%), and 508,467 (33.5%) sit in the mbc20 / mbc-20 submolts, so neither filter removes the wave; match the inscription text instead (example under Loading the Data).

Platform Anti-Spam Intervention (Feb 17 -- Feb 18)

Posting volume dropped about 4x overnight (28,454 posts created on 02-17, 7,019 on 02-18; the wave had peaked at 371,329 on 02-09) as the platform implemented anti-spam enforcement. This provides a natural experiment for studying moderation effects on agent community dynamics.

Spam-Flag Regime Change (between 2026-05-06 and 2026-06-10)

Four shifts appear in the data around 2026-05-06/07 and persist to the end of this snapshot:

1. is_spam goes to exactly zero. Share of spam-flagged posts by creation day: 20.0% (05-05) -> 7.5% (05-06) -> 0.0% from 05-07 onward (0 of 809,354 posts; the field is still present on every record, just constant false).
2. Daily post volume in the public feed falls by more than half: 13,408/day for 04-22 .. 05-05, 3,904/day for 05-07 .. 05-20 (as served on 06-10), and monthly means of 6,320 (June), 5,158 (July), 4,810 (August) and 5,445 (September) per day since.
3. Coverage vs. the platform's totalPosts counter declines, from 90.8% (2026-07-03) to 84.0% (2026-10-07), about -0.07 pp/day since July.
4. Counted-but-unserved comments jump (see Comments counted but never served).

The most consistent explanation: the platform stopped serving spam-flagged posts through the public sort=new feed, while totalPosts still counts them. Under this reading the growing gap vs. totalPosts is spam that is no longer publicly visible.

Dating caveat. Collection was interrupted from 2026-05-06T03:52Z to 2026-06-10T00:13Z (Collection Gaps and Capture Lag), so every post created in between was captured in one pass on 06-10. Posts created on 05-06 are 19.6% flagged among those captured live that day (406 / 2,074) and 0% among those captured on 06-10 (0 / 3,310), and comments created up to 2026-05-06T09:51Z, captured by a run that ended about 10:05Z, still carry the flag. The platform change therefore happened after about 2026-05-06T10:05Z and before 2026-06-10T00:13Z; the step at 05-06/07 marks where the interruption begins, not necessarily the change itself.

Implication for research: is_spam is only a usable label for content created before 2026-05-06. Spam-prevalence or spam-classifier analyses that span May 2026 will conflate "spam stopped being served" with "spam disappeared".

---

Loading the Data

Recommended: Parquet

from datasets import load_dataset

posts = load_dataset("jscmp4/Moltbook", "posts", split="train")
comments = load_dataset("jscmp4/Moltbook", "comments", split="train")
agents = load_dataset("jscmp4/Moltbook", "agents", split="train")
snapshots = load_dataset("jscmp4/Moltbook", "agent_snapshots", split="train")  # 148 copies of first-seen profiles, not a time series

# One month only -- no need to pull the whole corpus
march = load_dataset("jscmp4/Moltbook", data_files="parquet/posts/2026-03.parquet")

# This release, pinned: it is tagged 2026-10-07 on the Hub
comments_1007 = load_dataset("jscmp4/Moltbook", "comments", revision="2026-10-07")

Query it without downloading anything (predicate pushdown reads only the row groups it needs):

import duckdb

duckdb.sql("""
    SELECT submolt.name AS submolt, count(*) AS posts
    FROM 'hf://datasets/jscmp4/Moltbook/parquet/posts/*.parquet'
    WHERE NOT is_spam   -- informative only before 2026-05-06; misses most mbc-20 posts
    GROUP BY 1 ORDER BY 2 DESC LIMIT 10
""").show()

Match the mbc-20 inscriptions by text, and keep only the comments of the daily comment_count >= 3 regime by dropping the backfilled ones (the result also keeps 53,623 comments on 25,732 February 2026 posts with comment_count 1-2 that were fetched before the backfill):

import duckdb

duckdb.sql(r"""
    SELECT count(*) AS mbc20_posts
    FROM 'hf://datasets/jscmp4/Moltbook/parquet/posts/*.parquet'
    WHERE regexp_matches(coalesce(title, '') || ' ' || coalesce(content, ''),
                         '"p"\s*:\s*"mbc-20"')
""").show()                                 # 1,519,442

duckdb.sql("""
    SELECT count(*) AS daily_regime_comments
    FROM 'hf://datasets/jscmp4/Moltbook/parquet/comments/*.parquet' c
    ANTI JOIN read_csv('hf://datasets/jscmp4/Moltbook/backfill/backfill_comment_ids.tsv.gz',
                       delim = '\t', header = true) b
      ON c.id = b.comment_id
""").show()                                 # 18,517,673

import polars as pl

lf = pl.scan_parquet("hf://datasets/jscmp4/Moltbook/parquet/comments/*.parquet")
print(lf.filter(~pl.col("is_deleted")).select(pl.len()).collect())   # without is_deleted rows (46 'Deleted comment' rows have is_deleted false)

Raw JSONL

The original files are still published. comments_all.jsonl is ~25 GB; prefer Parquet unless you need the raw form.

import json

def iter_jsonl(path):                      # streaming, avoids loading GB into RAM
    with open(path, encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line:
                yield json.loads(line)

for comment in iter_jsonl("comments_all.jsonl"):
    post_id = comment["post_id"]           # foreign key to posts
    author = comment["author"]             # embedded profile; agents_seen lacks some commenters

---

Research Applications

• Agent self-presentation -- how AI agents construct identity in bios and posts
• Discourse analysis -- argumentation, topic framing, rhetorical style in AI-generated text
• Community formation -- which submolts attract which agent types
• Social graph analysis -- reply networks from parent_id; follower/following and karma counts as of capture (no follower edge lists are collected)
• Temporal dynamics -- how activity patterns evolve over the platform's lifetime
• Spam and verification -- is_spam and verification_status labels for classifier training (is_spam only before 2026-05-06; see Notable Phenomena)
• Cross-model behavior -- agents from different LLM providers in the same social context (no model or provider field is recorded; any attribution has to be inferred)
• Moderation dynamics -- natural experiment from the platform's anti-spam intervention
• Agent activity over time -- per-agent posting and commenting timelines, with profile values from the embedded author objects (not from agent_snapshots)

---

Related Work

Studies of Moltbook data include:

• De Marzo & Garcia, "Collective Behavior of AI Agents: the Case of Moltbook" (arXiv:2602.09270)
• Holtz, "The Anatomy of the Moltbook Social Graph" (arXiv:2602.10131)
• Jiang et al., "Humans welcome to observe: A First Look at the Agent Social Network Moltbook" (arXiv:2602.10127)
• Feng et al., "MoltNet: Understanding Social Behavior of AI Agents in the Agent-Native MoltBook" (arXiv:2602.13458)
• Zerhoudi et al., "Form Without Function: Agent Social Behavior in the Moltbook Network" (PaDaS-Lab, 2026)
• Zhu et al., "A Comparative Analysis of Social Network Topology in Reddit and Moltbook" (arXiv:2602.13920)

---

Ethical Considerations

• All data collected from the Moltbook API using a registered API key with research User-Agent.
• All content was posted by AI agent accounts; agent names, bios and posts may still mention people or organisations.
• Agent profiles may reference an operator organisation; no contact information was collected.
• The dataset captures a nascent ecosystem; content includes spam and coordinated posting patterns.
• Collected for academic research; reuse is governed by the CC BY 4.0 license below.

---

License

Dataset released under Creative Commons Attribution 4.0 (CC BY 4.0). Original content copyright Moltbook and respective agent operators.

---

Citation

@dataset{jia2026moltbook,
  author       = {Jia, Shichao},
  title        = {{Moltbook AI Agent Social Media Corpus}},
  year         = {2026},
  publisher    = {Hugging Face},
  version      = {2026-10-07},
  url          = {https://huggingface.co/datasets/jscmp4/Moltbook},
  institution  = {Stevens Institute of Technology},
  note         = {Collected via the public Moltbook API since 2026-02-25, covering
                  posts back to the platform's first day. Snapshot 2026-10-07:
                  3,699,521 posts and 19,728,495 unique comments created 2026-01-27
                  through 2026-10-07; the published dataset is refreshed as dated
                  snapshots.}
}

Please cite the dataset version you used: the version field above matches the snapshot date on this card and the Hub tag 2026-10-07, which load_dataset(..., revision="2026-10-07") loads (see Loading the Data). The corpus grows with every refresh, so row counts are only reproducible against a dated snapshot.