How Ant's Mobile Edge Computing Container Powers Real‑Time AI on Devices

Background and Challenges

An end‑to‑end mobile intelligence solution typically passes through decision chain development, feature development, model development, and decision‑logic development, but faces problems such as limited basic function support, slow iteration deployment, high‑performance computing constraints on devices, and the need for robust stability across fragmented mobile environments.

Overall Architecture

The edge intelligent computing container is divided into three core components:

Compute Engine : provides the runtime for feature calculation, model inference, Python VM, and task management.

Feature Engine : offers a unified feature service that bridges cloud and device.

Decision Engine : encapsulates a service framework for algorithm and engineering teams.

Developers use the Moobileaix platform and toolkits to streamline development, with a focus on the real‑time compute engine.

Real‑Time Compute Engine

The engine consists of an interface layer for dynamic task definition, a service layer that supplies real‑time aggregation, matching, and chaining data models with a DSL runtime, and a data layer that unifies multi‑stack data collection.

Event Standardization

A unified collection framework based on aspect‑oriented injection standardizes events across native, H5, mini‑programs, and cards, producing consistent data snapshots that feed downstream engines.

Real‑Time Aggregation

Three evolution stages are described:

1.0 : Hard‑coded native logic for quick PoC, but requires client releases for changes.

2.0 : Stores data in relational or time‑series databases; SQL‑based processing introduces latency and IO pressure as data grows.

3.0 : Introduces a real‑time aggregation engine that performs slicing, merging, and various aggregations (count, sum, average, sequence) with hierarchical caching for millisecond‑level retrieval, plus task similarity detection and automatic merging for resource efficiency.

Real‑Time Matching

A DSL described in JSON defines rules that are dynamically pushed to devices, parsed into a pattern list, compiled into an NFA (non‑deterministic finite automaton), and executed as a directed acyclic graph to match complex event sequences in real time.

Real‑Time Chaining

To overcome fragmented ID systems and high resource consumption, a hierarchical tree model (Session → App → Scene → Page) represents user behavior, with leaf nodes for specific actions and source‑target links for navigation, enabling efficient cross‑task reuse and on‑device computation.

Feature Engine

Challenges include low feature reuse, unfriendly development environments, and stability concerns on limited mobile resources. A low‑code platform splits feature work into four stages—development (config, script, or hybrid), debugging (IDE with real‑device deployment, logging, breakpoints), integration (stability and performance testing), and publishing (granular gray‑scale, AB control, cloud‑device joint experiments). The engine provides a unified feature service with routing, permission checks, and a metadata center, while real‑time monitoring alerts on invalid calculations or data drift.

Decision Engine

The decision framework separates trigger timing, decision logic, and action response, allowing engineers to focus on pipelines and algorithms to focus on models. Triggers use automatic instrumentation or rule‑engine events; actions expose common user‑reach channels. Scripts run in a trimmed Python VM with VSCode plug‑ins for one‑click packaging, device deployment, breakpoint debugging, log inspection, and full‑chain mock data. Release supports gray‑scale control, multi‑model AB testing, and cloud‑device joint experiments, plus unified scheduling, audit, and compute‑quota management.