Skip to content
CAI
Software that uses CAICheck a score

xai-org/x-algorithm

53.7

Adequate · 14 November 2026

449.3k

lines of production code

Rust

with Python, Scala, Java

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add CUDA-accelerated Adler32 checksum and unique value kernels via XLA FFI

This change introduces two new CUDA-based operations exposed through the XLA FFI interface. In the adler32 module, it adds GPU implementations for standard Adler32 checksums, global shard-based checksums (supporting up to 12 dimensions), and a fast variant using configurable scaling, alongside a CPU fallback using zlib. In the unique module, it adds a CUDA kernel that computes unique values from an input array, optionally returning inverse indices, using Thrust and CUB for sorting and deduplication on the device.

phoenix/xrex/cuda/adler32, phoenix/xrex/cuda/unique · high confidence

Added checksum verification for XAI checkpoint integrity

The xai-checkpointing module now includes a new checksum.py file that implements Adler32-based checksum computation and validation for JAX model states. This feature allows users to verify the integrity of saved checkpoints by computing shard-level and global checksums, detecting corruption, and ensuring consistency across distributed devices during training or inference.

xai-checkpointing · high confidence

Initial implementation of the Grox core processing engine

This change introduces the foundational architecture for the Grox recommendation and content processing system. It adds the core engine and dispatcher components that manage task queues, scheduling, and execution pipelines. The update includes a comprehensive data loading layer with Kafka and Strato integrations to ingest and hydrate post and user data, alongside specialized processors for media (including embedding-ranked key frame extraction), audio (ASR), and descendant thread resolution via the NightOwl search client. A task generator registry is also provided to allow extensible, configurable task generation. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

grox/core · medium confidence · unverified

Initial release of the Grox server entry point

This change introduces the main entry point for the Grox server, establishing the application's startup and shutdown lifecycle. It initializes core components including the Engine, Dispatcher, and gRPC server, and integrates Kerberos authentication renewal when configured. The server now handles graceful shutdowns via SIGINT/SIGTERM signals, ensuring proper cleanup of resources and connections.

grox · high confidence

Initial server entry point for abuse enforcement service

The server application now includes a main entry point that initializes the runtime, parses configuration, and sets up API key authentication for protected admin endpoints. It configures the HTTP router to serve API routes under /api, documentation under /api/docs, and a health check endpoint at /kafka\_ready, while also serving a static admin UI bundle from a public directory. The server integrates with Kafka for message consumption and supports graceful shutdown with configurable drain periods.

abuse-enforcement-service/server · high confidence

Introduce Botmaker expression language and compiler

Adds the Botmaker component, a new expression language and compiler for defining derived features. This includes an ANTLR grammar (BotMaker.g) for parsing expressions, a Java-based compiler that transforms parsed trees into AST nodes, and a runtime context system for evaluating those expressions against input features. The change also introduces a \BotMakerFunction\ annotation and associated documentation structures to define and describe available functions within the language.

botmaker, media-model-proxy · high confidence

Introduce Grox PTOS safety classification flow

This change adds the \grox/flows/ptos\ module, implementing a new safety classification pipeline for posts. It introduces task generators that ingest posts from various Kafka topics (such as min-traction, recovery, deluxe, and live cluster anchors) and route them through a series of processing plans. These plans orchestrate tasks for filtering, media hydration, category and policy detection (using LLM classifiers like SafetyPtosCategoryClassifier), and specific checks for adult content, spam, and key frames. The flow also includes rate limiting, deduplication, and result sinks to write safety annotations, with support for different operational modes like standard, deluxe, and recovery.

grox/flows/ptos · high confidence

Introduce Kafka CLI library with multi-region support and GSSAPI patching

This change adds the \grox/libs/kafka\_cli\ library, providing Python-based Kafka consumers and producers with support for PLAINTEXT, SSL/mTLS, and SASL (GSSAPI/SCRAM) authentication. It introduces \MultiRegionKafkaConsumer\ and \MultiRegionKafkaProducer\ classes that manage connections across multiple Kafka clusters (regions), including automatic retry logic for failed regions and metrics integration. The library also includes a \patched\_gssapi\ module that patches the \gssapi\ library to hardcode a specific Kerberos target name (\kafka/[e-mail redacted]\), and defines Pydantic-based configuration models for Kafka connectivity.

_grox/libs/kafka\cli · high confidence

Introduce Phoenix Rank-All indexing pipeline for posts and favorites

This change adds the Phoenix Rank-All streaming infrastructure to the platform, enabling the system to index posts and favorite events for downstream ranking and search capabilities. It introduces a new event processing pipeline that ingests post creation events and favorite (like) events, applying rate-limiting logic based on power-of-two favorite-count thresholds to control indexing frequency. The system writes candidate data to Manhattan storage (including post author metadata and filtered topics by experiment) and publishes indexing requests to Kafka topics (such as \phoenix\_rankall\_fav\_event\ and \phoenix\_rank\_all\_indexing\_event\) to trigger the actual indexing into various index sets like 'ads', 'evergreen\_video', and 'search\_unfiltered'.

phoenix-rankall-strato · high confidence

Introduce Phoenix Rankall recommendation pipeline

Adds the Phoenix Rankall service, a Rust-based recommendation pipeline that consumes events from Kafka, hydrates post features (such as engagement counts, media flags, and language) via internal Strato and Tweetypie APIs, and writes scored results to local snapshot stores. The service supports multiple pipeline modes (Main, Topic, Metadata, SID, SID-Tail, and Analysis) with configurable Kafka authentication (SCRAM or mTLS), backfill capabilities for SID lookups, and Prometheus metrics for monitoring fetch, processing, and store operations.

phoenix-rankall · high confidence

Introduce abuse-ledger-service for enforcement hold lookups

Adds a new Rust-based service that exposes a POST /v1/holds/lookup endpoint to retrieve active enforcement holds for users. The service validates request parameters (up to 100 user IDs and 32 labels), enforces request deadlines against a configurable statement timeout, and returns hold details along with database latency metrics. It includes a boot-time contract check to verify the ledger database schema before accepting traffic, a periodic database health probe, and Prometheus metrics for lookup counts, latency, and pool status.

abuse-ledger-service · high confidence

Introduce grok\_sampler library for LLM inference

Added the grok\_sampler library, providing configuration models and sampler implementations for interacting with large language models. The library includes a base LiteLLM class for gRPC-based sampling with streaming support, metrics, and logging, along with specific TextSampler and VisionSampler classes for handling text and multimodal inputs. It also features an OaiSampler for OpenAI-compatible API endpoints, supporting features like JSON schema response formatting and configurable timeouts.

_grox/libs/grok\sampler · high confidence

Introduce multimodal embedding and safety analysis infrastructure

This change adds the core Python components for a new multimodal recommendation and safety pipeline. It introduces a Keras-based CLIP model for generating image and text embeddings, a media processor to hydrate posts with video and image data, and a conversation module to structure multimodal inputs (including video frames and ASR transcripts) for large language models. Additionally, it implements a safety analysis flow that uses vision models and reference bundles to detect media-injected adult content and spam, integrating these capabilities into the post processing schedule.

python · high confidence

Introduces encrypted checkpointing for JAX training

Adds a new \xai\_checkpointing\ package that enables secure, encrypted storage of JAX training checkpoints. The module integrates with Orbax to provide encrypted read/write capabilities via \EncryptedPyTreeCheckpointHandler\, handling data encryption and decryption through a Key Management Service (KMS) client. It includes utilities for managing Data Encryption Keys (DEKs), handling JAX-specific array operations and sharding, and ensuring robust checkpoint loading and saving with retry logic for transient KMS errors.

phoenix/python/training · high confidence

Introduces v2 SimClusters ranking, clustering, and evaluation infrastructure

This change adds the core implementation for the SimClusters v2 recommendation system, introducing new candidate ranking strategies (ClusterRanker and HeavyRanker) that support multiple scoring methods such as normalized favorite scores and follow scores. It includes a suite of clustering algorithms (Connected Components, Louvain, and Largest Dimension) with configurable similarity thresholds and representative selection methods (MaxFavScore, Medoid). The update also provides essential mathematical utilities for vector operations (cosine similarity, norms, dot products), embedding management (MultiEmbedding, Monoid), and model versioning, alongside Scalding jobs for bipartite cluster evaluation and comparison to assess cluster quality and stability.

simclusters · high confidence

Introduction of centralized configuration management for Grox services

A new configuration module has been added to define settings for the Grox system, including model endpoints, Kafka consumer/producer parameters, gRPC server ports, and media processing options. This change establishes a structured way to manage environment-specific configurations via YAML files and environment variables, supporting features like multi-region Kafka consumption and embedding-based media hydration.

grox/config · high confidence

New AI-powered reply ranking and spam detection system

This change introduces a new backend flow for evaluating and ranking replies, utilizing large language models to score reply quality and detect various forms of spam. The system includes a \ReplyScorer\ that assigns a quality score (0-3) to replies, with a fallback mechanism for handling model errors. It also implements three distinct spam detection classifiers: \CoordinatedSpamScorer\ for identifying coordinated inauthentic behavior, \MultiStepReplySpamScorer\ for detecting complex multi-turn spam patterns, and \SimpleReplyScorer\ for general spam detection. These classifiers use specific prompts and model configurations (Gemma-2 and Grok) to analyze thread context, user profiles, and engagement signals. The flow is orchestrated through task plans that handle filtering, media hydration, detection, and writing results to the ranking system, with metrics tracking for each stage.

_grox/flows/reply\spam · high confidence

New Scarecrow Botmaker runtime and function registry for safety actions

This change introduces the Scarecrow implementation of the Botmaker platform, providing a new runtime and server entry points for both admin and non-admin modes. It registers a comprehensive set of functions for safety operations, including applying and removing safety labels on tweets via ActionIntakeService, managing user labels through Gizmoduck, and interacting with the Manhattan label and HLL counter stores. The runtime also supports social graph queries (follower counts, following status), feature counting via LimiterService, and model retrieval, enabling bots to execute tangible impact actions and data lookups within the Scarecrow security context.

scarecrow · high confidence

New XAI recommendation system common crate

The \phoenix/crates/common/xai-recsys\ crate has been added to provide shared infrastructure for the XAI recommendation system. It includes a build script that parses a Python feature configuration file to generate Rust constants and enums, a \model\_config\ module defining multimodal embedding types and hash table configurations for user, item, author, and IP features, and a \util\ module containing functions for processing Arrow record batches, handling conversation assets, and recording system metrics. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

phoenix/crates/common · medium confidence · unverified

New abuse enforcement service library with action control, allowlist, and backfill capabilities

The service-lib crate now includes a comprehensive abuse enforcement system. It introduces Action Control, allowing pages to define and enforce rules (such as suspensions or labeling) based on entity confidence levels and classifiers, with support for dry-run modes and history tracking. An Allowlist module provides CRUD operations for whitelisting users via the Manhattan store. A Backfill system enables replaying past decisions to apply actions retroactively, complete with rate limiting, budget management, and pause/resume controls. Additionally, the library adds an AIS (Action Intake Service) client for executing actions, an API documentation layer with Bearer token authentication, and rollback utilities to safely disable page-managed scopes.

abuse-enforcement-service/service-lib/src · high confidence

New abuse enforcement, adult content modeling, and bot detection capabilities

This release introduces several new capabilities for content safety and abuse management. The abuse enforcement service now includes a YAML rule validation tool and defines allowlist and configuration data types for managing user exceptions. An adult content detection module has been added, featuring Python scripts for training TensorFlow models on media embeddings and calibrating their confidence scores. Additionally, a Rust-based feature engineering library and accumulator service have been introduced to process user engagement sequences and compute behavioral features for abuse scoring. Finally, new botmaker rules have been deployed to automatically label spam, duplicate text, and low-quality URL interactions.

(repo-wide) · high confidence

New brand-safe ad blending strategies for the home feed

The home-mixer now includes a suite of new ad-blending components that integrate ads into the organic feed while enforcing brand safety and adjacency rules. These new modules—MultiRiskAdsBlender, PartitionOrganicAdsBlender, SafeGapAdsBlender, FollowingAdBlender, and TimeGapAdsBlender—implement logic to calculate safe gaps between posts, manage ad spacing, and drop ads that conflict with medium/high-risk content, excluded handles, or specific keywords. The system also tracks dropped ads and their reasons (e.g., spacing caps, brand safety risks) to ensure ads are only placed in safe, contextually appropriate positions within the user's timeline. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

home-mixer · low confidence · unverified

The \grox/flows/mm\_emb\ package introduces a new processing pipeline for generating multimodal embeddings for posts, supporting three model versions: V5, V8.2, and V8 Search. This includes dedicated embedders (\MultimodalPostEmbedderV5\, \MultimodalPostEmbedderV82\, \MultimodalPostEmbedderV8Search\) that handle text and media rendering, ASR transcript integration, and API calls to the embedding service. The flow is orchestrated via task plans (\PlanPostEmbeddingV5\, etc.) that define dependencies for rate limiting, media hydration, and ASR transcription. It also features a backfill mechanism (\TaskBackfillFavGate\, \BatchedFavHydrator\) to process historical posts, using an adaptive rate limiter to manage throughput and a Redis-based deduplication layer (\BackfillConsumerDedup\) to prevent redundant processing.

_grox/flows/mm\emb · high confidence

New recsys engine serving infrastructure for cross-datacenter checkpoint distribution

The serving crate now includes a complete engine for distributing model checkpoints across datacenters. This adds a checkpoint proxy server that polls and downloads checkpoints from trainers, an admission controller to manage request latency and queue depth, and high-performance data transfer capabilities using RDMA (via ibverbs) and gRPC. The implementation also includes parallel checksumming (Adler32) for data integrity, a checkpoint store supporting S3 and GCS object storage, and a peer-to-peer manifest-based serving system to optimize bandwidth usage during checkpoint replication. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

phoenix/crates/serving · low confidence · unverified

New takedown filtering and data integration components

This change introduces new code to handle takedown-related logic across two services. In the gizmoduck service, a new \ReadFilters\ chain is established to orchestrate various request filters, including a new \RedactUnenforcedTakedownsFilter\ that removes takedown reasons marked as unenforced (specifically those with worldwide copyright or country codes) from user data in read requests. In the tweet-entity-service, new \TakedownReasonsColumn\ and \TakedownReasonsTransform\ components are added to fetch and integrate takedown reasons for tweets and users, combining tweet-level and user-level takedown data into the tweet envelope.

takedowns · high confidence

New types for abuse enforcement service control mechanisms

The abuse-enforcement-service/types crate now exposes the core data models required for the service's enforcement logic. This includes types for action control (confidence levels, rollout buckets, and evidence overrides), allowlist management (with bulk parsing and TTL support), backfill operations (run records and settings), configuration patches, head guards (action limits and overturn rules), and an off-switch mechanism for pausing enforcement on specific heads or classifiers. These types define the request/response schemas and internal records that power the service's decisioning and safety controls.

abuse-enforcement-service/types · high confidence

New video processing library for frame sampling and key-frame extraction

Added the \grox/libs/video\_tools\ package, introducing \FrameSampler\ for extracting regular or specific-time video frames and \ShotKeyFramesExtractor\ for identifying and retrieving key frames based on shot detection. These tools allow users to efficiently sample video content for downstream processing or thumbnail generation.

_grox/libs/video\tools · high confidence

Open-source Behavioral Detection Sequence Model (BDSM) for inauthentic account detection

This release introduces the Behavioral Detection Sequence Model (BDSM), a transformer-based system designed to detect inauthentic accounts (bots, spam, and coordinated actors) by analyzing user behavioral event streams. The model uses a bidirectional transformer encoder with time-aware rotary position embeddings to capture inter-action timing and burstiness, processing 256 distinct action types across eight classification heads (e.g., FollowBot, LikeBot, TweetSpamBot, LegitimateUser). The package includes the full runtime inference pipeline, which ingests Kafka events, performs feature extraction via a Rust PyO3 module, and executes GPU-accelerated scoring using JAX. It also provides the training stack for task heads on cached backbone activations, along with Protobuf definitions for the scoring protocol and a reference streaming pipeline with Redis-backed sequence caching.

bdsm · high confidence

Open-source X Recommendation System reference implementation

The \phoenix/reference\ directory now provides a complete, runnable open-source reference for the X Recommendation Algorithm. This includes synthetic data generators that replace production Kafka streams, reference implementations of the MM-embedding and Semantic-ID (SID) provider services, and the deterministic training pipeline. Users can now generate a seeded synthetic world, produce training dumps and provider snapshots, train the ranking model end-to-end on a single device, and execute inference using the production gRPC contracts without requiring any proprietary infrastructure or real user data. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

phoenix/xrex · medium confidence · unverified

Open-source the Agatha recommendation algorithm and PMI hub

This change introduces the Agatha recommendation system and the underlying PMI (Pointwise Mutual Information) hub to the open-source repository. It adds the core Scala libraries for building and predicting features, including Bijections, Builder, and Prediction logic, alongside the Thrift definitions for features, labels, and modelled features. The diff also includes the job templates for scheduled and ad-hoc execution, label management, and mathematical aggregators for moments and percentiles. Additionally, it provides example implementations for computing PMI on follow graphs and specific build/predict jobs for NSFW, rate-based, and spam-related labels, along with the BlinkScore job template for calibrating user scores.

agatha · high confidence

Open-sourced PMI-based recommendation algorithm and graph feature infrastructure

This change introduces the Pointwise Mutual Information (PMI) recommendation algorithm, including core computation logic, statistical aggregators, and data extractors in the \agatha/hub/pmi\ package. It also adds a suite of graph-based data loaders for features such as follows, blocks, mentions, retweets, and abuse reports, alongside a new local aggregator runtime and app client infrastructure within the Botmaker framework.

repository · high confidence

Open-sourcing Phoenix recommendation system with synthetic training and CUDA kernels

The Phoenix recommendation system is now open-source, providing a complete, single-host verification harness for training and serving ranking and retrieval models. This release includes a QUICKSTART guide to generate deterministic synthetic data, train nano-config models (using Muon or AdamW optimizers), resume training, and serve checkpoints via gRPC. It also introduces a new CUDA-based Mixture-of-Logits (MOL) epilogue kernel for efficient retrieval scoring and a stubbed O2 storage client interface. The previous JAX/Haiku-based model implementations (grok.py, recsys\_model.py, etc.) have been removed in favor of this new architecture.

phoenix · high confidence

Thunder service: initial implementation of in-network post retrieval and supporting infrastructure

The Thunder service is introduced to handle in-network post retrieval, providing a new gRPC and HTTP interface (ports 9090 and 8080) with configurable Kafka consumption, SASL authentication, and object storage integration. It includes a comprehensive set of Prometheus metrics to monitor Kafka lag, request durations, and PostStore statistics, alongside a suite of Thrift-generated schema definitions for tweets, users, media, and events to support the new recommendation algorithm.

thunder · high confidence

Under the Hood report configuration and label definitions added

New configuration files for the Under the Hood reporting system have been introduced, defining feature switches to control report visibility, takedown inclusion, and time buckets. The update also establishes the data source configuration for the Manhattan Apollo service and provides a comprehensive registry of post and account labels (such as NSFW, Spam, and Violent Content) along with their specific effects on user visibility and recommendations. Also in this area: Introduce Under the Hood report feature.

under-the-hood/strato · high confidence

Behavioural changes

14 commits (0 fixes) modifying vm-ranker/scoring

A change to existing behaviour in vm-ranker/scoring — 14 commits, 4 files: “Open-source X Recommendation Algorithm”.

vm-ranker/scoring · medium confidence · unverified

15 commits (0 fixes) modifying vm-ranker

A change to existing behaviour in vm-ranker — 15 commits, 13 files: “Open-source X Recommendation Algorithm”.

vm-ranker · medium confidence · unverified

2 commits (0 fixes) modifying botmaker-rules

A change to existing behaviour in botmaker-rules — 2 commits, 73 files: “Open-source X Recommendation Algorithm”.

botmaker-rules · medium confidence · unverified

26 commits (0 fixes) modifying visibility-filtering-client

A change to existing behaviour in visibility-filtering-client — 26 commits, 11 files: “Open-source X Recommendation Algorithm”.

visibility-filtering-client · medium confidence · unverified

3 commits (0 fixes) modifying under-the-hood/jetfuel

A change to existing behaviour in under-the-hood/jetfuel — 3 commits, 8 files: “Open-source X Recommendation Algorithm”.

under-the-hood/jetfuel · medium confidence · unverified

3 commits (0 fixes) modifying under-the-hood/scalding

A change to existing behaviour in under-the-hood/scalding — 3 commits, 15 files: “Open-source X Recommendation Algorithm”.

under-the-hood/scalding · medium confidence · unverified

3 commits (0 fixes) modifying under-the-hood/thrift

A change to existing behaviour in under-the-hood/thrift — 3 commits, 1 file: “Open-source X Recommendation Algorithm”.

under-the-hood/thrift · medium confidence · unverified

44 commits (0 fixes) modifying phoenix/python/common

A change to existing behaviour in phoenix/python/common — 44 commits, 6 files: “Open-source X Recommendation Algorithm”.

phoenix/python/common · medium confidence · unverified

5 commits (0 fixes) modifying xai-configlib

A change to existing behaviour in xai-configlib — 5 commits, 1 file: “Open-source X Recommendation Algorithm”.

xai-configlib · medium confidence · unverified

55 commits (0 fixes) modifying phoenix-recsys

A change to existing behaviour in phoenix-recsys — 55 commits, 48 files: “Open-source X Recommendation Algorithm”.

phoenix-recsys · medium confidence · unverified

56 commits (0 fixes) modifying visibility-filtering

A change to existing behaviour in visibility-filtering — 56 commits, 162 files: “Open-source X Recommendation Algorithm”.

visibility-filtering · medium confidence · unverified

7 commits (0 fixes) modifying safety-label-source

A change to existing behaviour in safety-label-source — 7 commits, 10 files: “Open-source X Recommendation Algorithm”.

safety-label-source · medium confidence · unverified

9 commits (0 fixes) modifying xai-value-model

A change to existing behaviour in xai-value-model — 9 commits, 6 files: “Open-source X Recommendation Algorithm”.

xai-value-model · medium confidence · unverified

Comprehensive instrumentation and observability for the candidate pipeline

The candidate-pipeline now provides detailed, stage-level observability for all pipeline components (sources, hydrators, filters, scorers, selectors, and side effects). This change introduces a new \pipeline\_summary\ module that tracks latency, input/output sizes, and filter rates for each stage, emitting structured logs and metrics via \tracing\ and \xai\_stats\_receiver\. The pipeline execution flow has been refactored to use synchronous \run\ methods wrapped in instrumentation, replacing the previous async-only traits, and introduces a \CachedHydrator\ trait to support caching with hit/miss metrics. Additionally, the selector now explicitly tracks non-selected candidates, and side effects receive both selected and non-selected candidates, enabling better post-processing analytics. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

candidate-pipeline · low confidence · unverified

Test coverage

Added integration and load tests for the Media Model Proxy; Added mock rules and replay golden files for abuse enforcement testing.

Dependencies

Phoenix recommendation system dependency and build configuration

The Phoenix project's build manifests have been updated to define the 'Phoenix — X's open-source recommendation algorithm' package. This includes a comprehensive set of Python dependencies for JAX-based training (jax, dm-haiku, optax, chex), data processing (pyarrow, pandas, aiokafka), and checkpointing (orbax-checkpoint, tensorstore), alongside optional extras for the serving engine (cupy, py-libnuma), multimodal encoding (transformers, torch), and telemetry (wandb, fastapi). The Rust workspace (phoenix/Cargo.toml) establishes a workspace with Rust 2024 edition, defining dependencies for the recommendation engine, proto definitions, and storage crates using crates like arrow, axum, tonic, and object\_store.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 54 → 54 (-0.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 52 → 51 (-0.3)
  • Architecture 96 → 96 (-0.3)
  • Maturity 64 → 66 (+1.8)
  • Readiness 43 → 41 (-2.0)
  • Security 81 → 79 (-1.9)
  • Domain Modelling 100 → 100 (+0.0)
  • Performance 74 → 85 (+11.4)

Resolved (386)

  • AiTrendFeedbackContextHydrator::hydrate (cognitive 18) (home-mixer/candidate_hydrators/ai_trend_feedback_context_hydrator.rs)
  • ClassTooLong: Store (visibility-filtering/hydration/store.rs)
  • Duplicated block (10 lines × 14) (thunder/schema/user.rs)
  • Duplicated block (10 lines × 2) (abuse-enforcement-service/service-lib/src/action_control.rs)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 2) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • …and 366 more

New (725)

  • CachedHydrator::hydrate_cached (cognitive 31) (candidate-pipeline/hydrator.rs)
  • Case::judge (cyclomatic 19) (visibility-filtering/verdict_gate.rs)
  • DragonflySource::compare (cognitive 18) (safety-label-source/dragonfly.rs)
  • Duplicated block (10 lines × 14) (thunder/schema/user.rs)
  • Duplicated block (10 lines × 2) (abuse-enforcement-service/service-lib/src/action_control.rs)
  • Duplicated block (10 lines × 2) (home-mixer/ads/health_metrics.rs)
  • Duplicated block (10 lines × 2) (home-mixer/sources/sid_source.rs)
  • Duplicated block (10 lines × 2) (phoenix/crates/common/xai-recsys/src/util.rs)
  • Duplicated block (10 lines × 2) (phoenix/crates/serving/xai-recsys-engine/src/python.rs)
  • Duplicated block (10 lines × 2) (phoenix/crates/serving/xai-recsys-mm-server/src/events.rs)
  • Duplicated block (10 lines × 2) (safety-label-source/connect.rs)
  • Duplicated block (10 lines × 2) (thunder/schema/tweet.rs)
  • Duplicated block (10 lines × 2) (thunder/schema/tweet.rs)
  • Duplicated block (10 lines × 2) (thunder/schema/user.rs)
  • Duplicated block (10 lines × 3) (abuse-enforcement-service/service-lib/src/action_control.rs)
  • Duplicated block (10 lines × 3) (home-mixer/ads/multi_risk_blender.rs)
  • Duplicated block (10 lines × 3) (home-mixer/clients/prompts_client.rs)
  • Duplicated block (10 lines × 3) (thunder/schema/events.rs)
  • Duplicated block (10 lines × 4) (botmaker/src/scala/com/twitter/botmaker/FunctionUnitGen.scala)
  • Duplicated block (10 lines × 4) (thunder/schema/tweet.rs)
  • …and 705 more

Changes since last survey

  • 14 commits — 14 feature/other, 0 fixes

By area

  • phoenix/xrex — 5 commits
  • visibility-filtering/rules — 5 commits
  • abuse-enforcement-service/service-lib — 2 commits
  • home-mixer/candidate_hydrators — 1 commit
  • visibility-filtering/hydration — 1 commit

Notable commits

  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm
  • change: Open-source X Recommendation Algorithm

Architecture

  • Unchanged — 0 containers · 6 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

xai-org/x-algorithm was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 590f3926e5bc33c50d9ece13953623e1e75ee595 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.