LiveOps Analysis

AE Engage

Operate the AE Engage platform's push channels, task management, config strategies, and journey canvas through ae-cli, upgrading engagement from manual web operations to precise command-line management.

IndustriesAll industries

Agent · Skills Live

skill · loadedindustry+100

Run this Skill on my data

Query console

generated

query.sql · generated

SELECT channel, count(*)

FROM v_payment

GROUP BY channel — 0.4s

12 rows returned

Analysis readyevidence attached

The AE Engage Skill is an engagement-operations management capability in ThinkingAI's industry Skill library. It helps operations teams operate the AE Engage platform's push channels, task management, config strategies, and journey canvas through the ae-cli command-line tool, upgrading from configuring push tasks one at a time in the web UI to precise batch management from the command line. This is ThinkingAI's decade of industry experience, packaged into ready-to-use Skills.

Live walkthrough

AgentSave as AgentExport session

ae-engage

Next Monday we're launching a churn win-back: players who haven't logged in for 14 days, with paying users and high-activity non-payers going through separate Pushes, plus a follow-up SMS for anyone who still hasn't come back after 48 hours. Configuring one task by hand used to take 20 minutes and I'd always get a parameter wrong; this time just build the tasks for me in Engage.

Call +build_task_save_guide to get the required fields and channel-copy schema for the win-back scenario

Returned schemas for both Push and SMS channels plus a list of unsupported combinations

Call +channel_list to confirm the available push channels

Matched 3 channels: JPush / SMS / Webhook

Call +get_cluster_definition_schema to get the audience-definition format

Assemble the audience conditions: 14 days inactive × payment segmentation

Selected 12,847 users (paying tier 3,214 / high-activity non-payers 9,633)

Call +save_task to generate 3 task drafts, dry-run pre-check passed

The tasks are built, 3 drafts total. The 12,847 churned players are split into a paying tier and a high-activity non-payer tier, with SMS used only as a fallback follow-up for those who don't return within 48 hours. No blanket mass-send. Configuration details for a sample SLG game (demo) follow.

1. Win-back task configuration (3 drafts)

Task	Target audience	Trigger timing	Channel	Frequency cap
Win-back – paying tier	14 days inactive and lifetime spend ≥$100 (3,214 users)	Scheduled 20:30 on entry day	Push (JPush)	≤1 in 7 days
Win-back – high-activity non-payers	14 days inactive and ≥20 lifetime login days (9,633 users)	Scheduled 19:00 on entry day	Push (JPush)	≤1 in 7 days
Win-back – silent fallback	No login within 48 hours of the Pushes above	Event-triggered: no return in 48 hours	SMS	≤1 in 30 days

← Scroll to see more

Copy is written in two versions by tier: the paying tier leads with 'exclusive return gift + base resource protection expiry reminder,' and the non-payer tier leads with 'new-season content + your old alliance-mates are online.' Both versions passed the channel-copy schema validation with no missing fields.

2. Engage capability highlights

No guessing parameters for channels or audiences: channelId and targetClusterQp all come from the return values of +channel_list and the audience schema APIs.

Write operations have boundaries: +save_task only generates drafts; the publish action stays a manual confirmation in the console, so the risk of a mis-send is zero.

dry-run pre-check: all 3 drafts passed field validation: the 30%-plus parameter error rate from the manual-config days is caught at this step.

Time comparison: a single task went from about 20 minutes by hand to done in one pass within this conversation.

Recommendation

On day 7 after publishing, pull a data overview from the task module to compare the return rate across the three tasks. For reference, same-genre benchmarks: generic-copy win-back usually returns around 7%, while tiered messaging + fallback follow-up can reach 20%-plus: if the paying tier returns markedly lower than the non-payer tier, suspect the gift's appeal before the messaging itself.

The 3 task drafts are generated (status: draft), awaiting your confirmation to publish in the Engage console.

On your data

That was a simulated run

Leave your work email and we will run a live walkthrough on your real business data.

The problem

Engagement is a core lever for user growth and retention, yet more than 60% of operations teams configure it inefficiently: creating a push task means manually choosing the channel, writing the copy, setting the target audience, and defining trigger rules, averaging 15 to 20 minutes with a parameter error rate above 30%. The journey canvas is more complex, averaging 1 to 2 hours to configure by hand, and multi-language pushes easily miss a language mapping.

What it does

Full coverage of four modules: setting (channel management), task (task creation/query/data), config (strategies/config items/reports), and flow (journey canvas/node schema/reports)

Three-step journey-canvas lifecycle: build, preview, commit, each with self-checks and validation

Task-creation guidance up front: +build_task_save_guide returns the required fields for the scenario, the channel-copy schema, and unsupported combinations

Channel and audience queried up front: before creating a journey or task, query the channel list and audience-definition schema, never guessing channelId or targetClusterQp

Write-operation confirmation: writes like creating, deleting, or enabling/disabling strategies and journeys require explicit intent and support a dry-run precheck

When to use it

You need to query or manage push channels such as Push, WeChat, or Webhook

You need to create a push-task draft or query the task data overview and metric details

You need to query the config-strategy list or copy a config template

You need to create a journey canvas (an automated operations journey)

You need to query the journey node schema or journey report data

In the field

Case

An e-commerce team · creating a churned-user win-back task

Creating a win-back push task by hand took the team 20 minutes and often missed audience conditions. With the AE Engage Skill, the system first called +build_task_save_guide to return the required fields, then +channel_list to confirm the channel ID, +get_cluster_definition_schema to get the audience-definition format, and finally +save_task to create the task draft. Configuration time dropped from 20 minutes to 3 minutes with zero parameter errors.

FAQ

What is the difference between a task and a journey?

A task is a one-time or scheduled push, good for simple engagement. A journey is a multi-node automated flow, good for complex scenarios of trigger, judge, wait, and push again.

Are +save_task and +save_flow write operations?

Yes. save_task creates or updates a task draft, and save_flow runs the build, preview, and commit lifecycle; both require explicit intent.

What must you do before creating a journey?

You must query the channel list and audience-definition schema first, otherwise you cannot fill in required parameters like channelId and targetClusterQp.