KakaoTalk Native Extension Documentation
The KakaoTalk AI extension for conversation routing, broadcast handling, response pacing, and runtime analytics.
Overview
KakaoTalk Native Extension is the SSNATW AI extension for KakaoTalk. It gives the platform a dedicated runtime for conversation intelligence and routing, so the experience feels native, fast, and fully integrated with the rest of the product.
The extension follows the same marketplace installation and agent attachment model used across SSNATW. After activation, it can run under standard permissions or under ranks that include root access, which can manage the full extension lifecycle, credentials, recovery actions, and advanced controls.
This guide documents the extension as a live product capability. It covers what the extension does, what users can expect to see, which service endpoints support it, and how the core runtime objects are structured.
What this extension delivers
- Stable KakaoTalk conversation handling during high-volume periods.
- Integrated broadcast and reply behavior under one AI extension runtime.
- User-facing analytics that explain message pressure and response quality clearly.
User-facing signals
- Queue size
- Reply pace
- Broadcast effectiveness
Capabilities
KakaoTalk Native Extension is designed as a first-class AI extension. The workflow below describes how the runtime, user experience, and management layer fit together in production.
- Install the KakaoTalk extension and attach it to the agent that owns the channel.
- Define AI behaviors for routing, broadcast windows, and follow-up priorities.
- Track queue, reply, and engagement signals in the extension analytics layer.
API Surface
The extension surface is split into marketplace APIs for discovery and installation, runtime APIs for AI execution and analytics, and management APIs for configuration and advanced control.
| Surface | Method | Path | Purpose |
|---|---|---|---|
| marketplace | GET | /api/marketplace/extensions | List extension offers available in the marketplace catalog. |
| marketplace | GET | /api/marketplace/extensions/:id | Read the marketplace record for KakaoTalk Native Extension. |
| marketplace | POST | /api/marketplace/extensions/install | Install the extension to a private agent or shared agent. |
| management | GET | /api/agents/:agent_id/extensions | List extension attachments on a private agent. |
| management | GET | /api/shared-agents/:agent_id/extensions | List extension attachments on a shared agent. |
| runtime | POST | /api/extensions/native-kakaotalk/runtime/execute | Execute an AI action such as publish, reply, score, route, or monetize depending on the extension family. |
| runtime | GET | /api/extensions/native-kakaotalk/runtime/insights | Read insight data used by analytics cards, trends, and detail views. |
| management | GET | /api/extensions/native-kakaotalk/management/config | Read active runtime policy, access tier, and extension configuration. |
| management | PUT | /api/extensions/native-kakaotalk/management/config | Update runtime policy, AI behavior rules, and extension settings. |
Function Calls and Integration Examples
The following snippets show the extension from a real integration perspective: install it, read its attached state, then drive runtime behavior and analytics through explicit service calls.
Install through the marketplace API
import { installMarketplaceExtension } from '../api/marketplace';
await installMarketplaceExtension({
offerId: <extension-id>,
agentUuid: '<agent-uuid>',
installMode: 'purchase',
notes: 'Enable KakaoTalk Native Extension on the primary KakaoTalk agent.'
});Read installed attachment state
import { listAgentExtensions } from '../api/agents';
const attachments = await listAgentExtensions(<agent-id>);
const installed = attachments.find((item) => item.offer_slug === 'native-kakaotalk');
if (installed?.status === 'active') {
console.log('KakaoTalk Native Extension is live on this agent');
}Execute the AI runtime and read insights
import { apiFetch } from '../api/client';
await apiFetch('/api/extensions/native-kakaotalk/runtime/execute', {
method: 'POST',
body: JSON.stringify({
agent_uuid: '<agent-uuid>',
intent: 'route_conversation',
context: {
platform: 'kakaotalk',
priority: 'high',
resource: 'conversation-snapshot',
conversation_id: '<conversation-id>'
}
})
});
const insights = await apiFetch('/api/extensions/native-kakaotalk/runtime/insights');
console.log(insights.summary);Extension Data Structures
These structures define the core extension object, the installed attachment record, and the runtime data shape used by the AI orchestration and analytics layers.
Marketplace extension record
The catalog object returned by the marketplace extension APIs.
export interface MarketplaceExtensionRecord {
id: number;
slug: 'native-kakaotalk';
name: 'KakaoTalk Native Extension';
version: string;
status: 'active' | 'published' | 'beta' | 'deprecated';
description: string;
author?: string | null;
extension_type: 'social';
platform: 'kakaotalk';
capabilities: string[];
required_permissions: string[];
documentation_url?: string | null;
pricing_model?: 'free' | 'one_time' | 'subscription' | 'revenue_share';
price?: number | null;
revenue_share_percent?: number | null;
is_official?: boolean;
install_count?: number;
rating?: number;
review_count?: number;
created_at?: string;
updated_at?: string;
}Agent extension attachment
The normalized attachment object created after installation.
export interface AgentExtensionAttachment {
id: number;
agent_id: number;
offer_id: number;
offer_name: string;
offer_slug: string;
status: string;
install_mode: 'trial' | 'purchase' | 'queued';
billing_model: string;
revenue_share_percent?: number | null;
upfront_price?: number | null;
notes?: string | null;
created_at: string;
activated_at?: string | null;
}Extension runtime insight payload
The runtime object used by the AI execution and analytics layers.
export interface ExtensionRuntimeInsight {
extension_slug: 'native-kakaotalk';
platform: 'kakaotalk';
agent_uuid: string;
status: 'active' | 'degraded' | 'paused';
summary: string;
metrics: {
reply_rate: 0.81,
queue_pressure: 22,
conversations_active: 184
};
controls: {
automation_mode: 'assisted' | 'autonomous' | 'priority';
access_tier: 'standard' | 'root';
};
updated_at: string;
}MessagingSnapshot
A conversation-level payload for message queue state, routing outcome, and reply performance.
export interface MessagingSnapshot {
extension_slug: 'native-kakaotalk';
platform: 'kakaotalk';
conversation_id: string;
queue_state: 'open' | 'pending' | 'escalated' | 'closed';
assigned_route: 'ai' | 'hybrid' | 'human';
reply_rate: number;
queue_pressure: number;
last_message_at: string;
updated_at: string;
}Extension Lifecycle
- Discover the extension in the marketplace and open its detail page.
- Install it to the target private agent or shared agent through the marketplace installation flow.
- Activate the runtime profile, channel policy, and AI behavior rules that define how the extension should operate.
- Allow the extension to execute publishing, messaging, visibility, or monetization tasks through the AI runtime layer.
- Review health, insights, and control status through the extension management surface.
- Scale, refine, or override behavior as needed through standard controls or rank-based root access.
Platform Notes
- KakaoTalk should remain the canonical platform identifier across routing, analytics, caching, and UI state.
- The user-facing dashboard should stay focused on clear outcomes and not drown the account in low-level noise.
- Configuration, credentials, and advanced controls should stay consistent across marketplace, runtime, and management surfaces.
- Ranks that include root access are allowed to manage installation, runtime policy, credentials, execution controls, analytics settings, and recovery actions across the full extension surface.
- Extension schemas should stay additive and versionable so the runtime can evolve without breaking existing agents or dashboards.
