From Assisted to Autonomous: AliExpress's Multi-Agent System for Full-Lifecycle Promo Operations
Alibaba AliExpress details their evolution from a Copilot-style page generation tool to a multi-agent system that autonomously manages the entire promotional lifecycle — planning, design, product selection, building, delivery, monitoring, and post-promotion review — using an autonomous driving level framework (L1-L4) to structure system capabilities and human roles.
Background: From Tool to Agent
Large-scale promotional operations (大促运营) span planning, design, building, product selection, delivery, monitoring, and review. Last year's solution was essentially a single-point page generation tool (Copilot + Workflow) requiring extensive manual coordination across business systems. However, foundational work — data standardization, automated strategy production and on/off decisions, centralized placement and coupon capabilities — laid the groundwork for this year's architectural shift to Agents: from "helping operators generate a page" to "operating the entire promotion on behalf of operators." The goal: a main Agent handles intent understanding, plan generation, and resource scheduling; domain Agents execute deterministic tasks (design, build, selection, delivery, inspection); humans focus on strategy judgment, key confirmations, and exception handling.
Four-Dimensional Upgrade
Depth (Technical Vertical Depth) : Last year used Copilot + Workflow deterministic orchestration. Pain points: steps hardcoded; cross-system collaboration/exception branches freeze; no autonomous decision-making; no self-evolution. This year: Agent framework (ReAct decision loop + Plan Mode + long-term memory) + pre-guardrails (role permissions / idempotency / dependency validation). Target: Agent autonomously advances standard nodes; human verifies key decision points.
Breadth (Horizontal Multi-Agent Connection) : Last year: isolated systems, manual stitching. Pain points: "Design → Build → Delivery → AB" information breakpoints; on/off-site material consistency manually ensured. This year: Delivery (on-site ops / PUSH / EDM) / AB / Design platform three-track connection; multi-Agent multi-protocol collaboration (sync call / async message / A2A / scheduled). Target: instruction-driven end-to-end automation.
Business Efficiency (Promo Planning / Product AB / Inspection / Self-Healing) : Last year: single-point page tool; only world knowledge for strategy; no promo-perspective planning; no data/AB/inspection-driven auto-repair. Pain points: can only build pages from existing knowledge; AB/inspection/modification manual; no planning using historical promo data + world knowledge. This year: intelligent promo operations closed loop (executor → reviewer): pre-promo planning + real-time monitoring/AB tuning/auto stop-loss + page inspection auto-detect & repair (HITL). Target: pre-promo planning, mid-promo experiment tuning & risk control; continuously improve ops efficiency.
Self-Growth (Knowledge Accumulation / Co-Construction) : Last year: business knowledge scattered, no unified focus; experience siloed in individuals. Pain points: decisions lack business baseline; cross-promo experience not reusable; no self-growing review knowledge loop. This year: business-product-tech co-construction three-layer knowledge base (expert / case / sample) + post-promo auto-review attribution feeding back into library. Target: "Experience → Knowledge Base → Next Promo" self-growth flywheel; decision quality improves long-term.
Unified Cognitive Framework: Autonomous Driving Levels for Promo Operations
L1/L2 : System assists local ops; driver fully responsible. AliExpress form: build assistant — template-based local page/config generation. Human role: operator.
L3 : System runs autonomously in defined conditions; requests takeover when needed. AliExpress form: current system — main Agent plans, domain Agents execute cross-system. Human role: safety officer.
L4 : End-to-end autonomy within defined operational domain. AliExpress form: end state — pre/mid/post-promo form observable, replayable, evolvable closed loop. Human role: reviewer & strategy maker.
Architecture: Three-Layer Autonomous System Spanning Pre/Mid/Post Promo
Three questions: who thinks, who executes, what does execution rely on? Answer: three layers — Main Agent (unified control plane), seven domain Sub-Agents (professional execution plane split by pre/mid/post), and three foundational platforms (knowledge, data, integration).
Main Agent (ReAct + PlanMode + Long-Term Memory)
Routes incoming requests into five intent types: Create, Modify, Delivery, Q&A/Diagnosis, Data Analysis. Generates dynamic Plan based on promo phase, current state, context. Example: "Create Oct category day promo" expands into cross-domain tasks (planning, design, selection, build, delivery, inspection, review). Any step result change triggers re-planning of affected downstream steps (Re-planning). Responsibilities: intent recognition & phase perception → task routing (Plan-driven) → scheduled scheduling → long-term memory. Does not directly produce business entities; manages call order, dependencies, result flow.
State management: separates compressible conversation memory (dialogue coherence) from persistent facts (Plan, task state, permissions, idempotency). Restart recovers from latest stable checkpoint without re-reading entire session.
Sub-Agents (Vertical Split by Professional Capability)
Planning Agent : generates draft strategy combining promo goals, historical experience, country insights; evaluates ROI/risk. Delivers: confirmable strategy & constraints.
Design Agent : dispatches theme/material requirements; receives theme packs & main KV; completes structured mapping. Delivers: single-source visual assets & version info.
Selection Agent : generates page pool, gameplay views, country parameters; connects algorithmic personalization. Delivers: reusable selection assets & rules.
Build Agent : orchestrates activity space, pages, headers, styles, coupons, strategy scheduling; page quality check. Delivers: runnable venue structure & unique structured result report.
Delivery Agent : assembles strategies for homepage, on-site ops slots, PUSH, EDM; dispatches & collects status. Delivers: unified-semantic channel tasks & execution status.
Inspection Agent : checks page rendering, scheduling, selection validity, material consistency; generates repair plans. Delivers: anomaly evidence, impact scope, executable repair suggestions.
Review Agent : aggregates funnel & experiment results; extracts effective strategies & failure patterns. Delivers: cases, samples, pitfall constraints entering knowledge base.
Three collaboration principles: (1) Capability atomization — one Skill = one clear, independently verifiable action. (2) Domain asset ownership — professional assets produced by owning domain; Main Agent doesn't duplicate facts. (3) Result contractualization — every call returns structured state, domain artifact references, context for next steps.
Three Foundational Platforms
Harness & Knowledge Platform : plan, memory, hooks, permissions, recovery, expert knowledge management — stability & governance.
Data & Algorithm Platform : user, product, industry, promo history, scene data; carries country-level selection, floor personalization, effect attribution — decision evidence.
Agent & Tool Integration Platform : connects design, selection, build, delivery, approval systems. Human-AI interaction, tool calls, cross-team Agent collaboration use appropriate protocols (not one RPC for all).
Missing any layer limits system to partial automation, not full-lifecycle autonomy.
Promo Unique ID (促唯一码): Unified Control & Data Flow Primary Key
Cross-system collaboration prerequisite: same promo uniquely identifiable at any node. Promo Unique ID runs through planning, design, build, delivery, feedback, review — task state, context snapshots, domain artifacts all mounted under same primary key. Provides idempotency & disambiguation; enables cross-domain reconciliation, task tracing, split/merge with consistent caliber. Downstream calls derive stable Action Idempotent ID on top of Promo ID, separating "same promo" from "same action". In Agent engineering, primary key is the starting point for unifying control flow, data flow, audit flow.
Pre-Promo: From Goal Understanding to Executable Route
3.1 Dynamic Planning: Natural Language to Executable Plan
Operator requests in natural language (create promo, add country config, add reach task). Main Agent classifies intent, combines promo phase, domain constraints, historical state → structured Plan with steps, dependencies, required context, executing Agent, human confirmation points. Plan is runtime control plane. Different templates for full create, page modify, delivery adjust. Each step has explicit states (pending, running, done, failed, awaiting human). When domain results or env conditions change, Main Agent re-plans only affected downstream steps, preserving confirmed facts & completed nodes. LLM handles intent understanding & task decomposition; Plan engine enforces execution order & state progression. Separation enables long-cycle tasks: progress visible, pausable, recoverable, adjustable.
3.2 Runtime Boundaries & Tool Governance: Defining What Agent Can Do Each Step
Borrowing ODD (Operational Design Domain) from autonomous driving. Implemented in Plan Mode's "tool governance": dynamically decides allowed tools based on current phase, pre-dependencies, user permissions, risk level. Example: before build completes, delivery tools hidden from model; missing required params → info completion step; high-risk actions marked "requires human confirmation" — only proceed after explicit approval. Core constraints enforced by tool visibility, pre-guardrails, state machine; Prompt only explains current limits.
3.3 Skill Abstraction: Model Understands, System Executes Precisely
LLM good at fuzzy understanding (intent recognition, description completion, template selection); downstream platforms need reproducibility, auditability, replayability. Hard to combine in one model call. Solution: cross-system actions distilled into atomic Skills. Each Skill = Trigger Semantics (when to use) + Input Schema (fields model must fill) + Execution Template (compiles fields into deterministic payload) + Result Schema (returns status & artifact refs to Plan). Model only does first two steps; actual downstream content from template variable substitution.
Shared constraints across design/build/selection/delivery Skills: execution template not freely rewritten by model; downstream receives business values, not internal knowledge IDs; field overflow or missing required → explicit fail, no silent truncation or guesswork fallback. New domain capability → integrate Skill contract only, no new process branch.
3.4 Human-in-the-Loop (HITL): Precise Takeover at High-Risk Nodes
Pre-promo automation uses HITL at high-risk, low-confidence, irreversible nodes: pre-execution permission/idempotency/dependency checks; pre-dispatch key param confirmation; context gaps → human supplements; pre-launch final review. Interaction layer shows structured confirmation cards with Agent's key assumptions, param diffs, impact scope; user can locally modify & continue. For first-time info not derivable from rules/upstream facts, system actively asks & writes confirmation back to knowledge base. As knowledge coverage rises, human takeover frequency should decline, focusing attention on novel, uncertain, high-risk decisions.
3.5 Harness Engineering: Managing Agent Runtime Lifecycle
Promo tasks: long-cycle, multi-step, cross-system, async callbacks. Execution sees context compression, app releases, downstream latency, retries. Harness layer manages full lifecycle from start→execute→recover; model call just one link. Manages layers: compressible dialogue content (semantic coherence); non-lossy fact state (independent persistence); key stage checkpoints; recovery decides auto-retry vs human handoff based on idempotency. Guarantees no skipped steps, no lost key facts, safe recovery after anomalies.
3.6 Cross-Domain Data Flow: Linking Design, Selection, Build, Delivery
Pre-promo breadth measured by whether domain Agents truly chain. Design Agent outputs theme packs & main KV → unified material entry. Build Agent consumes materials → generates activity space, page structure, header, styles, coupon config. Selection Agent provides page pool & floor gameplay. Delivery Agent pulls from unique structured result report → assembles channel strategies. Key metric: upstream domain artifact directly becomes downstream input. Design assets produced once, build results aggregated once, delivery reads from single fact source — transforms manual relay into traceable data flow.
Selection chain adopts "Page Pool + Gameplay View + Algorithm Tag" structure. Base assets no longer linearly replicated per country/page/floor combo. Hot-selling, big-discount, low-price, smart-recommend gameplay expressed via views & algorithm tags; country differences via parameters & samples. Data assets converge, personalization delegated to algorithm — data prerequisite for multi-country scaled hosting.
Mid-Promo: Continuous Perception, Judgment, Action in Dynamic Conditions
Mid-promo complexity: page state, delivery progress, material review, resource scheduling, performance all may deviate. End state needs controlled "Detect → Diagnose → Verify → Execute → Review" closed loop to avoid blind adjustments without evidence.
4.1 Unified State Model: Smoothing Cross-System State Differences
Common cross-platform issue: same task shows different states in different systems. Maps domain execution results to unified task states, aggregated under Promo Unique ID. Main Agent judges completed/rejected/waiting steps, decides next: compensation, clarification, or human intervention. Unified state machine converges sync/async, active callback/polling differences at adapter layer; business side decides only on unified semantics.
4.2 A2A Contract: Unified Rules for Cross-Agent Collaboration
Connects three object types: humans (streaming interaction for plan/progress), enterprise tools (via MCP or domain adapters), other teams' Agents (via A2A for discovery, addressing, auth, task collaboration). Strong-consistency queries, async event callbacks, scheduled polling each use suitable enterprise middleware — not forced into single protocol.
Cross-Agent contract constrains three things: (1) Capability exposed via single entry; channel/scene routing determined internally by domain Agent. (2) Requests carry stable idempotent ID; retries don't create duplicate business entities. (3) Sync acceptance & async completion both map to unified state machine; Main Agent depends only on consistent state semantics. Call chain respects domain boundaries: Main Agent schedules adjacent domain Agents, doesn't bypass their routing/permissions/knowledge to call end systems directly. Adds one hop but preserves governance & independent evolution.
4.3 Observe-Diagnose-Experiment: Evidence-Based Closed-Loop Correction
Mid-promo anomalies enter "Observe → Diagnose → Experiment → Execute" loop: Inspection generates verifiable evidence; Diagnosis identifies anomaly type & impact scope; Verifiable solutions enter experiment/canary; expand execution only after safety guardrails met; auto-rollback if expectations unmet, retaining full experiment records.
Mechanism grounds automation in verifiable evidence. System judges handling via three dimensions: confidence, impact scope, reversibility. High-confidence, low-impact, reversible → auto-execute. Low-confidence or high-impact → HITL, human decides based on evidence.
4.4 Failure Semantics: Distinguishing Failure, Unknown, Waiting
"No result received" in async chain ≠ "execution failed". Could be: not yet accepted, accepted but no callback, remote exception, local query temporarily unavailable. Compensation design distinguishes these states; sets explicit constraints on retry count, trigger timing, concurrency scope. For side-effect actions, system prioritizes verifiable structured state; if unconfirmable → suspend & handoff to human. For delivery-type actions, cost of duplicate dispatch far exceeds slight delay, so no aggressive retries for surface completion rate.
Post-Promo: Turning Every Drive's Experience into Next Capability
Post-promo critical for L3→L4 evolution. If experience not structurally saved, next promo starts from zero; if process not replayable, system can't explain "why did it do that then".
5.1 Decision Trajectory: Full Process Traceable, Key Choices Explainable
Every execution saves necessary process snapshots → "Decision Trajectory": inputs, structured context, knowledge hit versions, plan state, execution results. When results deviate, can replay: at which point Agent saw what info, chose which path, who confirmed, what finally dispatched. Replay serves debugging & builds trustworthy ops system foundation. Only explainable process → credible attribution → reusable experience.
5.2 Context Engineering: Layered Assembly, Precise Retrieval, Version Governance
Goal: within limited context window, continuously improve relevance, completeness, traceability. Promo context split by source: upstream node factual data, operator-maintained domain knowledge, deterministic rule-derived system info. Different sources → different entry/update/validation/expiry strategies. Retrieval uses multi-dimensional addressing: Channel × Chain × Promo Type × Country (Group); matches progressively: country → country group → promo type → global fallback. Assembly loads only info needed for current plan step, with source, version, priority — reduces irrelevant noise. Balances retrieval accuracy, info completeness, token consumption dynamically.
Knowledge base has full lifecycle: instantiate, modify, review, publish, rollback. Task snapshots save raw input, structured params, hit knowledge & versions → minimum replay unit. Downstream reads from single fact source; dashboards only aggregate. Context upgrades from reference material to addressable, composable, evaluable, auditable runtime asset.
5.3 Long-Term Memory: Turning Single Execution into Reusable Experience
Long-term memory extracts, attributes, structures raw execution trajectories. Expert rules → semantic knowledge base; success/failure cases → case library; reusable params/solutions → sample library. Each memory type retains applicability conditions, verification evidence, risk boundaries. Positive experience abstracted as reusable strategies; negative conclusions → failure patterns & safety guardrails; undecided issues → future experiment queue. When these assets actively retrieved, evaluated, referenced in next promo's planning phase, system forms "Execute → Review → Learn → Re-execute" loop.
Four Engineering Principles for Production-Grade Agent Stability
Pre/mid/post automation target different scenarios but repeatedly rely on same principles, converged from multiple promo battles.
6.1 Structured Guardrails: System Constraints Bound Agent Behavior
Runtime phase, tool visibility, permission checks, dependencies, human confirmations — all guaranteed by system structure. Prompt helps model understand task but cannot bear core safety constraints: model occasionally ignores Prompt rule → cost could be wrong delivery. Tool visibility control, pre-guardrails, "requires human confirmation" markers are this principle's implementation.
6.2 Determinism First: Queryable Facts Not Guessed by Model
Model suits intent, semantics, unstructured info. For status codes, task results, fixed rules → prioritize structured interfaces. Example: whether a reach task dispatched successfully → use channel platform's returned status, not model inference from dialogue. Reduces misjudgment risk, improves auditability.
6.3 Context Governance: Primary Key, Version, Source, Snapshot
Primary key for cross-domain alignment; source for credibility assessment; version for change tracking; snapshot for decision scene restoration. In this system: primary key = Promo Unique ID; version & source enter context with knowledge entries; snapshots persist per task. Four together form minimum governance for production Context: no primary key → no cross-domain alignment; no snapshot → can't answer "why did it do that then".
6.4 HITL Convergence: Better Knowledge → Less Human Takeover
Fixed approval flow is just HITL starting point; goal is convergence. System must turn first confirmations into domain knowledge, repetitive confirmations into rules/default policies, continuously monitor human intervention rate, rewrite rate, escalation reasons. Only when human intervention declines as knowledge coverage rises does system evolve from "automated operation interface" to autonomous Agent.
Toward L4: From Instruction Execution to Domain Autonomy
System evolved from local build assistant to cross-domain collaborative execution: within explicit runtime boundaries completes intent understanding, dynamic planning, capability scheduling, state management; HITL handles low-confidence, high-risk, irreversible decisions.
Three directions for L3→L4:
Mid-promo proactive operations : Enhance inspection, diagnosis, experiment, controlled repair so system executes plan AND proposes/validates adjustments based on real-time changes.
Post-promo effect learning : Connect result attribution & strategy沉淀 so planning references verified historical experience beyond templates & static knowledge.
Continuous runtime domain expansion : Under safety/stability/explainability, gradually expand autonomously handled standard scenarios; retain explicit HITL boundaries for non-standard/high-risk scenarios.
Retrospective: Production-grade Agent maturity determined by model capability AND engineering system: ODD defines capability boundaries, Harness ensures runtime reliability, Context Engineering improves decision quality, HITL controls business risk, Long-term memory drives cross-promo continuous evolution. When one promo's experience makes next promo enter correct state faster, the Agent truly embodies "autonomous driving" meaning.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
