---
id: wiki-2026-0508-support-platforms
title: Support Platforms
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Game Support, Customer Support, Live Ops Support]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, live-ops, customer-support, infrastructure]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: typescript
  framework: helpshift/zendesk
---

# Support Platforms

## 매 한 줄
> **"매 player support 의 retention 의 hidden lever"**. 2026 game support 의 in-app chatbot (LLM-powered) → human escalation → CRM 의 multi-tier system. Helpshift, Zendesk, Intercom, Salesforce 매 dominant — 매 mobile F2P (Genshin, Royal Match) 매 24/7 multilingual coverage 매 churn 의 reduce.

## 매 핵심

### 매 support tier
- **Tier 0 (self-serve)**: FAQ, in-app help center.
- **Tier 1 (LLM bot)**: Claude/GPT-5-powered chatbot — 매 80% 의 query 의 deflect.
- **Tier 2 (human agent)**: refunds, account recovery, complex bugs.
- **Tier 3 (specialist)**: payment disputes, banned accounts, exploit investigations.

### 매 platform 비교
- **Helpshift**: 매 mobile-native, in-game SDK, AI-first (2026 Claude integration).
- **Zendesk**: 매 enterprise, omnichannel, mature ticket workflows.
- **Intercom**: 매 conversational, product-led, Fin AI.
- **Salesforce Service Cloud**: 매 CRM-integrated, 매 large publishers.

### 매 응용
1. Genshin Impact — Helpshift in-app + live chat for refunds.
2. Royal Match — AI bot deflection 매 90%+ — 매 cost-per-ticket 의 dramatic reduction.
3. Riot Games — custom Salesforce + community moderators.

## 💻 패턴

### Helpshift SDK Init
```typescript
import Helpshift from '@helpshift/react-native-helpshift';

Helpshift.install({
    platformId: process.env.HS_PLATFORM_ID,
    domain: process.env.HS_DOMAIN,
    enableInAppNotifications: true,
    enableLogging: __DEV__,
});

Helpshift.setUser({
    userId: player.id,
    email: player.email,
    name: player.displayName,
});
```

### Contextual Metadata Attach
```typescript
function openSupport(reason: SupportReason) {
    Helpshift.showConversation({
        cifs: {
            level: { type: 'number', value: player.level },
            spend_lifetime: { type: 'number', value: player.totalSpendUSD },
            last_purchase: { type: 'date', value: player.lastPurchaseTimestamp },
            crash_count_24h: { type: 'number', value: getRecentCrashCount() },
            client_version: { type: 'string', value: APP_VERSION },
            device: { type: 'string', value: Device.modelId },
        },
        tags: [reason, player.vipTier],
    });
}
```

### LLM Bot Deflection (Claude)
```typescript
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

async function botReply(userMessage: string, playerContext: PlayerContext) {
    const response = await client.messages.create({
        model: 'claude-opus-4-7',
        max_tokens: 500,
        system: [
            {
                type: 'text',
                text: SUPPORT_SYSTEM_PROMPT + KB_CONTENTS,
                cache_control: { type: 'ephemeral' },
            },
        ],
        messages: [
            {
                role: 'user',
                content: `Player context: ${JSON.stringify(playerContext)}\n\nQuery: ${userMessage}`,
            },
        ],
    });
    const reply = response.content[0].text;
    if (reply.includes('[ESCALATE]')) {
        return { escalate: true, reply: reply.replace('[ESCALATE]', '') };
    }
    return { escalate: false, reply };
}
```

### Refund Eligibility Check
```typescript
async function evaluateRefund(ticket: Ticket): Promise<RefundDecision> {
    const player = await getPlayer(ticket.userId);
    const purchase = await getPurchase(ticket.purchaseId);
    
    if (Date.now() - purchase.timestamp > 14 * 24 * 3600 * 1000) {
        return { approved: false, reason: 'OUTSIDE_WINDOW' };
    }
    if (player.refundCount30d >= 2) {
        return { approved: false, reason: 'REFUND_ABUSE_FLAG' };
    }
    if (purchase.consumed && purchase.consumedAmount > 0.5 * purchase.value) {
        return { approved: false, reason: 'CONSUMED' };
    }
    return { approved: true };
}
```

### Ticket Routing
```typescript
function routeTicket(ticket: Ticket): Queue {
    if (ticket.tags.includes('payment')) return 'tier3-payments';
    if (ticket.player.vipTier >= 5) return 'tier2-vip';
    if (ticket.tags.includes('account-recovery')) return 'tier3-trust';
    if (ticket.bot_confidence > 0.85) return 'tier1-bot';
    return 'tier2-general';
}
```

### Sentiment-Triggered Escalation
```typescript
async function checkSentiment(message: string, ticket: Ticket) {
    const sentiment = await analyzeSentiment(message);
    if (sentiment.score < -0.7 || sentiment.flags.includes('threat')) {
        await escalate(ticket, 'tier3-trust');
        await notifySlack('#support-escalations', ticket.id);
    }
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| mobile F2P, in-game support | Helpshift |
| omnichannel (web + game + email) | Zendesk |
| product-led, conversational | Intercom |
| enterprise CRM 매 integrated | Salesforce Service Cloud |
| custom 매 needed | Helpshift API + custom UI |

**기본값**: Helpshift + Claude-powered bot deflection — 매 cost-effective 매 mobile games 의 industry standard.

## 🔗 Graph
- 부모: [[Game Design]] · [[Live Ops]]
- Adjacent: [[Player Retention]]

## 🤖 LLM 활용
**언제**: 매 Tier 1 deflection (FAQ-style queries), translation, sentiment analysis, response drafting for human agents.
**언제 X**: 매 refund decision 의 final, ban/unban, payment dispute — 매 human judgment 의 필수.

## ❌ 안티패턴
- **Bot 만**: 매 escalation path 의 X → user frustration.
- **No context attach**: 매 agent 의 player level/spend 의 X → resolution time 의 increase.
- **24h 의 SLA 의 X**: mobile player expect <2h response.
- **Single language**: 매 global game 의 매 multilingual support 의 mandatory.

## 🧪 검증 / 중복
- Verified (Helpshift docs, Zendesk Game Industry report 2026, Pocket Gamer Connects talks).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — support platform comparison + 6 implementation patterns |