[

[

x algorithm series

]

]

How the Twitter Phoenix algorithm sees creators: hashed authors, semantic IDs and viewer history

·

·

12 min read

·

·

By Prateek Singh, founder of VoiceMoat

By Prateek Singh, founder of VoiceMoat

Summarize with AIClaudeChatGPTPerplexityShareShare

Updated 21 October 2026. We wrote this in May 2026, when the repo shipped a small sample Phoenix model (128-dimensional embeddings, a 127-step history, a 1M hash vocabulary) and files named phoenix/recsys_model.py and phoenix/recsys_retrieval_model.py, which no longer exist. On 13 August 2026 the repo replaced that sample with the production Phoenix code, which lives under phoenix/xrex/ and represents posts with semantic IDs as well as hashed IDs. This update swaps in the production numbers, corrects the action count from 19 to 25, and labels our “voice” reading as interpretation rather than code fact.

“Voice” is a slippery word. Phoenix, the model that ranks the Twitter For You feed, never reads a voice. What it reads is narrower and easier to check: the viewer’s recent engagement history, a hashed ID for each author, and IDs that describe each post. This article walks how the Twitter Phoenix algorithm represents authors, posts and viewer history in the open-source code as of 21 October 2026 (xai-org/x-algorithm), then gives our read, clearly labelled, on what that means for creators who care about consistency. It pairs with the series hub, which covers the whole pipeline, and the negative-signal economy, which covers the actions that pull a post down.

Phoenix in two stages

Phoenix has two jobs, described in phoenix/README.md:

  • Retrieval narrows millions of posts down to a candidate list for each viewer, using a two-tower model.

  • Ranking scores those candidates with a larger transformer and predicts how likely the viewer is to take each of 25 actions, from a like or a reply to a mute or a report.

home-mixer then multiplies each predicted probability by a weight and adds the results into one score. That step, and the full list of 25 actions, is covered in the guide to every signal Phoenix predicts.

The May version of this article quoted a “mini checkpoint”. It no longer exists. The Phoenix README now says the release ships “the production implementation itself”: the real model code, training step and Rust serving engine. Earlier releases shipped a sample transformer ported from Grok-1, which is where the old small numbers came from. The production configs look like this.

Phoenix production configs, ranking and retrieval

Parameter

Ranking (prod)

Retrieval (prod)

Embedding dimension

2,560

1,024

Transformer layers

8

8

History length (viewer actions)

1,022

1,023

Candidates per sequence

64

64

Author vocabulary (hash rows)

30M

30M

Post vocabulary (hash rows)

100M

100M

Hashes per entity

2

2

Semantic IDs

6 × 256, an input feature

6 × 256, the candidate’s identity

Source: phoenix/README.md, “Model Architecture Configs”, read 21 October 2026

Phoenix README table of production and nano model configs for ranking and retrieval

The Phoenix README config table, github.com/xai-org/x-algorithm, captured 21 October 2026.

One warning applies to every weight in this series. The weights in home-mixer/params/param.rs multiply predicted probabilities, not engagement counts. The repo says so directly: reading the report weight as “1 report cancels out 468 likes” is incorrect, and the comments in xai-value-model/scoring.rs note that the baseline probability of a report is more than 1000x lower than a like.

From username to hashed token

Phoenix never looks up your handle. Design decision 3 in the root README says both retrieval and ranking use multiple hash functions for embedding lookup, “so there is no vocabulary to maintain and a new post is representable immediately.”

In code, HashKeys in phoenix/xrex/models/recsys_embedding.py gives each entity type (users, posts, authors) two hash functions. Your author ID goes through both, each lands on one row of the author table, and the model learns from those two rows. In production that table has 30 million rows. Twitter has far more accounts than that, so rows are shared.

What this means in practice:

  • Your account has no private slot in the model. Each of your two rows is shared with other accounts through hash collisions.

  • Two independent hashes make it unlikely that another account collides with you on both rows, which is why the README calls the scheme collision-tolerant.

  • A post published a minute ago can be scored straight away. Nothing waits for a vocabulary update.

What separates you from other accounts is not the rows themselves. It is the pattern those rows form together with the posts you publish and the way viewers respond to them.

Semantic IDs: the part of a post the model can read

The biggest change since May is the semantic ID (SID). The Phoenix README describes SIDs as residual-quantized codes, 6 levels of 256 codes each, derived from each post’s multimodal embedding (its text and media). Same-topic posts share SID prefixes, which lets the model generalise to posts it has never seen.

In retrieval, the SID now does most of the work of describing a post. The production configs in phoenix/xrex/configs/xrecsys_two_tower.py set:

  • use_post_embedding: False: the candidate tower does not use the hashed post ID.

  • use_post_sid: True: it uses the post’s semantic ID instead.

  • use_user_embedding: False: there is no learned ID embedding for the viewer either.

Phoenix two-tower production config showing use_user_embedding False, use_post_embedding False and use_post_sid True

Production retrieval flags in phoenix/xrex/configs/xrecsys_two_tower.py, github.com/xai-org/x-algorithm, captured 21 October 2026.

Our read: in retrieval, a post is roughly “what it is about” (the SID) plus “who wrote it” (the author hash). A creator influences both, the first through subject matter and the second simply by being the same account over time.

The candidate tower: post plus author

RecsysCandidateTower in phoenix/xrex/models/recsys_two_tower_model.py builds the vector for each candidate post. It takes the author hash embeddings and the SID embedding (plus post hash embeddings, in configs that use them), combines them with a small learned projection, and normalises the result. Then:

  1. At every checkpoint save, the trainer runs the tower over the post corpus and stores the resulting index inside the checkpoint.

  2. The user tower turns the viewer’s history into one vector.

  3. Serving returns the top posts by dot product between the viewer’s vector and the index. The flagship production index holds up to 10.24 million posts.

The README says retrieval trains the two towers contrastively, with favorites as the positive signal. Put plainly, the similarity that decides retrieval is learned from likes: the model is trained to put a viewer’s vector close to posts they liked and away from sampled others.

The ranking model sees a richer candidate. Each candidate position carries post hashes, author hashes, the SID and context features such as the viewer’s timezone, local hour, product surface and the post’s age.

One consequence is a code fact, not interpretation. Two accounts posting identical text give the model the same content features but different author tokens, so Phoenix sees two different candidates. Which one scores higher for a given viewer depends on that viewer’s history with each author. The May version said identical text gets different embeddings because of the author hash. That is still true for the author part, but the content part is now shared through the SID.

The history sequence: what the model actually reads

Before scoring, home-mixer collects the viewer’s “user action sequence”, which the root README calls the main input to the model. It sends up to 1,024 actions for ranking and 1,024 for retrieval (MaxSeqLengthScoring and MaxSeqLengthRetrieval in home-mixer/params/param.rs). The production model configs use 1,022 and 1,023 positions.

Each history position is one past interaction, built from:

  • the post’s hashes and semantic ID,

  • the author’s hashes,

  • an embedding of the action the viewer took,

  • context features, plus dwell time on history positions.

block_history_reduce in phoenix/xrex/models/recsys_model.py joins these pieces for each position. In ranking, a user token adds coarse profile features (country, language, location, gender, age bracket, installed apps). In retrieval, the README says that beyond those profile features, “the user is represented by what they interacted with.”

So when a follower has liked, replied to or dwelt on your posts, those interactions sit in their sequence with your author token attached. When Phoenix ranks your next post for that follower, the candidate can attend to all of them.

Our read: three things shape how that history treats your next post.

  • Presence: how many of your posts appear in that viewer’s last thousand or so actions.

  • Response: which actions they took on them, from replies and long dwells to “not interested”.

  • Resemblance: how close the new post’s features, especially its SID, are to the posts of yours they engaged with.

The first two are earned over time. The third is the one you decide each time you write. Note where your “voice” actually lives in this picture: not in a profile of your style, which the model does not have, but in records of how specific people responded to your posts.

Candidate isolation: each post is scored on its own

Design decision 2 in the root README: during ranking, candidates can attend to the viewer’s history but not to each other, so “the score for a post doesn’t depend on which other posts are in the batch.” The Phoenix README draws the attention mask, and attention_segment_ids in phoenix/xrex/models/recsys_model.py marks candidate positions so each one sees the user and history tokens plus itself.

What this means for a creator:

  • Your other posts sitting in the same scoring batch do not lift or drag a given post.

  • Your past posts still matter, through the viewer’s history. If a viewer engaged with your last ten posts, those engagements are part of the sequence your new post attends to.

  • Scores are consistent and cacheable. The Phoenix README calls this batch-invariant serving.

The May version said a streak of good posts “does not contribute extra signal” to the next one. That was overstated. A streak does not help through the batch, but it does help once viewers have engaged with it and those engagements show up in their history.

Voice drift: our read, built on real mechanics

Everything in this section is VoiceMoat’s interpretation. The code has no “voice” feature, no style score and no drift detector. Our read rests on four mechanics that are in the code:

  1. Your author token stays the same across all your posts.

  2. SIDs group posts about the same subject.

  3. The model learns, from viewer histories, which viewers respond to which authors and subjects.

  4. It predicts negative actions as well as positive ones.

When a creator’s posts stay recognisable (similar subjects, similar formats, the same point of view), each new post resembles the posts their audience already engaged with, in the features the model can see. When a creator swings between unrelated subjects, or suddenly posts in a borrowed style, the new post resembles less of that history.

In practice this likely means weaker predicted positives from existing fans and, for some viewers, a higher predicted chance of “not interested” or a mute. Those weights are large: NotInterestedWeight is -52.272 and MuteAuthorWeight is -58.8, against FavoriteWeight 0.66. Remember they multiply small predicted probabilities. A slightly higher chance of a mute moves the score; it does not mean one mute erases dozens of likes.

What the code cannot tell us: how much drift matters, after how many posts, or for which audiences. None of that is in the repo. We write more about the pattern in voice drift.

Why a handful of samples is a weak picture

There is a separate question: the AI that drafts with you. A common pitch is “train on twenty of your tweets and we will write like you.”

Our read, and this is general statistics rather than anything in Phoenix: a handful of posts is a noisy sample of how someone writes. Habits such as how you open, how long you run, and which ideas you return to only show up reliably across a real body of posts.

audenAI, the brain inside VoiceMoat, learns from your own published posts, read across 10 signals. The more of your own content it reads, the steadier the picture new drafts are checked against.

The 10 signals audenAI reads in your posts

Signal

What it captures

Sentence rhythm

how long or short you run, where you break, when you fragment

Vocabulary

the words and register you reach for, and the ones you never use

Hooks

how you open: a question, a bold claim, a stat, a story, a direct address

Structure

how you build a post or a thread from start to finish

Tone

your mix of formality, confidence, humour, warmth and edge

Punctuation

your habits with commas, line breaks, ellipses and casing

Recurring references

the ideas, people and themes you come back to

Taboos

the phrasings and cliches you avoid

Mode-specific register

how you shift between a tweet, a reply and a thread

Persona markers

the small tells that make your posts recognisably yours

Source: the 10 signals in the VoiceMoat docs

None of these are Phoenix features. Phoenix sees IDs, semantic IDs, actions and context. The 10 signals are how VoiceMoat reads your content. Whether a post reads like you is a question your audience answers, and Phoenix learns their answers from their behaviour.

Where templates and generic AI output land (our read)

This section is interpretation too. It describes reader reactions, which are what Phoenix learns from.

  • Template-filled posts. When many creators pour their topic into the same viral template, their posts start to look alike. Our read: the content features of different accounts converge, the author token is left to do the distinguishing, and the follower who came for your particular take gets something that looks like the rest of their feed.

  • Lightly prompted general AI. A general model with a short prompt tends toward a familiar assistant register. Our read: the main risk is the reader. Short dwell, no reply, or a “not interested” are exactly the actions Phoenix predicts.

  • A code fact worth knowing. We found no AI-text feature among Phoenix’s inputs, but the labeling side does have one. A Grox classifier in grox/flows/upa/ outputs a slop_score for posts, and the enforcement rules act on a separate account-level label. In abuse-enforcement-service/service-lib/rules/enforcement_user.yaml, an account whose model score carries the label llm_slop_user gets the SpamHighRecall label for 30 days, and that label keeps its posts out of recommendations to non-followers. The model that assigns llm_slop_user is not in the repo, so nobody outside can say what triggers it.

  • Prompting versus learning. A model that has learned from your own posts has more to go on than one given a prompt and a few examples. That is a reasonable expectation, not a guarantee.

The tool-by-tool comparison is in VoiceMoat vs Tweet Hunter, Typefully and Hypefury.

How audenAI checks drafts today

audenAI, the brain inside VoiceMoat, checks drafts in Studio for Style and Stance. Style compares a draft with the habits in your own posts and updates as you type. Stance reads each line against the claims and stories in your own posts. Neither check changes how Twitter ranks anything. They help a draft read like you before you post it.

What changes for creators in practice

Start with the facts. Retrieval learns its notion of similarity from likes. Ranking predicts 25 actions, and the default weights in home-mixer/params/param.rs put more on replies (5.0), quotes (5.0), shares via DM (5.0), shares via copy link (20.0) and follows (4.0) than on likes (0.66). Each of those multiplies a predicted probability.

Our read on what to do with that:

  • Keep a recognisable subject area. SIDs group same-topic posts, and your followers’ histories are full of the subjects they engaged with you on.

  • Earn real interactions from the people who already follow you. Their histories are what your next post is scored against.

  • Treat negative actions as the cost of an off-pattern post. A post your audience did not expect from you risks “not interested” and mutes, which carry heavy weights.

  • Remember the window. The 48-hour AgeFilter means only recent posts compete (see 48 hours in Thunder), but the history effect builds across everything viewers engaged with.

  • Reach beyond followers works differently. Retrieval, SimClusters and the out-of-network discount are covered in how Twitter shows your posts to people who don’t follow you.

The honest summary: the Twitter Phoenix algorithm has no notion of voice. It has your author token, IDs that describe your posts, and a long record of how each viewer responded to them. VoiceMoat’s view is that consistent, recognisable content from a real person tends to earn the positive actions in that record (replies, dwell, shares, follows) and avoid the negative ones (not interested, mute, block, report). The code does not state that. It does make it plausible. For how the tools compare, see the VoiceMoat, Tweet Hunter, Typefully and Hypefury comparison.

Frequently asked questions

Frequently asked questions

What is the Twitter Phoenix algorithm?

Phoenix is the model behind the Twitter For You feed. It has two stages: a two-tower retrieval model that finds candidate posts near your engagement history, and a transformer ranking model that predicts the chance of 25 actions, from likes and replies to mutes and reports. home-mixer then weights those predicted probabilities into one score.

How does Phoenix represent a creator?

As a hashed author ID, not a username. Each author ID goes through two hash functions into a 30-million-row table, so rows are shared with other accounts. In retrieval, a post is represented by its semantic ID (a content code from its text and media) plus that author hash.

What does Phoenix read about the viewer?

Mainly their recent engagement history: up to 1,024 past actions, each built from the post, its author, the action taken, the post's semantic ID and context such as time and surface. Retrieval has no learned ID for the viewer; the viewer is represented by what they interacted with, plus coarse profile features.

Does Phoenix measure voice or detect drift?

No. There is no voice feature or drift detector in the code. Our read is that recognisable, consistent posts resemble the posts your audience already engaged with, which likely earns more positive predicted actions and fewer "not interested" or mute predictions. That is interpretation built on the real mechanics, not a code fact.

Do my other posts affect how a new post is scored?

Not through the scoring batch: candidate isolation means posts cannot attend to each other, so a post's score does not depend on what else is in the batch. Your past posts do matter through viewers' histories, because their likes, replies and dwell on your earlier posts are part of the sequence a new post is scored against.

AI disclosure

AI disclosure

This article was drafted with AI assistance and human-edited by Prateek Singh. All technical claims are sourced to the xai-org/x-algorithm repository; file paths are cited inline.

More in the series

Twitter's new ranker, explained: what the open-source code shows, updated October 2026, with 25 predicted actions and the ranking weights now published

Twitter Algorithm

The Twitter algorithm in 2026: how the open-source ranker works and why your voice matters

Twitter's For You feed runs on open-source code in the xai-org/x-algorithm repo on GitHub, first published in January 2026 and updated almost every weekday since 13 August. A transformer called Phoenix predicts 25 actions for each post, published weights turn them into one score, and author diversity, an out-of-network discount, a new-author boost and a DPP reranker follow. This hub walks the current code in plain English and explains why consistent, recognisable content still matters for creators.

14 min read

·

·

Mutes count more than likes: mute, block, report, not interested, scrolled past and muted keywords all pull a post down

Twitter Algorithm

Twitter algorithm negative signals: what a mute, block or report really costs

The Twitter algorithm predicts five negative actions for every post and gives them the largest weights in the code: report -234, mute -58.8, not interested -52.272, block -31.2 and not dwelled -0.02. Those weights multiply one viewer's predicted probability of the action, not counts, so a single mute does not cancel dozens of likes. This article explains the offset branch exactly as the code runs it, the filters that act after a real mute or block, and the visibility labels you can now check with Under the Hood.

13 min read

·

·

Recency is a window, not a boost: a new-author boost in the first 2 hours, eligible for For You up to 48 hours, filtered out after 48 hours

Twitter Algorithm

Twitter algorithm recency: why For You drops posts after 48 hours

How long do tweets stay in the For You feed? In the open-source code as of 21 October 2026, the answer is 48 hours: an AgeFilter removes older posts from every candidate source before scoring. There is no hand-set recency multiplier, but Thunder serves followers' posts newest first, the Phoenix training code reads post age as a feature, and the new-author boost only covers posts up to two hours old. This refresh corrects our May claim that old posts live on out of network.

10 min read

·

·

The whole series

The Twitter/X algorithm in May 2026: all ten articles

Read ›

Read ›

[

ready to start?

]

Create more.
Stay unmistakably you.
Grow from there.

3-day free 3-day trial · Cancel anytime · Your content stays private

[

ready to start?

]

Create more.
Stay unmistakably you.
Grow from there.

3-day free 3-day trial · Cancel anytime · Your content stays private

[

ready to start?

]

Create more.
Stay unmistakably you.
Grow from there.

3-day free 3-day trial · Cancel anytime · Your content stays private