TFS-ZS-MNLI — Zero-Shot Thinking Classification Model

Model ID: brahmairesearch/TFS-ZS-MNLI
Series: Thinking Fast and Slow (TFS)
Parameters: ~279M
Base Architecture: DeBERTaV2ForSequenceClassification
Type: Zero-Shot Classification
Predicted Labels: fast_thinking, slow_thinking, calculative_thinking

Overview

TFS-ZS-MNLI is the first zero-shot classification model in BRAHMAI's TFS (Thinking Fast and Slow) series. It brings cognitive routing to the forefront of NLP. Trained using the MNLI framework, this model predicts the kind of reasoning your text demands — be it intuitive, reflective, or computational.

Zero-shot? Hell yes. Instead of creating a dedicated classifier for every downstream task, we let the model generalize. You provide the text and a set of candidate labels, and the model ranks them using NLI-style entailment scoring. This makes it versatile, scalable, and hella efficient for reasoning-based workflows.

Why Three Types of Thinking?

Inspired by Daniel Kahneman’s Thinking, Fast and Slow, this model doesn’t stop at just fast and slow cognition. Real-world AI needs a third gear—calculative thinking—to handle technical, logical, and numerical reasoning tasks.

Fast Thinking

Quick. Casual. Intuitive. Requires little effort or analysis.

Examples:

"Is mango a fruit?"

"Name a city in France"

"What time is it?"

Slow Thinking

Deep. Reflective. Abstract. Philosophical or ethical in nature.

Examples:

"How does AI impact mental health?"

"Is morality objective or subjective?"

Calculative Thinking

Analytical. Numeric. Algorithmic. Needs math, logic, or structured reasoning.

Examples:

"What’s the output of 3x + 2 when x = 5?"

"Write a binary search algorithm"

"What is Big-O of bubble sort?"

This triad gives you a finer control over routing and model behavior in real-world apps.

Why Zero-Shot Instead of Classic Classification?

Because life (and prod deployments) ain’t always supervised.

Zero-shot allows you to plug this model into any app, any domain, and start classifying cognitive styles without task-specific retraining. You define the labels. The model maps them dynamically.

This flexibility is gold for systems where reasoning type dictates downstream actions. Instead of retraining a model every time the use case shifts, just change the labels.

Use Cases

Cognitive Routing: Direct user inputs to task-specific models (e.g., reasoning vs factual models)
Prompt Type Detection: Categorize prompts for instruction-tuned LLMs
Educational Tech: Match student queries to the right level of explanation or tutor
Customer Support: Route tickets to either human reps, bots, or tech support based on complexity
Data Labeling: Automatically tag large text corpora based on reasoning demand
Content Analysis: Track how much intuitive vs deep vs technical reasoning is needed in datasets
Conversation Segmentation: Split chats into intuitive vs reflective vs analytical zones

Quick Start

Pipeline API

from transformers import pipeline

classifier = pipeline("zero-shot-classification", model="brahmairesearch/TFS-ZS-MNLI")

sequence = "How many R are in STRRRRAWBERRRRRRY?"
candidate_labels = ["fast_thinking", "slow_thinking", "calculative_thinking"]

output = classifier(sequence, candidate_labels, multi_label=False)
print(output)

Manual Transformers API

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import torch.nn.functional as F

tokenizer = AutoTokenizer.from_pretrained("brahmairesearch/TFS-ZS-MNLI")
model = AutoModelForSequenceClassification.from_pretrained("brahmairesearch/TFS-ZS-MNLI")

text = "Write a Python function to reverse a linked list."
candidate_labels = ["fast_thinking", "slow_thinking", "calculative_thinking"]

results = []
for label in candidate_labels:
    inputs = tokenizer(text, label, return_tensors="pt", truncation=True)
    with torch.no_grad():
        logits = model(**inputs).logits
        score = F.softmax(logits, dim=1)[0][2].item()  # Entailment score (MNLI)
        results.append((label, score))

results = sorted(results, key=lambda x: x[1], reverse=True)
for label, score in results:
    print(f"{label}: {score:.4f}")

Multilingual Support

The model was fine-tuned on English but supports basic generalization to the following languages:

Arabic, Bulgarian, Chinese, German, Greek, English, Spanish, French, Hindi, Russian, Swahili, Thai, Turkish, Urdu, Vietnamese

Performance may vary depending on the language complexity and phrasing.

Training Details

Base Model: microsoft/deberta-v2-xlarge-mnli
Training Set: MultiNLI (Multi-Genre Natural Language Inference)
Approach: Entailment-based zero-shot reformulation
Optimization: AdamW, weight decay, learning rate warm-up
Batch Size: 16
Epochs: 3

Limitations

Model assumes candidate labels are phrased as readable hypotheses (i.e., in English)
Can be fuzzy near category boundaries (e.g., slow vs calculative)
May misclassify creative or ambiguous queries
Inherits biases from MNLI dataset

Citation

@misc{tfs-zs-mnli-2025,
  title={TFS-ZS-MNLI: Zero-Shot Thinking Classification},
  author={BRAHMAI},
  year={2025},
  url={https://huggingface.co/brahmairesearch/TFS-ZS-MNLI}
}

About BRAHMAI

BRAHMAI is on a mission to build the most human-aligned AI systems, starting with how machines think. The TFS (Thinking Fast and Slow) series is our deep dive into cognitive modeling — blending psychology, reasoning theory, and machine learning.

Stay tuned for:

Local-first agents
Cognitive memory architectures
Native reasoning models that choose their own thinking style

Built with soul. Tested with fire. Welcome to the future of cognition.

BRAHMAI RESEARCH — Think Before You Automate.

brahmairesearch
/

TFS-ZS-MNLI