Exactly. You want intent detection, with sentiment as a supporting signal—not a binary positive/negative classifier.

A good output schema would look like:

Input: "I've been comparing your Pro plan with Competitor X. Does it include SSO?"

sentiment: neutral
intent:
  buy: 0.82
  churn: 0.04
  support: 0.11
  information_seeking: 0.71
confidence: 0.89

signals:
  - comparing alternatives
  - asking about a purchase-relevant feature
  - product-specific question

recommended_action: "Sales follow-up"

How I'd build it

Use a multi-label intent classifier rather than forcing every message into one class. Zero-shot classification is particularly useful for prototyping because you can supply your own labels rather than being limited to positive/negative. Hugging Face's zero-shot pipeline explicitly supports arbitrary candidate labels and independent multi-label scores.

Start with intents such as:

• buy — wants to purchase, upgrade, request pricing, evaluate plans
• churn — considering cancellation, switching, downgrading, dissatisfaction
• support — wants help resolving a problem
• information_seeking — researching features, compatibility, capabilities
• comparison — evaluating competitors or alternatives
• renewal — discussing renewal/contract continuation
• complaint — reporting dissatisfaction
• feature_request — asking for something the product doesn't currently offer
• no_intent — conversational or irrelevant content

Then run sentiment separately:

sentiment = {positive, neutral, negative}
intent = {buy, churn, support, ...}

This matters because:

"I love the product, but I'm cancelling because it's too expensive." is positive sentiment + high churn intent, while:

"Your product is amazing. How much is the annual plan?" is positive sentiment + high buy intent.

A sentiment-only model completely misses that distinction.

For production

I'd ultimately fine-tune a model on your own labeled conversations rather than relying indefinitely on zero-shot classification. Your training rows could be:

The important architectural choice is multi-output/multi-label prediction, because a customer can simultaneously be positive, interested in buying, and asking for support. Modern intent systems similarly model multiple intent signals independently rather than treating intent as a single binary outcome.

If you tell me your input source (support tickets, chat, reviews, sales calls, etc.) and whether you want an API, Python library, or SaaS, I can recommend a concrete model/architecture for it.

To detect intent like buying or churning , you need an Intent Classification or Aspect-Based Sentiment Analysis (ABSA) system rather than vanilla sentiment analysis.

Here is a complete guide and a production-ready Python blueprint using the transformers library to build this.

💡 Choosing Your Approach

Depending on your data size and budget, you have three primary ways to build this:

📊 Python Blueprint: Zero-Shot Intent Analyzer

This implementation uses a pipeline that maps text to your specific business intents without requiring prior training.

python``` from transformers import pipeline

class IntentSentimentAnalyzer: def init(self): # Using a robust cross-encoder model trained for Natural Language Inference (NLI) self.classifier = pipeline( "zero-shot-classification", model="facebook/bart-large-mnli" ) # Defining explicit action-oriented labels self.labels = [ "intent to buy", "intent to churn", "product feedback", "customer support request", "casual conversation" ]

def analyze_text(self, text: str):
    result = self.classifier(text, self.labels, multi_label=False)
    
    # Extract the top prediction
    top_intent = result['labels'][0]
    confidence_score = result['scores'][0]
    
    return {
        "text": text,
        "detected_intent": top_intent,
        "confidence": round(confidence_score, 4)
    }

--- Quick Test ---

analyzer = IntentSentimentAnalyzer()

test_phrases = [ "Your pricing is way too high, I am looking at switching to CompetitorX next month.", "Do you guys offer any discounts if I upgrade to the annual enterprise plan today?", "The new UI update looks okay, but it takes two extra clicks to export my data." ]

for phrase in test_phrases: analysis = analyzer.analyze_text(phrase) print(f"Text: {analysis['text']}") print(f"Intent: {analysis['detected_intent']} ({analysis['confidence'] * 100}%)\n")

Use code with caution.

🔎 Why Traditional Sentiment Fails (And How This Fixes It)

Traditional sentiment looks for keywords like "good," "bad," "love," or "hate." Intent analysis focuses on **actionable future behavior**.

- **The Problem:** The sentence *"I love your product but I can't afford it anymore, canceling tomorrow"* contains highly positive sentiment words ("love"), but the business intent is **100% Churn**.
- **The Fix:** The NLI model used above looks at premises and hypotheses. It tests if the text logically implies the hypothesis *"This text demonstrates an intent to churn."* 

🛠️ Production Open-Source Alternatives

If you want to move beyond basic scripts, look into these specialized open-source NLP frameworks:

- **Rasa NLU:** Purpose-built for intent classification and entity extraction. Highly structured and ideal for conversational data.
- **SpaCy (TextCategorizer):** Best if you have 1,000+ labeled examples and want to train a lightning-fast, lightweight pipeline to run locally.

If you want to tailor this further, tell me:

- What is your **data source** ? (e.g., live chat, emails, social media tweets)
- Do you have **historical labeled data** ready, or starting from scratch?
- What is your preferred **tech stack** ? (e.g., Python local, AWS, OpenAI API)

To build a sentiment analyzer that goes beyond basic positive/negative polarity and detects deep intent (such as buying or churning) , you need an intent-driven text classification pipeline . Standard sentiment tools miss the nuance—someone can be furious (−ve negative ve−v e sentiment) but highly motivated to buy a workaround, or completely neutral (0 0 0 sentiment) while canceling their subscription.

Here is a blueprint and architecture to build an intent-aware sentiment and action classifier.

Core Architecture

Instead of a single binary classifier, use a multi-label / multi-class classification setup (or a Large Language Model prompt/fine-tuned encoder) that extracts three dimensions per text:

1. Polarity : Positive, Neutral, Negative
2. Action Intent : Buy, Churn, Support/Help, Feature Request, Feedback (General)
3. Urgency/Confidence : High, Medium, Low

Implementation Options

• Option A: LLM-Based Zero/Few-Shot Prompting (Fastest to Prototype)
  • How it works : Use models like GPT-4o, Claude 3.5 Sonnet, or Llama 3 via API. Structure your system prompt to output structured JSON containing polarity, primary intent, and confidence score.
  • Pros : High accuracy out of the box, excellent at nuance, handles changing definitions via prompt updates.
  • Cons : Higher per-request latency and cost at scale.
• Option B: Fine-Tuned Transformer (Best for Production/Scale)
  • How it works : Fine-tune a lightweight encoder model like DeBERTa-v3 or RoBERTa on a custom-labeled dataset containing intent tags (intent:buy, intent:churn).
  • Pros : Blazing fast inference, cost-effective for millions of rows, runs locally or on private cloud.
  • Cons : Requires a labeled training dataset (≈5 0 0−1 0 0 0 examples per intent class).

Example Data Schema (JSON Output)

Your classifier should output a structured payload like this:

json``` { "text": "Your pricing went up too much, and I'm moving my team to CompetitorX by Friday.", "sentiment": "negative", "intent": { "primary": "churn", "secondary": "competitor_mention", "buying_signal": false }, "urgency": "high", "action_trigger": "immediate_retention_outreach" }

Use code with caution.

Step-by-Step Blueprint to Build It

1. **Define Your Taxonomy** 
	- Specify exact intent labels. For example: `PURCHASE_READY`, `PRICE_SENSITIVE`, `CHURN_RISK`, `ACTIVE_CHURN`, `INFO_SEEKING`.
2. **Gather a Seed Dataset** 
	- Collect historical customer support tickets, chat logs, or app store reviews.[[1]](https://arxiv.org/html/2405.13003v1)
3. **Design the Classifier Prompt (if using LLMs)** 
	- Instruct the model: *"Classify the following customer feedback into Sentiment (Positive/Neutral/Negative) and Intent (Buy/Churn/Support/Other). Output strictly in JSON."* [[1]](https://pipeline.zoominfo.com/marketing/sentiment-analysis)[[2]](https://www.queerinai.com/blog/queer-is-bad-in-sentiment-analysis)[[3]](https://www.sciencedirect.com/science/article/abs/pii/S1566253517306590)[[4]](https://www.questionpro.com/blog/intent-classification/)[[5]](https://aclanthology.org/K18-1016.pdf)
4. **Setup an Evaluation Loop** 
	- Test against a holdout set of 100 messy real-world comments to measure accuracy on edge cases (e.g., sarcasm or angry buyers).
5. **Route the Signals** 
	- Connect high-intent triggers to workflows (e.g., send `intent:churn` directly to your CRM/Customer Success alert system).

Would you like to see a **Python code snippet using an LLM API (like OpenAI or Hugging Face)** to structure this exact JSON output, or would you prefer a guide on **how to label and fine-tune a smaller open-source model**?

Yes — what you want is intent-aware sentiment analysis, where sentiment is just one dimension rather than the final classification.

A useful output for each message would look something like:

The important distinction is that sentiment ≠ intent. A customer can be negative but still intend to stay, or positive while actively considering a purchase. Research specifically finds that purchase intent cannot simply be inferred from positive/negative sentiment.

Intent taxonomy I'd recommend

• Purchase - Ready to buy
• Comparing vendors
• Asking about pricing
• Asking how to sign up/order
• Considering purchase
• Churn - Explicit cancellation
• Considering leaving
• Switching to competitor
• Contract non-renewal
• Frustration indicating likely departure
• Expansion - Upgrade
• Add seats/users
• Buy another product
• Retention / Stay - Will remain if issue is fixed
• Renewal intent
• Positive commitment to continue
• Support - Needs help resolving an issue
• Complaint - Wants a problem acknowledged/fixed
• Feature request - Wants a capability added
• Information seeking - Asking a question without clear buying/churn intent
• Advocacy - Recommending, referring, testimonial interest
• No actionable intent - General commentary with no clear desired action

And I'd allow multiple intents simultaneously. For example:

“I love the platform, but the new pricing is too much. If you can't offer us a better rate, we'll probably move to Competitor X.” Should become:

sentiment: positive_mixed
purchase_intent: none
churn_intent: high
retention_intent: conditional
topic: pricing
competitor_mentioned: Competitor X
urgency: high
recommended_action: retention_offer

That is much more useful operationally than sentiment = negative.

If you're building the analyzer

I'd structure the pipeline as:

Text → sentiment + emotion + topics + intent signals → business outcome prediction → recommended action

Crucially, keep intent detection separate from churn prediction. “I want to cancel” is explicit churn intent; “I'm increasingly frustrated” might be a risk signal without being an actual stated intention to churn.

Modern feedback-analysis systems are already moving in this direction, combining sentiment, intent, urgency, topics, and churn signals rather than treating sentiment as the sole output.

If you're looking for an existing API/tool rather than building one, I can also compare the best current options specifically for purchase + churn intent detection.

Exactly. What you want is intent detection + sentiment, not sentiment analysis with a different label set.

A useful output schema would be:

For example:

“I like the product, but $49/month is too much. If you can't offer a cheaper plan I'll cancel.”

Should become roughly:

{
  "intent": "churn",
  "intent_strength": 0.93,
  "sentiment": "negative",
  "urgency": "high",
  "confidence": 0.95,
  "reason": "Customer explicitly threatens cancellation due to pricing."
}

And:

“This looks great. Can I get pricing for 20 seats?”

{
  "intent": "buy",
  "intent_strength": 0.91,
  "sentiment": "positive",
  "urgency": "medium",
  "confidence": 0.96,
  "reason": "Customer is requesting commercial pricing for a specific quantity."
}

How I'd build it

Use multi-label intent classification, with sentiment as a separate dimension. Zero-shot classification is particularly useful for prototyping because you can supply your own candidate labels rather than being restricted to the labels the model was originally trained on.

A good initial taxonomy might be:

purchase_intent
churn_intent
renewal_intent
upgrade_intent
downgrade_intent
support_intent
refund_intent
comparison_intent
pricing_intent
complaint_intent
feature_request
information_seeking
no_action_intent

Crucially, don't make these mutually exclusive. Someone can simultaneously have:

purchase_intent = 0.87
pricing_intent  = 0.94
comparison_intent = 0.31

That's more useful operationally than forcing the message into one class.

For a prototype, Hugging Face's zero-shot models such as facebook/bart-large-mnli or newer ModernBERT-based zero-shot models can do this without training a classifier from scratch. huggingface.co There are also existing purchase-intent models, although you'd generally want to fine-tune/evaluate against your own customer language rather than blindly adopting one.

The important distinction is that sentiment tells you how they feel; intent tells you what they're likely to do. A customer saying “I love your product, but I'm cancelling” is positive sentiment + extremely high churn intent—which a conventional sentiment analyzer would miss.

If you're building this as a product, I'd make the core output intent probabilities + sentiment + evidence, rather than a single “sentiment score.”

To build a sentiment analyzer that goes beyond basic positive/negative polarity to detect actionable intent (such as buying or churning), you need an intent-driven aspect-based sentiment framework . Standard models only see how someone feels; an intent framework maps what action the user is signaling next.

Here is a blueprint for designing and implementing this kind of analyzer:

• Architecture: Use a multi-task or sequence-to-sequence model (like a fine-tuned transformer or large language model prompt chain) that extracts polarity, target aspects, and primary behavioral intent simultaneously.
• Intent Taxonomy: Define clear target classes beyond sentiment. For Intent to Buy , look for signals like pricing inquiries, feature comparisons, or implementation timelines. For Churn Intent , look for cancellation requests, complaints about unresponsiveness, or comparisons to competitors.
• Feature Signals (Buy): Keywords and phrases indicating a purchase cycle, such as "pricing""pricing""p r i c i n g", "demo""demo""d e m o", "upgrade""upgrade""u p g r a d e", "annual contract""annual contract""a n n u a l c o n t r a c t", or "how to get started""how to get started""h o w t o g e t s t a r t e d".
• Feature Signals (Churn): Keywords and phrases indicating abandonment, such as "cancel""cancel""c a n c e l", "switch to [competitor]""switch to [competitor]""s w i t c h t o[c o m p e t i t o r]", "waste of money""waste of money""w a s t e o f m o n e y", "not working""not working""n o t w o r k i n g", or "refund""refund""r e f u n d".
• Output Structure: Instead of returning a single positive/negative label, output a structured JSON payload containing polarity, primary_intent (Buy, Churn, Support, None), confidence_score , and extracted_aspects.

To help tailor this design, let me know:

• What is your tech stack or preferred environment (Python/Hugging Face, OpenAI API, custom spaCy)?
• Where is your data coming from (customer support tickets, app store reviews, social media)?

A better system is a customer intent + sentiment analyzer, where sentiment is only one signal. You want the model to answer:

1. How does the customer feel? → sentiment/emotion
2. What does the customer want to happen next? → intent
3. What business outcome is likely? → buy, expand, churn, escalate, ignore, etc.

Modern feedback intelligence systems typically combine sentiment with intent, topics, urgency, and churn signals rather than stopping at positive/negative labels.

Suggested classification schema

{
  "sentiment": {
    "label": "negative",
    "score": -0.72,
    "emotions": ["frustration", "disappointment"]
  },
  "intent": {
    "primary": "churn_risk",
    "confidence": 0.91
  },
  "commercial_intent": {
    "buy_signal": false,
    "upgrade_signal": false,
    "renewal_risk": true
  },
  "recommended_action": "customer_success_outreach"
}

Intent categories

Revenue-positive intents

• purchase_intent

  • "How much is the premium plan?"
  • "Can I start a trial?"
  • "Do you offer discounts for teams?"

• upgrade_intent

  • "We need more seats."
  • "Can we increase our limits?"

• expansion_intent

  • "Can this work for our other departments?"

Retention-risk intents

• churn_intent

  • "I want to cancel."
  • "We're switching to another provider."

• renewal_risk

  • "Not sure we'll renew."
  • "The value isn't there anymore."

• competitor_evaluation

  • "We're comparing you with X."

Service intents

• complaint
• bug_report
• feature_request
• billing_issue
• support_request
• question
• praise
• advocacy

Model architecture

A practical pipeline:

Customer message
        |
        v
LLM / NLP encoder
        |
        +--> Sentiment classifier
        |
        +--> Emotion detector
        |
        +--> Intent classifier
        |
        +--> Entity extraction
        |        (product, competitor, plan, feature)
        |
        +--> Outcome predictor
                 |
                 +--> Buy probability
                 +--> Churn probability
                 +--> Expansion probability

Example outputs

Input:

"Love the product, but we're missing Salesforce integration. We may need to look elsewhere."

Bad sentiment-only result:

positive

Useful business result:

{
  "sentiment": "mixed",
  "intent": [
    "feature_request",
    "competitor_evaluation"
  ],
  "business_signal": "churn_risk",
  "churn_probability": 0.78,
  "recommended_action": [
    "notify_customer_success",
    "send_feature_feedback_to_product"
  ]
}

Input:

"Your pricing page looks good. How quickly can we get 50 users onboarded?"

Output:

{
  "sentiment": "positive",
  "intent": "purchase_intent",
  "sales_stage": "evaluation",
  "lead_score": 0.86
}

Training data you need

Label examples with:

The key is that "positive/negative" becomes a feature, not the final answer. Intent should drive routing and revenue actions.

A strong production version would usually be a multi-task classifier or LLM-based classifier fine-tuned on your historical conversations, CRM outcomes, renewals, and purchases.

To build a sentiment analyzer that goes beyond basic positive/negative polarity and detects actionable intent (such as buying or churning), you need an Intent-Aware Aspect-Based Sentiment Analysis (ABSA) or a Zero-Shot Classification/LLM Prompting approach.

Here is how you can architect this type of analyzer, categorized by intent categories and implementation methods.

1. Define Your Intent Taxonomy

Instead of just Positive/Negative , map your labels to specific customer lifecycle triggers:

• Purchase Intent Indicators: Asking about pricing, shipping times, enterprise tiers, feature availability, or upgrade paths (e.g., "How do I upgrade to Pro?", "Do you offer annual discounts?").
• Churn Risk Indicators: Complaining about billing errors, mentioning competitor alternatives, asking how to cancel/delete an account, or expressing deep frustration over unresolved bugs (e.g., "I'm moving to CompetitorX if this isn't fixed", "How do I cancel my subscription?").
• Support/Inquiry: Needing technical help without immediate threat of leaving or buying.
• Neutral/General Feedback: Compliments or complaints that don't trigger a transactional action.

2. Choose Your Implementation Approach

• Approach A: Large Language Model (LLM) Prompting (Fastest & Most Accurate for Nuance)
  • How it works: Feed customer text into an LLM (like GPT-4o or Claude 3.5 Sonnet) with a strict JSON schema output.
  • Why it works: LLMs naturally understand sarcasm, context, and latent intent (like mentioning a competitor as a churn signal) without requiring thousands of labeled training examples.
• Approach B: Fine-Tuned Transformer (Cost-Effective at Scale)
  • How it works: Fine-tune a smaller encoder model like RoBERTa or DeBERTa on a custom dataset labeled with both sentiment and intent tags.
  • Why it works: Lower latency and cost per inference for millions of real-time social media mentions or support tickets.

3. Example JSON Output Structure

A production-ready analyzer should output a structured payload rather than a single string:

json``` { "text": "Honestly considering switching to CompetitorY because your API downtime is killing our workflow.", "polarity": "Negative", "emotion": "Frustration", "intent": { "primary_intent": "Churn Risk", "confidence_score": 0.94, "trigger_phrase": "switching to CompetitorY", "action_required": "Immediate outreach by Customer Success" } }

Use code with caution.

If you want to start building this, let me know:

- **Where the text is coming from** (e.g., live chat, app store reviews, Twitter/X, support tickets)
- **Your preferred tech stack** (Python/Hugging Face, OpenAI API, etc.)

I can provide you with a **starter code snippet** or a **custom prompt template** tailored to your workflow.

Building an intent-driven sentiment and behavioral analyzer requires moving beyond simple polarity (positive/negative/neutral) and mapping text directly to actionable business outcomes like Purchase Intent and Churn Risk.

Here is a structured blueprint, featuring an architectural framework, category breakdown, and a practical implementation pattern using LLM function calling/structured outputs.

Core Architecture & Taxonomy

Instead of a single classification, your analyzer should output a multi-dimensional JSON object.

• Polarity (Contextual): Positive, Neutral, Negative, Mixed (serves as background context, not the primary action driver).
• Primary Intent:
  • PURCHASE_READY : High transactional intent ("Where can I buy this?", "Checking out now").
  • PURCHASE_CONSIDERING : Evaluative/Research intent ("Comparing X and Y", "Does this support Z cap Z𝑍?").
  • CHURN_ACTIVE : Explicit cancellation or defection intent ("Canceling my subscription", "Moving to competitor").
  • CHURN_FRUSTRATED : High friction/complaint risking churn ("If this isn't fixed, I'm done").
  • RETENTION_NEUTRAL : General feedback, support queries, or non-actionable chatter.
• Urgency Level: High, Medium, Low (based on linguistic markers like capitalization, deadline mentions, or severe pain points).
• Key Trigger / Entity: The specific feature, price point, or competitor driving the sentiment.

Step-by-Step Implementation Approach

To achieve high-accuracy intent classification without training a custom model from scratch, use a modern LLM (like GPT-4o or Claude 3.5 Sonnet) configured for Structured Outputs (JSON schema).

1. Data Ingestion: Collect text streams (support tickets, social mentions, product reviews, or chat logs).
2. Prompt & Schema Definition: Instruct the model to analyze the text specifically for commercial intent rather than emotion.
3. Routing & Action Trigger: Route the JSON payload to specific internal queues based on intent flags.

Example JSON Output Schema

json``` { "polarity": "Negative", "primary_intent": "CHURN_FRUSTRATED", "urgency": "High", "confidence_score": 0.94, "trigger_entity": "billing pricing increase", "recommended_action": "Route to retention team for immediate outreach." }

Use code with caution.

Key Linguistic Markers to Watch For

When tuning your rules or writing system prompts, train your analyzer to look for these specific indicators:

- **For Purchase Intent (I b u y cap I sub b u y end-sub𝑰𝒃𝒖𝒚):** 
	- Temporal markers: "tonight", "ready to order", "sign up".
	- Financial/Logistics queries: "payment methods", "shipping time", "discount code", "enterprise tier".
- **For Churn Intent (I c h u r n cap I sub c h u r n end-sub𝑰𝒄𝒉𝒖𝒓𝒏):** 
	- Defection references: "switch to [Competitor]", "cancel my plan", "refund request", "waste of money".
	- Sunk-cost/Ultimatum language: "used to be good", "last chance", "unacceptable downtime".

If you'd like, let me know:

- **Where** this data is coming from (customer support chats, app store reviews, social media, etc.)
- **What tech stack** you prefer to build this in (Python/FastAPI, Node.js, etc.)

I can provide a **ready-to-use Python script** with a structured prompt and Pydantic schema to get your prototype running.

You’re describing intent-aware sentiment analysis (or customer intent intelligence), not traditional sentiment analysis.

A useful system should separate at least three dimensions:

1. Emotion / sentiment

   • Positive, neutral, negative
   • Frustration, excitement, disappointment, satisfaction

2. Customer intent

   • Buy intent
     • “How much does the enterprise plan cost?”
     • “Can I upgrade today?”
     • “Do you offer annual discounts?”
   • Churn intent
     • “I’m looking at alternatives.”
     • “Cancel my subscription.”
     • “This is too expensive for what I get.”
   • Expansion intent
     • “Can we add more seats?”
     • “Do you support larger teams?”
   • Support/escalation intent
     • “I need this fixed immediately.”
     • “I want to speak to a manager.”

3. Business outcome prediction

   • Probability of purchase
   • Probability of churn
   • Probability of renewal
   • Recommended action

This matters because sentiment and intent often diverge. A customer can be positive but not ready to buy (“Looks great, I’ll think about it”), or negative but still likely to purchase (“I hate the onboarding, but I need this product”). Research on purchase intent specifically notes that sentiment alone does not reliably capture purchase intent.

A practical architecture:

Customer message
       |
       v
Intent extraction model
       |
       +--> Sentiment classifier
       |
       +--> Intent classifier
       |       - buy
       |       - churn
       |       - upgrade
       |       - renew
       |       - complain
       |
       +--> Entity/topic extraction
       |
       v
Customer action score
       |
       +--> Sales alert
       +--> Retention workflow
       +--> Support escalation

Example output:

{
  "text": "Your product is great but the price increase means we may switch providers.",
  "sentiment": {
    "label": "mixed",
    "score": 0.42
  },
  "intent": {
    "churn_risk": 0.81,
    "purchase_intent": 0.05,
    "renewal_intent": 0.22
  },
  "drivers": [
    "price increase",
    "competitor evaluation"
  ],
  "recommended_action": "customer_success_outreach"
}

For implementation, I would avoid a single “sentiment model” and use either:

• Fine-tuned transformer classifiers (BERT/RoBERTa-style) for fixed intents
• LLM extraction with structured JSON output for flexible intent taxonomies
• Hybrid approach:
  • LLM extracts intent signals
  • ML model predicts churn/buy probability using historical outcomes

For churn specifically, combine text with behavioral signals:

Text signals:
- "cancel"
- "switching"
- "too expensive"
- "not worth it"

Behavior signals:
- declining usage
- fewer logins
- support complaints
- payment failures
- competitor research

Output:
churn_probability = 0.87

Many intent systems already use this idea: predicting probabilities for behaviors like conversion, exit, return, or add-to-cart rather than forcing binary labels.

If you’re building this, the key design choice is your intent taxonomy. A SaaS company, ecommerce store, and telecom provider would need very different labels.