Cloud-Edge-Terminal Collaborative Intelligence

• Cloud-Edge-Terminal Collaborative Intelligence (CETCI) is a distributed AI paradigm that unifies cloud, edge, and terminal layers to dynamically allocate tasks and process data.
• It employs model splitting, task offloading, and confidence-based routing to balance latency, accuracy, bandwidth, energy, and privacy in diverse environments.
• CETCI enables efficient video analytics, resilient distributed learning, and enhanced privacy in applications such as smart cities, autonomous driving, and industrial automation.

Cloud-Edge-Terminal Collaborative Intelligence (CETCI) is a distributed AI computing paradigm in which cloud, edge, and terminal layers work together as a single, coordinated intelligent system. In the formulation used for video analytics, Cloud-Edge-Terminal Collaborative Systems (CETC) are distributed computing environments where terminals capture and possibly pre-process video, edge nodes perform near-source computation, filtering, and inference, and the cloud performs large-scale training, heavy inference, global coordination, and long-term storage; CETCI is the algorithmic and system-level intelligence that exploits this three-tier architecture to decide what to compute where, how to split models and pipelines, how to adapt to resource and content dynamics, and how to balance latency, accuracy, bandwidth, energy, privacy, and reliability (Gong et al., 10 Feb 2025). More broadly, CETCI is treated in AIoT research as a concrete instantiation of distributed collaborative intelligence systems in which tasks and models are split, migrated, and co-executed across heterogeneous infrastructures rather than being confined to a single layer (Wu et al., 26 Aug 2025).

1. Definition, scope, and conceptual model

CETCI is defined by the joint operation of three layers with distinct but interdependent roles. The terminal layer comprises IoT devices, sensors, cameras, smartphones, vehicles, wearables, or embedded systems that sense and act on the physical world and perform lightweight pre-processing, simple inference, and control. The edge layer comprises gateways, roadside units, base stations, routers, micro data centers, and edge servers that provide low-latency processing, pre-filtering, aggregation, local inference, caching, and sometimes training. The cloud layer comprises centralized data centers with high computational and storage capacity, used for large-scale training of deep models and LLMs, global analytics, long-term storage, and orchestration (Gong et al., 10 Feb 2025, Wu et al., 26 Aug 2025, Ren et al., 2022).

In the video-analytics formulation, raw video at time $t$ is denoted $V_t$. A canonical hierarchical pipeline places lightweight preprocessing $f_t$ at the terminal, edge-level processing $f_e$ at the edge, and complex models $f_c$ in the cloud, yielding

$$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$

where $g$ represents control or feedback logic such as adjusting terminal capture rate or edge filtering thresholds (Gong et al., 10 Feb 2025). This formulation makes explicit that CETCI is not only a deployment topology but a control problem over representation flow, feedback, and task placement.

The principal motivations are consistent across surveys. Massive deployments of cameras and mobile devices generate continuous high-resolution streams that overwhelm centralized cloud-only architectures. Sending all raw data to the cloud is often infeasible under bandwidth constraints. Applications such as autonomous driving, traffic control, and AR/VR impose sub-second latency requirements. Processing closer to the source can improve privacy by keeping raw data local or restricting transmission to features rather than full content. Battery-powered terminals and resource-constrained edges further require energy-aware scheduling and offloading (Gong et al., 10 Feb 2025). Related work on collaborative inference for AI-empowered IoT devices frames the same problem as a trade-off among inference accuracy, communication latency, privacy, connectivity requirements, and resource limits (Shlezinger et al., 2022).

A plausible implication is that CETCI should be viewed as a continuum of collaborative operating points rather than a single architecture. At one extreme, intelligence is concentrated in the cloud; at another, intelligence is pushed to terminals; between them lie multiple split-computing and hybrid arrangements whose suitability depends on network conditions, task semantics, and trust constraints.

2. Architectural forms and layer responsibilities

Three architectural paradigms recur in the CETCI literature: hierarchical, distributed, and hybrid architectures (Gong et al., 10 Feb 2025). In hierarchical architectures, cloud, edge, and terminal form a layered pipeline, with the cloud orchestrating, the edge performing intermediate computation, and terminals performing local preprocessing. Task allocation across tiers is designed to minimize latency under resource constraints. In distributed architectures, edge and terminals collaborate semi-autonomously with reduced cloud reliance, often through federated learning and decentralized task placement. Hybrid architectures combine the two and adapt placement dynamically using content-aware encoding, transfer learning, and resource-aware scheduling (Gong et al., 10 Feb 2025).

A parallel taxonomy for collaborative DNN inference distinguishes cloud-device, edge-device, cloud-edge-device, and device-device paradigms (Ren et al., 2022). This mapping is important because CETCI encompasses both vertical collaboration across tiers and horizontal collaboration within a tier. Vertical collaboration includes split computing and hierarchical inference across terminal, edge, and cloud. Horizontal collaboration includes device-device partitioning and edge ensembles, where multiple terminals or edge nodes jointly execute parts of a model or combine local predictions (Shlezinger et al., 2022, Ren et al., 2022).

The operational responsibilities of each tier are comparatively stable across domains:

Layer	Primary functions	Representative responsibilities
Terminal	sensing, local preprocessing, lightweight inference	denoising, resizing, ROI detection, motion detection, local tracking
Edge	near-source intelligence and orchestration	VFF, ROIE, feature encoding, mid-depth DNNs, local retraining, caching, scheduling
Cloud	heavy inference, training, global coordination	large-model inference, multimodal understanding, transfer learning, long-term storage

In video analytics, terminals may run lightweight inference such as pedestrian tracking via REVAMP$^2$T or SAMEdge; the edge may apply Video Frame Filtering, ROI Extraction, and feature encoding using methods such as DeGraF, OpenVAD, TransFlow, TVNet, and DLOF; the cloud may execute open-set anomaly detection, complex action recognition, and large-scale multi-object tracking, while training models such as VCReg, Video-LaVIT, and DyAnNet (Gong et al., 10 Feb 2025). In broader edge-cloud deployment practice, automated split systems such as Auto-Split determine a DNN cut point and bit-width assignment so that early layers run on the edge and later layers run in the cloud, balancing transmission cost, memory, and accuracy constraints (Banitalebi-Dehkordi et al., 2021).

Within CETCI, model partitioning is a core mechanism. For a DNN split at layer $k$, the latency can be expressed as

$$T = T_{\text{comp}^{(1:k)}} + T_{\text{tx}(\phi_k)} + T_{\text{comp}^{(k+1:L)}},$$

where $V_t$0 is the intermediate representation at layer $V_t$1 and $V_t$2 is the total number of layers (Gong et al., 10 Feb 2025). In collaborative inference literature, this same principle appears as split computing, where front-end layers are deployed at the terminal or local edge and back-end layers in the cloud (Shlezinger et al., 2022). Architectures specifically designed for collaborative intelligence can reduce the size of offloaded feature tensors substantially by inserting learnable bottlenecks after selected layers; in one such design for ResNet-50, the proposed method achieved on average $V_t$3 improvements for end-to-end latency and $V_t$4 improvements for mobile energy consumption compared to a cloud-only approach, with accuracy loss less than 2% (Eshratifar et al., 2019).

3. Collaborative inference, learning, and adaptation mechanisms

CETCI combines multiple mechanisms for distributing intelligence, of which task offloading, model splitting, feature-level communication, and collaborative learning are the most prominent. A canonical offloading formulation assigns each task $V_t$5 to terminal, edge, or cloud through a decision variable $V_t$6, with latency modeled as

$V_t$7

and the system choosing $V_t$8 to minimize delay subject to energy and bandwidth limits (Gong et al., 10 Feb 2025). In edge-cloud scheduling research, the same idea is cast as an MDP solved by DQN, where the state includes available resources and task demands, the action space assigns tasks to nodes, and the reward combines total processing time, resource utilization, and migration cost (Wang et al., 26 Feb 2025).

Collaborative inference can also proceed through confidence-based routing. ECCENTRIC defines an edge model and a cloud model, with decisions based on edge confidence $V_t$9. In its simplest form, if $f_t$0, inference terminates at the edge; otherwise the sample is sent to the cloud. An adaptive variant instead sends an adapted intermediate feature map to the cloud, allowing the cloud to continue from a suffix of its network rather than from raw input (Kamani et al., 12 Nov 2025). This yields explicit compute-communication-performance trade-offs and constructs Pareto-optimal operating points between edge-only and cloud-only execution.

Collaborative learning in CETCI spans federated, centralized, and hybrid paradigms. In distributed architectures, a standard federated aggregation rule is

$f_t$1

with devices sharing model updates rather than raw data (Gong et al., 10 Feb 2025). A more explicit collaborative learning example is ECAvg, in which edge devices train local models, transfer parameters to the server, the server averages them,

$f_t$2

fine-tunes on the union of local datasets, and pushes improved weights back to clients (Mih et al., 2023). The paper reports that on CIFAR-10 the server model initialized with averaged weights reached 66.96% accuracy, compared with 36.60% for the ImageNet-initialized server model, and edge models improved markedly after update; on MNIST, by contrast, weight averaging led to negative transfer and degraded both server and edge performance (Mih et al., 2023). This establishes that collaboration quality depends strongly on model depth and task compatibility.

Another hybrid learning mechanism is bi-directional knowledge transfer between cloud and edge. ECCT separates federated features on devices from centralized features on the cloud, constructs edge and cloud embeddings, fuses them, and exchanges embeddings and logits bidirectionally so that both sides benefit from local personalization and global context (Li et al., 2023). A plausible implication is that CETCI learning systems need not choose between fully local and fully centralized data assumptions; instead, they can treat each tier as possessing a different feature space and train through representation exchange.

Recent work also connects CETCI to LLMs and multimodal video-LLMs. Surveyed opportunities include unified multimodal understanding, natural-language interfaces for tasks such as “detect abnormal behaviors in zone A,” and high-level cross-layer coordination by central foundation models. The principal challenge is that LLMs and video-LLMs are too heavy for many terminals and edges, motivating collaborative intelligence with lightweight encoders near the source and full reasoning in the cloud (Gong et al., 10 Feb 2025, Wu et al., 26 Aug 2025).

4. Resource management, optimization, and system modeling

CETCI is fundamentally a resource-allocation problem over heterogeneous computing, communication, and storage substrates. A standard end-to-end latency decomposition is

$f_t$3

where processing delay arises from computation at the terminal, edge, and cloud, transmission delay from tier-to-tier communication, and queueing delay from contention and scheduling (Gong et al., 10 Feb 2025). In queue-aware modeling of edge servers, an $f_t$4 model gives utilization

$f_t$5

and average waiting time

$f_t$6

linking arrival rates, service rates, and queue length to system responsiveness (Gong et al., 10 Feb 2025).

Energy and throughput models are similarly explicit. The total energy across $f_t$7 devices may be written as

$f_t$8

while throughput is

$f_t$9

with $f_e$0 the allocated bandwidth and $f_e$1 the data rate on link $f_e$2 for user $f_e$3 (Gong et al., 10 Feb 2025). These formulations support multi-objective optimization such as

$f_e$4

where $f_e$5 is end-to-end delay and $f_e$6 is energy under offloading decision $f_e$7 (Gong et al., 10 Feb 2025).

A more structured offloading model is given in optimal-transport-based edge-cloud collaboration. There, each task is characterized as

$f_e$8

with data size $f_e$9, required CPU cycles $f_c$0, maximum allowable delay $f_c$1, and maximum allowable energy consumption $f_c$2. Local, edge, and cloud execution have distinct delay and energy expressions, and a weighted cost metric

$f_c$3

handles differentiated services (Li et al., 2021). The offloading assignment is then formulated as an optimal transport problem with cost matrix $f_c$4 and transport plan $f_c$5, solved using a Sinkhorn-style regularized method (Li et al., 2021). In simulation with 100 devices and collaborative edge-cloud infrastructure, this OT-based approach achieved the lowest average delay, smallest blocking queues, and higher processing speed than Markov, game-theoretic, and Cross-Edge baselines under bursty loads (Li et al., 2021).

Deep reinforcement learning offers another route to online resource scheduling. In one edge-cloud scheduler, the state includes available computing resources and task demands, the objective is to minimize

$f_c$6

and Q-learning is used to learn scheduling policies (Wang et al., 26 Feb 2025). Experimental results with 10 edge nodes, 3 cloud nodes, and 100–800 tasks show consistently lower processing time and higher resource utilization for DQN compared with priority-based and load-balancing baselines; at 500 tasks, DQN yielded 1050 s total processing time and 93% resource utilization (Wang et al., 26 Feb 2025).

A plausible implication is that CETCI orchestration increasingly requires hierarchical or multi-agent control. Surveys already identify RL-based scheduling, MARL-based decentralized orchestration, and two-timescale optimization for service caching and resource allocation as central mechanisms (Gong et al., 10 Feb 2025, Wu et al., 26 Aug 2025).

5. Privacy, security, reliability, and trust

CETCI improves privacy by allowing sensitive processing to remain near the source, but it also enlarges the attack surface because computation is spread across many heterogeneous nodes (Gong et al., 10 Feb 2025). Common privacy-preserving strategies include on-device preprocessing such as blurring faces or removing sensitive regions, feature-level transmission instead of raw video, federated learning, and local differential privacy. The video-analytics survey specifically names Fed-FSNet for federated learning and HierSFL for local differential privacy (Gong et al., 10 Feb 2025). Collaborative inference research adds that feature-based collaboration is more privacy-preserving than raw-data upload, but intermediate features may still leak information through model inversion attacks; the paper references “privacy fan” as a defense that more aggressively compresses privacy-revealing features while retaining inference-relevant information (Shlezinger et al., 2022).

Reliability is a distinct systems concern. In collaborative DNN inference, node failures can break the inference path. Fault-tolerant distributed DNNs such as deepFogGuard and ResiliNet introduce skip hyperconnections so that if one node fails, intermediate features can bypass the failed segment and preserve end-to-end connectivity (Ren et al., 2022). On unreliable communication channels, feature tensor loss itself becomes a failure mode. Two papers address this directly. One evaluates low-rank tensor completion methods—SiLRTC, HaLRTC, FCP, and ALTeC—for recovering missing deep feature data after packet loss in split inference, using VGG16 and ResNet34 features and packet loss rates from 5% to 30% (Bragilevsky et al., 2021). Another proposes Content-Adaptive Linear Tensor Completion (CALTeC), which reconstructs a missing packet $f_c$7 in channel $f_c$8 using the most correlated channel $f_c$9 and an affine fit

$$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$0

where $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$1 is chosen by Pearson correlation from a spatially neighboring reference packet (Dhondea et al., 2021). CALTeC requires no pre-training and is intended for fast, data-adaptive recovery of intermediate features (Dhondea et al., 2021).

Trust at the edge is an additional prerequisite for deploying CETCI on open infrastructures. “The Trusted Edge” argues that companies may need to run protected business logic on untrusted third-party edge devices, and therefore edge computing requires concepts such as remote attestation, TEEs, hybrid attestation, and swarm attestation to protect both application integrity and the confidentiality of business logic and AI models (Meurisch, 2021). A plausible implication is that CETCI security is not reducible to encrypting transport links; it also requires trustworthy execution environments, attestation-aware orchestration, and policy mechanisms for deciding which tier may process which data.

Trust can also be modeled at the systems level. In socially trusted collaborative edge computing, small-cell base stations form coalitions to share computing resources, but the benefit of collaboration is penalized by a risk term based on pairwise trust $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$2. If direct trust is absent, trust propagates along the shortest social path, and the risk management cost is proportional to offloaded workload and $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$3 (Chen et al., 2017). Although developed for ultra-dense edge computing, this framework suggests how CETCI systems can integrate performance, incentives, and trust into the same orchestration logic.

6. Evaluation domains, representative applications, and research directions

CETCI has been most fully articulated in video analytics, but the application space is broader. Representative scenarios include video surveillance, autonomous driving, smart cities, industrial automation, smart manufacturing, healthcare, and agriculture (Gong et al., 10 Feb 2025, Wu et al., 26 Aug 2025). In video surveillance, the emphasis is on city-scale camera deployments, ROI detection at the edge, anomaly detection in the cloud, and sometimes blockchain-based indexed video (Gong et al., 10 Feb 2025). In autonomous driving, strict latency constraints motivate local or roadside inference for motion-aware action recognition and cooperative perception (Gong et al., 10 Feb 2025). A dedicated cloud-edge-terminal AIGC architecture for autonomous driving places large generative models in the cloud, fine-tuned models at RSUs or base stations, and pruned or quantized models onboard vehicles, supporting perception augmentation, motion prediction, motion planning, traffic simulation, synthetic dataset generation, and human-vehicle interfaces (Zhang et al., 2024).

Evaluation metrics are similarly standardized. Typical CETCI metrics include end-to-end latency $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$4, throughput in fps or streams per node, accuracy such as mAP or F1, energy consumption $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$5 and $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$6, bandwidth usage, QoS/QoE, and reliability or resilience under failures (Gong et al., 10 Feb 2025). The broader AIoT survey adds response time, resource utilization, privacy leakage, attack success rate, and carbon footprint as relevant dimensions (Wu et al., 26 Aug 2025).

Several quantitative patterns recur across the literature. Collaborative DNN inference studies report latency reductions ranging from $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$7 to $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$8 relative to cloud-only or device-only baselines, energy reductions between 25% and 70% or even $$D_t = f_t(V_t),\quad D_e = f_e(D_t),\quad \text{results} = f_c(D_e),\quad C = g(\text{results}),$$9 in extreme cases, and bandwidth reductions up to $g$0 (Ren et al., 2022). In collaborative inference for IoT, edge ensembles of compact MobileNetV2 models on 16 devices can approach or even slightly outperform a centralized MobileNetV2_1.0 when connectivity is high, while using much smaller per-device models (Shlezinger et al., 2022). This suggests that CETCI can exploit both vertical partitioning and horizontal model diversity.

The principal research directions are now converging. The video-analytics survey emphasizes explainable systems, efficient processing mechanisms, advanced video analytics, privacy-aware task placement, resilience under edge outage or network partition, and LLM/multimodal integration (Gong et al., 10 Feb 2025). The AIoT survey adds network virtualization, container orchestration, software-defined networking, hierarchical FL, RL-based optimization, interoperability, and 6G+ networks, agents, digital twins, and quantum computing as future directions (Wu et al., 26 Aug 2025). In cloud-continuum cybersecurity, collaborative DNN synthesis uses trained edge-cloud models to synthesize central cloud models, reducing convergence time while maintaining high detection accuracy; reported intrusion-detection accuracy ranges from 94.52% to 100%, with precision around 96.5%, true positive rate 98.6%, and false positive rate 0.64% (Gupta et al., 2024).

Taken together, these results indicate that CETCI is best understood not as a single algorithm or deployment pattern, but as a systems discipline for coordinating distributed intelligence across cloud, edge, and terminal tiers. Its defining problem is the continual negotiation of where computation, data, and model state should reside under evolving constraints of latency, accuracy, bandwidth, energy, privacy, reliability, and trust.