What is Grox and what does it classify?
Grox is X's content-understanding layer — a system of Grok-powered classifiers that read your posts and label them before ranking. It runs a stream of classification tasks: a spam screen, a multi-policy safety taxonomy, a post-quality ("banger") screen, reply ranking, and multimodal embedding that turns text, images, and video transcripts into vectors. Where Phoenix decides ranking order, Grox decides what your content *is*. The four penalty-and-quality classifiers documented in this library are all Grox classifiers.
If Phoenix is the ranker, Grox is the reader. It's the layer that looks at a post and produces labels — is this spam, is it safe, is it high quality, what is it about — that the rest of the system uses. The released code organizes it as a dispatcher running a stream of classification tasks.
A stream of classifiers
Grox's base classifier is an abstract type: every classifier takes a set of categories and an LLM, and classifies a post against them:
19class ContentClassifier(ABC): 20 def __init__(self, categories: list[ContentCategoryType], llm: LiteLLM): 21 self.categories = categories 22 self.llm = llm ... 28 async def classify(self, post: Post) -> list[ContentCategoryResult]:
Grox's base ContentClassifier takes a list of content categories and an LLM, and exposes classify(post) returning per-category results — every Grox content classifier is an LLM judging a post against named categories.
Every Grox classifier is an LLM judging a post against named categories. That single shape — Grok reading your content and returning labels — is the whole content-understanding layer in miniature.
What Grox runs
The released classifiers and tasks map to pages already in this library:
| Grox component | what it judges | read more |
|---|---|---|
| Spam classifier | Low-follower spam screening, including replies and images | Spam classifier |
| Safety (PTOS) | A seven-policy safety taxonomy, two-stage | PTOS |
| Banger screen | Post-quality scoring, slop detection | Quality score |
| Multimodal embedder | Text + images + video transcript → one vector | Seen & heard |
| Reply ranking | Ordering replies under a post | — |
The Grok connection
Grox is Grok applied to content understanding — the same model family that powers
Phoenix. This is why the
multimodal embedder can read images and the
spam classifier can see them: the layer is built on a vision-capable LLM throughout. One model
family reads your content, embeds it, and ranks it.
The May 2026 release includes Grox, a content-understanding service with classifiers for spam detection, post-category classification, and PTOS policy enforcement — including spam.py, safety_ptos.py, banger_initial_screen.py, post_safety_screen_deluxe.py, and reply_ranking.py.
What the code doesn't say
The prompts. Every Grox classifier judges against a system prompt imported from
grox.prompts.template — and that entire module is absent from the public release.
The machinery (the classifiers, the categories, the stream) is open; the exact instructions each
model is given are withheld. We can tell you what Grox screens for, not the precise wording of
the rules it enforces.
The actual spam criteria are withheld: spam.py imports its system prompt (SpamSystemLowFollower) from grox.prompts.template, and the entire grox/prompts/ module is absent from the public release — the classifier machinery is open, the rules it enforces are not.
What to do with this
Write for two readers at once: Phoenix, which ranks by predicted engagement, and Grox, which labels what you made. Clean, clearly-on-topic, non-spammy content gives Grox little to flag and Phoenix a clear signal — and that alignment is what xDoctor's content diagnostics are built to check against the classifier behavior documented across this pillar.