Tribe V2 Agent Alignment

TRIBE v2 Agent Alignment

Validate whether your AI encoders — text, video, or audio — represent information the way human brains do, using Meta's TRIBE v2 cortical predictor. Use the resulting alignment scores to drive neuro-informed model routing in Life/Arcan.

Concept

Cortical alignment measures how well an AI encoder's hidden states predict actual fMRI brain activity in response to the same stimulus. TRIBE v2 (TRansformer for In-silico Brain Experiments) was trained on thousands of hours of naturalistic fMRI data and can predict activity across the full cortical surface (~20k vertices on the fsaverage5 mesh) for any text, video, or audio input. A high alignment score (R² > 0.25) means the encoder has learned representations that are geometrically similar to what the human language, visual, or auditory cortex computes — without any explicit neuroscience objective. This matters for model selection in an agent OS: a text encoder with higher language cortex alignment tends to generalize better to novel linguistic contexts, is more robust to distribution shift, and exhibits better zero-shot transfer. TRIBE v2 proved that LLaMA 3.2-3B spontaneously developed such alignment, validating its representations neurologically. The same benchmark can be applied to any candidate encoder before committing it to Arcan's routing stack.

Quick Start

Run a full alignment score for any encoder in 5 commands:

# 1. Install dependencies
pip install tribev2 transformers torch scikit-learn numpy

# 2. Prepare a stimulus directory (video files for video, text files for text, wav for audio)
mkdir -p ~/stimuli/text && echo "The model routed the task to the visual cortex." > ~/stimuli/text/s1.txt

# 3. Run alignment against LLaMA 3.2-3B (text encoder baseline)
python scripts/align_encoder.py \
  --encoder-type text \
  --encoder-model meta-llama/Llama-3.2-3B \
  --stimulus-dir ~/stimuli/text \
  --output ~/results/llama_alignment.json

# 4. Run alignment against a competing encoder
python scripts/align_encoder.py \
  --encoder-type text \
  --encoder-model bert-base-uncased \
  --stimulus-dir ~/stimuli/text \
  --output ~/results/bert_alignment.json

# 5. Compare scores
python -c "
import json
llama = json.load(open('~/results/llama_alignment.json'))['alignment_score']
bert  = json.load(open('~/results/bert_alignment.json'))['alignment_score']
winner = 'LLaMA 3.2' if llama > bert else 'BERT'
print(f'LLaMA 3.2: {llama:.3f}  |  BERT: {bert:.3f}  |  Winner: {winner}')
"

Workflow A: Text Encoder Alignment

Compare any two text encoders by their language cortex alignment score. Language cortex vertices cover Broca's area (~vertex 15000-18000, left hemisphere) and Wernicke's area (~vertex 12000-15000, left hemisphere) on the fsaverage5 mesh.

Step 1 — Prepare Text Stimuli

Text stimuli should be naturalistic sentences or paragraphs (not short keywords). TRIBE v2 was trained on narrative speech transcripts; similar inputs yield the most reliable alignment estimates.

mkdir -p ~/stimuli/text
cat > ~/stimuli/text/naturalistic_en.txt << 'EOF'
The surgeon carefully examined the patient before the procedure.
Language emerges from a distributed network spanning frontal and temporal lobes.
The model predicted activation in Broca's area when processing syntactically complex sentences.
EOF

Step 2 — Run Alignment for Each Encoder

# Baseline: TRIBE v2's own text encoder (LLaMA 3.2-3B) — expect ~0.40 R²
python scripts/align_encoder.py \
  --encoder-type text \
  --encoder-model meta-llama/Llama-3.2-3B \
  --stimulus-dir ~/stimuli/text \
  --output ~/results/llama32_align.json

# Candidate A: Mistral 7B
python scripts/align_encoder.py \
  --encoder-type text \
  --encoder-model mistralai/Mistral-7B-v0.1 \
  --stimulus-dir ~/stimuli/text \
  --output ~/results/mistral7b_align.json

# Candidate B: sentence-transformers (smaller, faster)
python scripts/align_encoder.py \
  --encoder-type text \
  --encoder-model sentence-transformers/all-mpnet-base-v2 \
  --stimulus-dir ~/stimuli/text \
  --output ~/results/mpnet_align.json

Step 3 — Interpret and Route

import json, pathlib

results = {}
for p in pathlib.Path("~/results").expanduser().glob("*_align.json"):
    d = json.loads(p.read_text())
    results[d["encoder"]] = d["alignment_score"]

best = max(results, key=results.get)
print("Alignment scores (language cortex R²):")
for enc, score in sorted(results.items(), key=lambda x: -x[1]):
    flag = " <-- route here" if enc == best else ""
    print(f"  {enc:55s} {score:.3f}{flag}")

Text Encoder Comparison Table

Workflow B: Video Encoder Alignment

Compare video encoders by their visual cortex alignment. Visual cortex vertices cover V1-V4 (~vertex 1000-5000) and motion-selective areas MT/MST (~vertex 5000-8000) on fsaverage5.

Step 1 — Prepare Video Stimuli

Use naturalistic video clips (not slideshows). MP4 format, 1-5 minutes each. TRIBE v2 segments at 5-second windows internally.

mkdir -p ~/stimuli/video
# Download a CC-licensed short clip, or use any .mp4 you have:
# ffmpeg -i source.mp4 -t 120 -c copy ~/stimuli/video/clip01.mp4

Step 2 — Run Alignment

# Baseline: TRIBE v2's own video encoder (V-JEPA2 ViT-G) — expect high visual cortex alignment
python scripts/align_encoder.py \
  --encoder-type video \
  --encoder-model facebook/vjepa2-vitg-fpc64-256 \
  --stimulus-dir ~/stimuli/video \
  --output ~/results/vjepa2_align.json

# Candidate: CLIP ViT-L/14
python scripts/align_encoder.py \
  --encoder-type video \
  --encoder-model openai/clip-vit-large-patch14 \
  --stimulus-dir ~/stimuli/video \
  --output ~/results/clip_vitl_align.json

# Candidate: VideoMAE-v2 (ViT-G, action recognition)
python scripts/align_encoder.py \
  --encoder-type video \
  --encoder-model MCG-NJU/videomae-huge \
  --stimulus-dir ~/stimuli/video \
  --output ~/results/videomae_align.json

Step 3 — Check Emergent Networks

TRIBE v2 spontaneously recovers 5 functional brain networks. Verify the visual encoder activates the correct one:

import json
result = json.load(open("~/results/vjepa2_align.json"))
print(f"Alignment score: {result['alignment_score']:.3f}")
print(f"Top cortical regions: {result['top_regions']}")
# Expected output for video: top_regions includes 'visual_cortex' vertices 1000-8000

Video Encoder Comparison Table

Workflow C: Arcan Integration

Use alignment scores stored in Lago to configure Arcan's model routing at task dispatch time.

Step 1 — Cache Scores in Lago

After running align_encoder.py, push scores into Lago's alignment table:

import json, datetime
import lago  # Life/Lago Python client

scores = {}
for path in ["llama32_align.json", "mistral7b_align.json"]:
    d = json.load(open(path))
    scores[d["encoder"]] = {
        "modality": d["modality"],
        "alignment_score": d["alignment_score"],
        "top_regions": d["top_regions"],
        "evaluated_at": datetime.datetime.utcnow().isoformat(),
    }

lago.write("broomva.arcan.encoder_alignment", scores)

Step 2 — Declare Routing Weights in Arcan Config

Add alignment-driven routing to ~/.config/arcan/routing.toml:

[routing.text]
strategy = "neuro_alignment"
alignment_table = "broomva.arcan.encoder_alignment"
modality = "text"
fallback = "meta-llama/Llama-3.2-3B"
min_score = 0.15          # reject encoders below this threshold

[routing.video]
strategy = "neuro_alignment"
alignment_table = "broomva.arcan.encoder_alignment"
modality = "video"
fallback = "facebook/vjepa2-vitg-fpc64-256"
min_score = 0.20

[routing.audio]
strategy = "neuro_alignment"
alignment_table = "broomva.arcan.encoder_alignment"
modality = "audio"
fallback = "facebook/w2v-bert-2.0"
min_score = 0.10

Step 3 — Routing Logic (Pseudocode)

# arcan/src/routing/neuro_alignment.py

def select_encoder(task: Task, alignment_table: dict) -> str:
    """Return the highest-alignment encoder for this task's modality."""
    modality = task.modality  # "text", "video", or "audio"
    candidates = {
        enc: data["alignment_score"]
        for enc, data in alignment_table.items()
        if data["modality"] == modality
           and data["alignment_score"] >= MIN_SCORE[modality]
    }
    if not candidates:
        return FALLBACK[modality]
    return max(candidates, key=candidates.get)

# Called at every task dispatch:
encoder = select_encoder(task, lago.read("broomva.arcan.encoder_alignment"))
result = arcan.run(task, encoder=encoder)

Step 4 — Re-Evaluation Triggers

# Autonomic watchdog (add to autonomic/config/watches.toml):
# [watch.encoder_alignment]
# table = "broomva.arcan.encoder_alignment"
# check = "alignment_score"
# threshold_drop = 0.05
# action = "rollback_and_alert"

Alignment Score Interpretation

Important caveats:

• Scores are population-average predictions from TRIBE v2's training cohort. Individual subject variability can shift scores ±0.05.
• TRIBE v2 operates on 5-second temporal windows. Encoders that produce token-level representations need temporal pooling before probing.
• The linear ridge regression probe (see scripts/align_encoder.py) measures linear decodability, not representational isomorphism. High R² means the encoder's representations are linearly predictive of cortical activity, which is the standard encoding model benchmark in computational neuroscience.
• License constraint: TRIBE v2 is CC BY-NC 4.0. Alignment scores derived from it cannot be used in commercial products without a separate agreement with Meta.

Reference Files

• references/encoder-alignment.md — Methodology, known baseline scores, modality-to-region mapping, limitations
• references/arcan-integration.md — Full integration guide, TOML config schema, Lago caching, re-evaluation workflow

Arcan Integration — Neuro-Informed Model Routing

How to wire TRIBE v2 alignment scores into the Life/Arcan model routing layer for biologically-informed encoder selection at task dispatch time.

---

1. Overview

Arcan is the AI orchestration layer in the Life monorepo (core/life/arcan/). It receives tasks from aiOS, selects the appropriate model/encoder, calls tools, and returns results. Today, routing decisions are driven by:

• Task type (generation, embedding, classification)
• Cost budget
• Latency SLA
• Model capability flags (context window, multimodal support)

TRIBE v2 alignment scores add a fifth dimension: biological plausibility — does this encoder represent the stimulus the way a human brain would? Encoders with higher language cortex alignment tend to generalize better to novel linguistic inputs, while high visual cortex alignment predicts better zero-shot scene understanding.

The integration flow:

New model released
      |
      v
run align_encoder.py  --> alignment_score JSON
      |
      v
lago.write("arcan.encoder_alignment")
      |
      v
Arcan routing reads alignment table at task dispatch
      |
      v
Route to highest-alignment encoder meeting cost/latency constraints

Alignment scores are computed offline (not per-request) and cached in Lago. The routing decision adds negligible latency (a single Lago table read, typically < 1ms local).

---

2. Configuration Format

Declare alignment-aware routing in Arcan's routing configuration file (~/.config/arcan/routing.toml or core/life/arcan/config/routing.toml):

# routing.toml — Arcan model routing configuration

[routing.defaults]
cost_budget = "medium"          # low / medium / high
latency_sla_ms = 2000
enable_neuro_alignment = true   # set false to disable alignment-based routing

# Text task routing
[routing.text]
strategy = "neuro_alignment"
alignment_table = "broomva.arcan.encoder_alignment"
modality = "text"
fallback_model = "meta-llama/Llama-3.2-3B"
min_alignment_score = 0.15     # reject models below this R^2

# Video task routing
[routing.video]
strategy = "neuro_alignment"
alignment_table = "broomva.arcan.encoder_alignment"
modality = "video"
fallback_model = "facebook/vjepa2-vitg-fpc64-256"
min_alignment_score = 0.20

# Audio task routing
[routing.audio]
strategy = "neuro_alignment"
alignment_table = "broomva.arcan.encoder_alignment"
modality = "audio"
fallback_model = "facebook/w2v-bert-2.0"
min_alignment_score = 0.10

# Model registry: declare all available encoders with their metadata
[models.text]
"meta-llama/Llama-3.2-3B"      = { cost = "low",    latency = "medium", context = 131072 }
"mistralai/Mistral-7B-v0.1"    = { cost = "medium",  latency = "medium", context = 32768  }
"bert-base-uncased"             = { cost = "low",    latency = "low",    context = 512    }

[models.video]
"facebook/vjepa2-vitg-fpc64-256"   = { cost = "high",   latency = "high",   fps = 64 }
"openai/clip-vit-large-patch14"    = { cost = "medium",  latency = "medium", fps = 1  }
"MCG-NJU/videomae-huge"            = { cost = "high",   latency = "high",   fps = 16 }

[models.audio]
"facebook/w2v-bert-2.0"            = { cost = "medium", latency = "medium" }
"facebook/wav2vec2-large-960h"     = { cost = "medium", latency = "medium" }

YAML Alternative

If your Arcan config uses YAML:

routing:
  defaults:
    cost_budget: medium
    latency_sla_ms: 2000
    enable_neuro_alignment: true

  text:
    strategy: neuro_alignment
    alignment_table: broomva.arcan.encoder_alignment
    modality: text
    fallback_model: meta-llama/Llama-3.2-3B
    min_alignment_score: 0.15

  video:
    strategy: neuro_alignment
    alignment_table: broomva.arcan.encoder_alignment
    modality: video
    fallback_model: facebook/vjepa2-vitg-fpc64-256
    min_alignment_score: 0.20

  audio:
    strategy: neuro_alignment
    alignment_table: broomva.arcan.encoder_alignment
    modality: audio
    fallback_model: facebook/w2v-bert-2.0
    min_alignment_score: 0.10

---

3. Routing Logic

The neuro-alignment routing strategy implemented in Arcan:

# core/life/arcan/src/routing/neuro_alignment.py

from dataclasses import dataclass
from typing import Optional
import lago  # Life/Lago Python client

MIN_SCORE = {"text": 0.15, "video": 0.20, "audio": 0.10}
FALLBACK_MODEL = {
    "text": "meta-llama/Llama-3.2-3B",
    "video": "facebook/vjepa2-vitg-fpc64-256",
    "audio": "facebook/w2v-bert-2.0",
}


@dataclass
class Task:
    modality: str               # "text", "video", "audio"
    cost_budget: str            # "low", "medium", "high"
    latency_sla_ms: int
    requires_language: bool = False
    requires_motion: bool = False


def select_encoder(task: Task, alignment_table: dict, model_registry: dict) -> str:
    """
    Select the highest-alignment encoder that fits within cost/latency constraints.
    Falls back to the configured fallback model if no alignment data is available.
    """
    modality = task.modality
    min_score = MIN_SCORE.get(modality, 0.0)
    available_models = model_registry.get(modality, {})

    # Filter: must have alignment data and meet minimum score
    candidates = []
    for model_id, meta in available_models.items():
        if model_id not in alignment_table:
            continue
        score = alignment_table[model_id].get("alignment_score", 0.0)
        if score < min_score:
            continue
        # Filter by cost budget
        model_cost = meta.get("cost", "high")
        if not _cost_fits(model_cost, task.cost_budget):
            continue
        # Filter by latency
        model_latency_ms = meta.get("latency_ms", 5000)
        if model_latency_ms > task.latency_sla_ms:
            continue
        candidates.append((model_id, score))

    if not candidates:
        return FALLBACK_MODEL.get(modality, "meta-llama/Llama-3.2-3B")

    # Sort by alignment score descending; pick the top candidate
    candidates.sort(key=lambda x: x[1], reverse=True)
    selected, score = candidates[0]
    return selected


def _cost_fits(model_cost: str, budget: str) -> bool:
    """Return True if model cost tier fits within the task budget."""
    tiers = {"low": 0, "medium": 1, "high": 2}
    return tiers.get(model_cost, 2) <= tiers.get(budget, 1)


# Called at task dispatch time in Arcan's main routing loop:
def route_task(task: Task) -> str:
    alignment_table = lago.read("broomva.arcan.encoder_alignment")
    model_registry = lago.read("broomva.arcan.model_registry")
    return select_encoder(task, alignment_table, model_registry)

Decision Tree

Task arrives at Arcan dispatcher
├── Determine modality (text / video / audio)
├── Read alignment_table from Lago cache
│   └── If cache_age > 30 days: trigger async re-evaluation, use stale data
├── Filter candidates by min_alignment_score
├── Filter candidates by cost_budget and latency_sla
├── Sort remaining by alignment_score descending
├── Return top candidate
└── If no candidates: return FALLBACK_MODEL[modality]

---

4. Score Caching in Lago

Alignment scores are stable until a new model version is released or fine-tuning occurs. Cache them in Lago's broomva.arcan.encoder_alignment table:

# scripts/push_alignment_to_lago.py
# Run after align_encoder.py to update the Lago routing table.

import json
import datetime
import pathlib
import lago

RESULTS_DIR = pathlib.Path("./results")
TABLE_NAME = "broomva.arcan.encoder_alignment"


def push_results():
    current = {}
    try:
        current = lago.read(TABLE_NAME) or {}
    except Exception:
        pass  # Table may not exist yet

    for result_path in RESULTS_DIR.glob("*_align.json"):
        data = json.loads(result_path.read_text())
        encoder_id = data["encoder"]
        current[encoder_id] = {
            "alignment_score": data["alignment_score"],
            "modality": data["modality"],
            "interpretation": data["interpretation"],
            "roi_label": data["roi_label"],
            "top_regions": data["top_regions"],
            "evaluated_at": datetime.datetime.utcnow().isoformat(),
            "n_stimuli": data["n_stimuli"],
            "tribe_model": data["tribe_model"],
        }

    lago.write(TABLE_NAME, current)
    print("Pushed {} encoder alignment records to Lago.".format(len(current)))
    for enc, rec in sorted(current.items(), key=lambda x: -x[1]["alignment_score"]):
        print("  {:.3f}  {}  ({})".format(rec["alignment_score"], enc, rec["modality"]))


if __name__ == "__main__":
    push_results()

Lago Table Schema

broomva.arcan.encoder_alignment
├── key: encoder_id (str)         -- HuggingFace model ID
├── alignment_score (float)       -- mean R^2 from ridge probe
├── modality (str)                -- text / video / audio
├── interpretation (str)          -- poor / moderate / good / excellent
├── roi_label (str)               -- language_cortex / visual_cortex / auditory_cortex
├── top_regions (list[dict])      -- top-5 vertices with highest alignment
├── evaluated_at (ISO timestamp)  -- when the score was computed
├── n_stimuli (int)               -- stimulus count used for evaluation
└── tribe_model (str)             -- "facebook/tribev2"

---

5. Re-Evaluation Triggers

Autonomic Watchdog Configuration

Add to core/life/autonomic/config/watches.toml:

[watch.encoder_alignment_staleness]
description = "Re-evaluate alignment if any encoder score is stale"
table = "broomva.arcan.encoder_alignment"
check_field = "evaluated_at"
max_age_days = 30
action = "trigger_skill"
skill = "tribe-v2-agent-alignment"
command = "python scripts/align_encoder.py --encoder-type {modality} --encoder-model {encoder_id} --stimulus-dir ./stimuli/{modality} --output ./results/{encoder_id_safe}_align.json"

[watch.encoder_alignment_regression]
description = "Alert and rollback if alignment score drops significantly"
table = "broomva.arcan.encoder_alignment"
check_field = "alignment_score"
threshold_drop = 0.05
action = "rollback_and_alert"
alert_channel = "agent-logs"
rollback_table = "broomva.arcan.encoder_alignment_history"

---

6. End-to-End Workflow: New Model Integration

Full workflow when a new text encoder (e.g., LLaMA 3.3-8B) is released:

# Step 1: Pull the new model (or it will be downloaded by align_encoder.py)
huggingface-cli download meta-llama/Llama-3.3-8B --local-dir ./models/llama-3.3-8b

# Step 2: Run cortical alignment benchmark
python scripts/align_encoder.py \
  --encoder-type text \
  --encoder-model meta-llama/Llama-3.3-8B \
  --stimulus-dir ./stimuli/text \
  --output ./results/llama33_align.json \
  --cv-splits 5

# Step 3: Inspect the result
python -c "
import json
r = json.load(open('./results/llama33_align.json'))
print('Encoder:', r['encoder'])
print('Alignment score:', r['alignment_score'], '(' + r['interpretation'] + ')')
print('Top regions:', r['top_regions'][:2])
"

# Step 4: Compare to current best encoder
python -c "
import json, glob
scores = {}
for p in glob.glob('./results/*_align.json'):
    d = json.load(open(p))
    if d['modality'] == 'text':
        scores[d['encoder']] = d['alignment_score']
for enc, s in sorted(scores.items(), key=lambda x: -x[1]):
    print(f'{s:.3f}  {enc}')
"

# Step 5: Push to Lago
python scripts/push_alignment_to_lago.py

# Step 6: Arcan will automatically pick up the new scores on next task dispatch.
# Verify by checking the routing decision for a test task:
arcan route --task-type language_understanding --modality text --dry-run
# Expected output: Selected encoder: meta-llama/Llama-3.3-8B (score: 0.XXX)

# Step 7: Monitor for regressions via Autonomic (automatically watches alignment table)
arcan status --watch encoder_alignment

Rollback Procedure

If alignment regression is detected after switching to a new model:

# View alignment history
lago query "SELECT encoder, alignment_score, evaluated_at FROM broomva.arcan.encoder_alignment_history ORDER BY evaluated_at DESC LIMIT 20"

# Manual rollback: restore previous best encoder to routing table
python -c "
import lago
history = lago.read('broomva.arcan.encoder_alignment_history')
current = lago.read('broomva.arcan.encoder_alignment')

# Find the previous best text encoder
prev_best = max(
    ((enc, rec) for enc, rec in history.items() if rec['modality'] == 'text'),
    key=lambda x: x[1]['alignment_score']
)
current[prev_best[0]] = prev_best[1]
lago.write('broomva.arcan.encoder_alignment', current)
print('Rolled back to:', prev_best[0], 'score:', prev_best[1]['alignment_score'])
"

---

7. Integration Testing

Before deploying alignment-driven routing to production, verify the integration:

# tests/test_arcan_alignment_routing.py

import pytest
from core.life.arcan.routing.neuro_alignment import select_encoder, Task

MOCK_ALIGNMENT_TABLE = {
    "meta-llama/Llama-3.2-3B": {"alignment_score": 0.40, "modality": "text"},
    "bert-base-uncased":        {"alignment_score": 0.18, "modality": "text"},
    "facebook/vjepa2-vitg":     {"alignment_score": 0.38, "modality": "video"},
    "openai/clip-vit-l14":      {"alignment_score": 0.24, "modality": "video"},
}

MOCK_MODEL_REGISTRY = {
    "text": {
        "meta-llama/Llama-3.2-3B": {"cost": "low",    "latency_ms": 500},
        "bert-base-uncased":        {"cost": "low",    "latency_ms": 100},
    },
    "video": {
        "facebook/vjepa2-vitg":    {"cost": "high",   "latency_ms": 3000},
        "openai/clip-vit-l14":     {"cost": "medium", "latency_ms": 500},
    },
}


def test_selects_highest_alignment_text_encoder():
    task = Task(modality="text", cost_budget="medium", latency_sla_ms=2000)
    result = select_encoder(task, MOCK_ALIGNMENT_TABLE, MOCK_MODEL_REGISTRY)
    assert result == "meta-llama/Llama-3.2-3B"


def test_falls_back_on_latency_constraint():
    task = Task(modality="video", cost_budget="medium", latency_sla_ms=1000)
    # vjepa2 latency_ms=3000 exceeds SLA; should select clip
    result = select_encoder(task, MOCK_ALIGNMENT_TABLE, MOCK_MODEL_REGISTRY)
    assert result == "openai/clip-vit-l14"


def test_falls_back_when_no_alignment_data():
    task = Task(modality="audio", cost_budget="medium", latency_sla_ms=2000)
    result = select_encoder(task, {}, {})
    assert result == "facebook/w2v-bert-2.0"  # hardcoded fallback

Run with: cargo test -p arcan (Rust) or pytest tests/test_arcan_alignment_routing.py (Python bindings).

Encoder Alignment — Methodology and Reference

Technical reference for interpreting cortical alignment scores produced by scripts/align_encoder.py.

---

1. Methodology: Linear Probing via Ridge Regression

Cortical alignment is measured using the linear encoding model paradigm from computational neuroscience. The protocol:

1. Encoder forward pass — Run each stimulus through the candidate AI encoder. Extract the final hidden state and mean-pool over the spatial/temporal dimension to get a single vector per stimulus. This yields a matrix X of shape (n_stimuli, encoder_dim).

2. TRIBE v2 forward pass — Run the same stimuli through TRIBE v2. Extract predicted fMRI activity over the modality-relevant ROI (e.g., language cortex vertices 12000-18000 for text). This yields Y of shape (n_stimuli, n_roi_vertices).

3. Ridge regression probe — Fit a ridge regression Y_hat = X @ W + b where W is (encoder_dim, n_roi_vertices). Train and test on disjoint stimulus sets via k-fold cross-validation (default 5 folds). Regularization prevents overfitting to encoder-specific quirks.

4. R-squared as alignment score — Report the mean coefficient of determination (R²) across vertices and CV folds. R² = 1 - (sum of squared residuals / total variance). This measures the fraction of TRIBE v2 cortical variance that the encoder's representations can linearly explain.

Why R² and Not Pearson r

R² accounts for both correlation and scaling. An encoder whose activations are correlated but differently scaled from cortical activity will score lower than one with matched magnitude. In practice, StandardScaler is applied to both X and Y before fitting, so the difference from using r vs. R² is small, but R² is the conventional reporting metric in encoding model benchmarks (see Scotti et al., Brain-Score 2, 2024).

Why Ridge and Not LASSO or OLS

Ridge regression handles the high-dimensional encoder_dim >> n_stimuli regime (common with LLMs) without overfitting. The regularization strength alpha defaults to 1.0; sweep over [0.01, 0.1, 1.0, 10.0, 100.0] and pick the best by inner CV when n_stimuli is large enough.

---

2. Known Alignment Scores (from TRIBE v2 paper and related work)

These are reference values from the TRIBE v2 publication (Benchetrit et al., 2025) and related encoding model studies. Use them to sanity-check your benchmark runs.

Text Encoders — Language Cortex (vertices 12000-18000)

Key finding from TRIBE v2: Autoregressive LMs (LLaMA family) consistently outperform masked LMs (BERT family) on language cortex alignment. This matches the finding that language cortex processes text in a predictive (left-to-right) manner, not bidirectionally.

Video Encoders — Visual Cortex (vertices 1000-8000)

Key finding from TRIBE v2: Self-supervised video models trained with masked prediction (V-JEPA2, VideoMAE) strongly align with motion-selective cortex (MT/MST, vertices 5000-8000). CLIP-style models align better with ventral visual stream (V1-V4) than dorsal motion stream.

Audio Encoders — Auditory Cortex (vertices 8000-11000)

---

3. Interpretation Thresholds

Practical guidance: A 0.05 R² difference between two encoders is typically not meaningful given fMRI noise. Treat differences < 0.05 as ties and prefer the faster/smaller model.

---

4. Modality-to-Region Mapping

The ROI vertex ranges below are approximate boundaries on the fsaverage5 surface (~20k vertices total, both hemispheres combined). Left hemisphere is vertices 0-9999, right hemisphere 10000-19999.

For more precise parcellation, use the HCP MMP1.0 atlas projected onto fsaverage5. The vertex ranges above are suitable for bulk alignment scoring but not for fine-grained region analysis.

Emergent Functional Networks

TRIBE v2 spontaneously recovers 5 functional brain networks from its training data alone. Verify your encoder activates the expected network:

If your encoder achieves high R² outside its expected network (e.g., a video encoder scoring high on language cortex vertices), investigate for data leakage or multimodal contamination in training.

---

5. Limitations

Population-Average Predictions

TRIBE v2 predicts population-average cortical responses from its training cohort. Individual subjects show ~0.05 R² variability around the population mean. Alignment scores therefore reflect how well an encoder matches the "average human", not any particular subject.

5-Second Temporal Window

TRIBE v2 processes stimuli in non-overlapping 5-second windows. Encoders that capture phenomena at shorter timescales (e.g., phoneme-level in audio) may be slightly disadvantaged. Temporal pooling (mean over the window) is applied before probing.

Linear Probe Assumption

Ridge regression measures linear decodability only. An encoder could have high non-linear alignment with cortex but low linear R². For a fuller picture, use representational similarity analysis (RSA) in addition to linear probing — but linear R² is sufficient for model selection.

Stimulus Distribution Shift

Alignment scores are sensitive to stimulus statistics. TRIBE v2 was trained on naturalistic video/audio/text; synthetic or highly structured stimuli (e.g., word lists, artificial tones) will yield lower and less reliable alignment estimates. Use naturalistic stimuli when possible.

CC BY-NC 4.0 License Constraint

TRIBE v2 is released under Creative Commons Attribution-NonCommercial 4.0. Alignment scores derived from its predictions cannot be used in commercial products or to gate commercial model routing decisions without a separate agreement with Meta. For internal R&D and open-source projects within the Broomva stack, CC BY-NC permits use.

Stimulus Count Requirement

Reliable R² estimates require at least 20 stimuli (more is better). With fewer than 10 stimuli, the cross-validation estimate has high variance; treat results as directional only. The TRIBE v2 paper used thousands of fMRI trial repetitions; align_encoder.py is a lightweight proxy using TRIBE v2 predictions as a surrogate ground truth.