Building an AI Customer Support Bot with Telegram and AACFlow

Setting up the AACFlow Telegram workflow

Start by creating a Telegram bot via BotFather. The /newbot command gives you a token that looks like:

Add this token to AACFlow as a credential under Settings → Credentials → Telegram Bot Token.

In AACFlow, create a new workflow and add a Telegram Webhook Trigger as the entry block. This trigger:

• Registers a webhook URL with Telegram automatically
• Parses incoming Update objects (messages, callback queries, edited messages)
• Exposes trigger.message.text, trigger.message.chat.id, trigger.message.from.id, and trigger.message.from.language_code

The language_code field is critical for bilingual support. When a Russian-speaking user sends a message from a device set to Russian, language_code will be ru. When an English speaker writes, it will be en. You can use this to route responses in the correct language — but more on that below.

The core workflow: classify, route, respond

The support bot workflow has four stages:

Stage 1 — Intent Classification

The first Agent block receives trigger.message.text and classifies the message into one of five categories:

• billing — payment issues, invoices, subscription changes
• technical — bugs, errors, integration problems
• sales — pricing questions, feature requests, upgrade inquiries
• general — FAQ, hours, contact info
• escalate — angry tone, complex multi-part issues, explicit request for human

The classification prompt is concise:

Stage 2 — Router Block

AACFlow's Router block reads the classification output and sends the flow to the appropriate branch. Five branches, each with a tailored Agent block:

• billing branch: the agent has access to billing tools (retrieve subscription, check payment history)
• technical branch: the agent has access to documentation search and error lookup tools
• sales branch: the agent is given current pricing data as context
• general branch: the agent uses a static FAQ document
• escalate branch: the agent sends an immediate acknowledgment and creates a ticket in your helpdesk

Stage 3 — Language Detection and Response Generation

Each branch Agent block uses the same language detection pattern. In the system prompt:

Claude handles Russian with native quality. You do not need separate prompts or separate workflows for Russian and English — a single agent with this instruction handles both. For languages outside Russian and English, the default English fallback covers most cases.

Stage 4 — Send Response

The final block is a Telegram send_message tool call:

Set parse_mode to Markdown so the agent can use bold, italic, and code formatting in responses. For technical support, code formatting is essential — error messages and commands need to be clearly distinguishable from prose.

Adding conversation memory

A support bot without memory repeats itself. The user writes "my invoice is wrong," the agent responds. Five minutes later the user writes "I meant the invoice from March," and a memory-less bot has no idea what invoice was mentioned before.

In AACFlow, set the Telegram Agent blocks to memoryType: conversation with:

The from.id is the Telegram user's permanent numeric ID. This creates a persistent conversation thread per user. When the same user writes again — today, tomorrow, next week — the agent recalls the full history of prior interactions. No registration required, no cookie, no session token. The Telegram user ID is the key.

For high-volume deployments, use memoryType: sliding_window_tokens with slidingWindowTokens: 6000. This keeps context costs predictable while retaining enough history for coherent multi-turn conversations.

Human escalation: the critical path

No AI handles 100% of cases correctly. The escalation path must be fast, frictionless, and transparent to the user.

In the escalate branch of the Router:

1. The Agent block generates a brief, empathetic acknowledgment: "I'm connecting you with a specialist right now. Please allow 2–3 minutes."
2. A send_message block delivers this to the user immediately.
3. A second tool call creates a ticket in your helpdesk (Linear, Jira, or a simple Notion database via AACFlow integrations).
4. A third tool call — optionally — sends a notification to your internal Telegram group via a different bot token: "New escalation: user @username, issue summary: ."

The key is speed. The user should receive the acknowledgment within 3 seconds of sending their message. The human agent should receive the notification within 5 seconds. AACFlow's webhook-to-execution latency is typically under 800ms, which means the entire escalation chain completes in well under 5 seconds.

Deployment and monitoring

Once the workflow is active, AACFlow's execution dashboard shows every Telegram message that triggered the bot, which branch it took, and the full agent response. Filter by branch to see the ratio of billing vs. technical vs. escalation tickets. If escalations spike, audit the intent classification prompt.

For volume monitoring, add a counter to a simple database (or use AACFlow's Table block) that increments on each execution. A daily report workflow — triggered by a cron schedule — aggregates the counters and sends a summary to your team's Telegram channel.

The result is a customer support operation that handles Russian and English, escalates intelligently, remembers every user, and runs 24/7 without staffing cost. The 60% deflection target is realistic within the first two weeks of deployment.

— Alexandr Chibilyaev