How does the Community Notes algorithm decide which notes show?
With a matrix factorization model — the same family of math behind recommendation systems — trained on every rating. It learns a "helpfulness" number for each note (the note intercept) and a "viewpoint" position for each note and each rater (the factors). A note becomes Currently Rated Helpful and shows publicly when its intercept clears 0.40. The crucial design: because raters sit at different viewpoint positions, a note only earns a high intercept if people across the viewpoint spectrum rate it helpful. Agreement within one camp isn't enough. That's the bridging mechanism, and it's in the open-source code.
Community Notes is open-source separately from the For You algorithm — its scoring code lives in
the twitter/communitynotes repository. It's worth understanding on its own terms,
because the mechanism is genuinely clever and widely misunderstood.
It's a matrix factorization model
At its core, Community Notes runs the kind of model that powers recommendation engines. It learns, from the full rating history, a set of parameters per note and per rater:
241note_intercepts # each note's helpfulness score 247note_factors # each note's viewpoint position 244user_intercepts # each rater's leniency 250rater_factors # each rater's viewpoint position 226global_intercept # overall baseline
Community Notes scores notes with a matrix factorization model: it learns a note intercept (helpfulness), a note factor (viewpoint), a rater intercept and rater factor, and a global intercept, fitting all parameters to the full rating history.
The model predicts how a given rater will rate a given note as: the global baseline, plus the note's intercept, plus the rater's leniency, plus the dot product of their viewpoint factors. It fits all these at once to best explain the real ratings.
The note intercept is the helpfulness score
The single number that decides a note's fate is its intercept — the part of its score that doesn't depend on viewpoint. A note becomes Currently Rated Helpful (and shows on the post) when its intercept clears the threshold:
167crhThreshold: float = 0.40,
A Community Note becomes Currently Rated Helpful (and shows publicly) when its learned note intercept clears the CRH threshold, which defaults to 0.40 in the open scoring code.
Why this requires cross-viewpoint agreement
This is the part worth grasping. The factor captures viewpoint — raters who tend to agree
get similar factor values. A note that only appeals to one viewpoint gets explained by the factor
term, not the intercept, so its intercept stays low. Only a note that people across different
factor positions rate helpful pushes its intercept above 0.40. The math literally rewards bridging
divides, and the not-helpful threshold uses a negative factor multiplier so that more polarized notes
must clear a harder bar.
The model places notes and raters on a shared viewpoint 'factor' axis; a note's intercept only rises when raters across different factor positions agree, and the not-helpful threshold applies a negative note-factor multiplier (default -0.8) so more polarized notes must clear a harder bar. This is the bridging mechanism that resists single-viewpoint agreement.
What the code doesn't say
This is a different repository from the ranking algorithm — twitter/communitynotes,
not xai-org/x-algorithm — so it carries its own source and commit. The open code shows
the model and thresholds; the live data (who rated what) isn't public at the individual level, and
the production pipeline runs additional scorers and safeguards layered on this core.
The Community Notes scoring algorithm is open-sourced in twitter/communitynotes — a distinct repository from the xai-org/x-algorithm ranking code — and operates on public note and rating data; individual rater data is pseudonymized in the public release.
What to do with this
If you write or rate notes, understand that helpfulness is earned across viewpoints, not within one — a note that reads as partisan won't clear the bar however many allies rate it. xDoctor's Community Notes intelligence is built directly on this model: it reads the public note and rating data through the same matrix-factorization lens to surface patterns in how notes get rated.