A Privacy-Preserving TinyML-Driven IoT Edge Architecture for Low-Latency Smart Sensing and Autonomous AI-Based Control

Abstract

As smart sensing applications grow rapidly, the IoT edge architectures need to support low latency, make decisions with little memory, power, and communication resources while preserving the privacy of the data. But traditional cloud-based IoT solutions come with transmission delay, increased energy consumption, and privacy issues because of the constant transfer of raw data. In this paper, we propose a privacy-preserving TinyML-driven IoT edge architecture that enables real-time smart sensing and autonomous AI-based control. The proposed framework includes on-device sensor pre-processing, lightweight TinyML inference, adaptive model selection, encrypted feature-level communication, trust-aware decision validation, and local control execution. Raw data streams from the sensors are also processed locally, and only compact encrypted features or a summary of the decisions are sent if necessary to minimize privacy exposure. The experimental evaluation reveals that the proposed architecture has an accuracy of 97.4%, an F1 score of 96.9%, and a secure-event detection rate of 98.1% and reduces the inference latency by 14.8%, the energy consumption by 4.1 mJ per inference and the amount of data transmitted by 74.5% compared to conventional edge-cloud processing. Results show that the proposed architecture is a scalable, privacy-aware, and energy-efficient solution for real-time autonomous IoT control of smart environments with limited resources.

1. Introduction

With the fast growth of smart sensing, autonomous control, and intelligent Internet of Things (IoT) applications, the demand for low latency, energy efficiency, and privacy-preserving edge intelligence is growing. Modern IoT systems are constantly gathering sensitive streams of data from healthcare wearables, industrial machines, smart homes, environmental nodes, and safety-critical embedded devices. Cloud-centric IoT architectures offer high computational resources but demand raw data to be transferred to distant servers, which leads to communication delay, bandwidth consumption, energy consumption, and privacy risks. Huckelberry et al. [1] recently performed TinyML security research based on the key security constraints of TinyML systems, which are the severe resource constraints and unique security risks, such as physical accessibility, side-channel leakage, memory-limited protection, and model extraction. However, the analysis performed focused on security threats and did not offer a comprehensive low-latency privacy-preserving sensing and autonomous control framework.

Federated TinyML has also been recognized as a privacy-friendly method for IoT edge devices. Ramadan et al. [2] studied the integration of federated learning and TinyML for edge devices and demonstrated that local learning can help minimize exposure of raw data. Federated approaches, however, still cause memory pressure, synchronization delay, and communication overhead, which may not be appropriate for ultra-low power smart sensing nodes. Majeed et al. [3] summarized the solutions that aim to preserve privacy in IoT-based systems, including encryption, anonymization, blockchain, federated learning, and access control approaches. However, most privacy-preserving methods are still considered as out-of-bounds security layers and are not tightly coupled to TinyML inference and autonomous control.

Recent TinyML surveys further show the growing importance of on-device inference. Though TinyML can offer local intelligence with less reliance on cloud computing, current research has issues regarding memory constraints, deployment complexity, model robustness, and real-time adaptability, as explained by Heydari and Mahmoud [4]. Tsoukas et al. [5] discussed the developing TinyML technologies and hardware, software, and application-level developments, but did not cover secure feature-level privacy protection or trust-aware autonomous decision-making. In the same manner, Elhanashi et al. [6] studied TinyML applications, limitations, and impact on IoT devices; however, they mainly addressed general TinyML deployment and did not offer a unified architecture that incorporates privacy, inference, resource awareness, and control.

The protection of privacy in IoT has also received a lot of attention. Rodríguez et al. [7] analyzed the machine learning and deep learning techniques in the context of privacy protection in the IoT and presented the fact that leakage of sensitive data is a major problem, especially in distributed sensing environments. But many of the current privacy-preserving methods are more expensive in terms of processing and are not geared toward TinyML-sized edge devices. Moin et al. [8] put forward the model-driven TinyML support for IoT edge engineering and how edge-based machine learning can help in enhancing the availability, privacy, and sustainability. Their effort, however, was primarily directed towards engineering and deployment support and not secure real-time decision validation. Dutta and Bharali [9] did a review of TinyML for IoT and highlighted the reduction of latency and cloud dependency but did not mention anything about adaptive privacy-preserving control. Although Soro [10] pointed to TinyML as an important technology to enable ubiquitous edge AI, it was mostly abstract in nature and does not describe an autonomous control architecture that can be deployed for privacy-preserving systems.

Based on the above literature, three main research gaps are identified. First, current TinyML research primarily concerns reducing the model size and lowering the power consumption at the inference stage, leaving privacy-aware sensing and secure decision validation as separate processes. Secondly, privacy-preserving IoT approaches are often based on mechanisms that require a significant amount of communication or computation, which are not appropriate for microcontroller-based IoT nodes with constrained capabilities. In summary, most edge-IoT systems view sensing, inference, security, and control as individual components rather than a single, stand-alone system.

This paper now introduces a novel Privacy-Preserving TinyML-Driven IoT Edge Architecture for Low-Latency Smart Sensing and Autonomous AI-Based Control to fill these gaps. The proposed architecture locally pre-processes data, computes privacy-preserving features, validates decisions with trust, performs inference using TinyML, selects models based on available resources, and executes autonomy control at the edge.

The main contributions of this work are:

• A privacy-by-design TinyML edge sensing approach that retains the raw data streams from the sensors at the edge and only sends compact representations of the features or decision summaries protected by AES-128-GCM, thus minimizing raw data exposure and communication overhead.
• Lightweight and INT8-quantized models for low-latency, low-memory, and low-energy TinyML inferences on microcontroller-class and embedded edge devices with a resource-efficient TinyML inference engine.
• A resource-aware adaptive model-selection mechanism that takes into account available memory, battery level, processor load, latency requirements, chip temperature, and input complexity to dynamically choose the most appropriate TinyML inference path.
• A secure decision-validation mechanism based on signal quality, authentication reliability, delay reliability, prediction confidence, and anomaly consistency with validation-derived weights and decision thresholds before accepting or escalating an inference result.
• A unified closed-loop edge-control framework that distributes local sensing, feature communication in a privacy-preserving manner, TinyML inference with adaptability, trust validation, and autonomous control in a deterministic way in a single deployment-oriented pipeline in resource-constrained IoT systems.

The novelty of the proposed work lies in the integration of privacy-preserving feature encoding, resource-aware TinyML model adaptation, trust-aware decision validation, and autonomous edge control within a unified deployment-oriented architecture for resource-constrained IoT devices, rather than proposing a fundamentally new TinyML learning algorithm or privacy-preserving paradigm.

The rest of this paper is organized as follows. In Section 2, related work on TinyML, IoT edge intelligence, and privacy-preserving sensing and secure embedded inference is reviewed. The methodology is proposed in Section 3. Section 4 describes the experimental design and assessment criteria. The results, comparative analysis, ablation study, privacy analysis, and deployment performance are discussed in Section 5. In conclusion, Section 6 summarizes the paper and outlines future research directions.

2. Materials and Methods

Most of the recent research around TinyML and IoT edge intelligence has been directed toward decreasing the need for cloud resources, optimizing energy consumption, and enabling real-time inference on low-power devices. The survey from Abadade et al. [11] offers a broad overview of TinyML—embedded hardware, optimization tools, IoT workflows, and application domains. Although their study demonstrates a reduction in latency, privacy, and power efficiency of TinyML over cloud-based inference, their work was a survey and offered no privacy-preserving autonomous control architecture. Jhaveri et al. [12] studied TinyML for low-power IoT edge consumer devices and highlighted quantization, pruning, and lightweight deployment. The positive aspect of their work is that it is about empowering the edge device, and secure decision validation and adaptive control were somewhat under-addressed.

Karras et al. [13] suggested TinyML algorithms for large-scale IoT data management, such as TinyCleanEDF, EdgeClusterML, CompressEdgeML, CacheEdgeML, and TinyHybridSenseQ. Here, they applied their methodology to edge-based data cleaning and compression, clustering, caching, and data quality evaluation, which are useful for large IoT environments. In the latter case, however, the work was targeted towards data management, but not towards privacy-preserving autonomous actuation. Datta et al. [14] have devised a model to predict air quality in real time for smart cities using TinyML. Their method showed that environment monitoring with low-cost local inference was feasible, and the model was specific to the application without trust aware control security. Xu et al. [15] developed an ultra-low power TinyML visual processing system based on an MCU connected with a neural co-processor. This obtained real-time edge vision with fewer accesses to off-chip memories, but the paper only considered visual processing, not encrypted sensing and secure IoT control.

Research on energy efficiency has also been extensive. Tekin et al. [16] presented an energy aspect on on-device machine learning for IoT, and pointed out the trade-off between accuracy of the models, communication cost, and battery use. The study is helpful for energy-aware TinyML design, but only considers privacy, trust, and control decisions separately. The authors Oliveira et al. [17] proposed the Internet of Intelligent Things, which involves embedded systems, edge computing, and machine learning. The work represents a solid architectural foundation for intelligent IoT but is not limited to TinyML and doesn’t give a specific low-latency privacy-preserving control pipeline.

Another key consideration for IoT edge systems is security and anomaly detection. Anomaly detection in distributed sensing environments has been discussed in a survey by Trilles et al. [18], which demonstrated that local intelligence can aid in the identification of abnormal events. But their study primarily covers anomaly detection studies and does not introduce lightweight secure decision execution. Pazmiño Ortiz et al. [19] presented a holistic system-level perspective for TinyML in resource-constrained IoT, discussing hardware, software, deployment, optimization, and benchmarking. The limitation is that the feature encoding is not designed for privacy, and autonomous control is not the key design aspect. In the study by Terziyska et al. [20] on TinyML in Industrial IoT (IIoT) and Industry 5.0, it is demonstrated that TinyML enables decentralized industrial intelligence. But their work was primarily bibliometric and conceptual.

Alharthi et al. [21] made a systematic review of TinyML in IoT applications in industry, system components, and methodologies. Among their findings were that predictive maintenance, anomaly detection, quality control, and smart energy are all key TinyML use cases, as well as the lack of common benchmarks and incomplete deployment pipelines. Villegas-Ch et al. [22] developed an optimization of federated learning on TinyML devices to protect privacy and reduce energy consumption, which was found to be lower than the centralized approach. Nevertheless, federated learning still needs to synchronize communication, which might not be well-suited to ultra-low-latency autonomous control. Saha et al. [23] introduced TinyNS, a platform-aware neurosymbolic AutoTinyML approach which enhances model selection for microcontroller-class hardware. It will have the benefit of platform awareness, but it will not be concentrating on encrypted sensing or control safety.

Alwaisi et al. [24] proposed a lightweight ML technique to detect and prevent anomalies in constrained IoT systems. While their approach enhances security in resource-efficient ways, it is mainly detection-focused and does not link to autonomous control based on TinyML. Dehrouyeh et al. [25] investigated TinyML in EV charging stations for cybersecurity and demonstrated that TinyML can decrease delay and memory consumption in contrast to traditional ML. However, it is a use case for a specific domain and not generalized privacy-aware sensing for large-scale IoT control environments.

Edge AI helps to reduce the dependency on the cloud and facilitate real-time intelligent decision-making as reviewed by Hua et al. [26] from a machine-learning point of view. Their work was, however, general and not specific to the TinyML level of privacy-preserving autonomous control. Prabha et al. [27] introduced a secure Edge AI wireless IoT system for real-time healthcare monitoring and federated anomaly detection. The system had good security capabilities to monitor, but it is specific to the healthcare domain and relies on federated communication, which can mean synchronization costs. Bhushan et al. [28] enabled energy-efficient object detection on low-power edge AI systems by deploying TinyML and showed that quantization is beneficial for MCU-level inference, with emphasis on visual object detection instead of general smart sensing and control. Kargar et al. [29] introduced a concept-drift mitigation method for resource-constrained IoT devices by means of self-learning, where the main focus of the approach was on model adaptation, rather than privacy-preserving decision validation.

Do et al. [30] proposed multi-modal sensor fusion and federated learning for TinyML on constrained IoT devices, demonstrating the benefits of using distributed learning and sensing fusion, but communication overhead and autonomous control execution are still issues to be addressed. In recent years tinyML embedded inference has been leveraged to enable binarized neural-network models for real-time classification, demonstrating how lightweight architectures can be used for constrained edge devices; the work, however, is limited to real-time classification and does not include privacy preserving sensing, trust validation or autonomous AI-based control [31]. Additionally, trust-aware privacy-preserving data aggregation has been explored for IoT-enabled wireless mesh communication networks, where secure data handling enhances privacy at the network level; but this work mainly addresses the aggregation at the communication layer and does not offer local inference capabilities and low-latency autonomous control at the edge with TinyML [32].

In summary, it can be verified that TinyML, edge AI, anomaly detection, and privacy-preserving IoT are active research fields from the literature under review. However, many studies focus on only one aspect: either model compression, energy optimization, anomaly detection, federated privacy, or application-specific sensing. The single architecture capable of performing privacy-preserving features encoding, low-latency TinyML inference, resource-aware model selection, trust-based decision validation, and autonomous control based on AI is still poorly explored. Hence, Table 1 is proposed to fill this gap by incorporating sensing, privacy, inference, security, and control functionalities within a single low-latency IoT edge architecture.

Table 1. Literature review summary and research gap analysis with percentage-based results.

Ref.	Author/Year	Method/Focus	Reported Result (%)	TinyML Edge	Privacy	Adaptive Selection	Trust Validation	Autonomous Control	Main Limitation
[11]	Abadade et al., 2023	Comprehensive TinyML survey	≈90–95	✓	✗	✗	✗	✗	Survey only
[12]	Jhaveri et al., 2024	Quantized low-power TinyML	≈92.4	✓	✗	✗	✗	✗	No secure validation
[13]	Karras et al., 2024	TinyML-based IoT data management	≈94.1	✓	✗	✗	✗	✗	Data-management focused
[22]	Villegas-Ch et al., 2024	Federated TinyML optimization	≈95.6	✓	✓	✗	✗	✗	Synchronization overhead
[24]	Alwaisi et al., 2024	Lightweight anomaly detection	≈96.2	✓	✗	✗	✗	✗	Detection only
[27]	Prabha et al., 2026	Secure Edge AI healthcare monitoring	93.7/90.8	✓	✓	✗	✗	✗	Healthcare-specific
[28]	Bhushan et al., 2025	Quantized TinyML object detection	86–88	✓	✗	✗	✗	✗	Vision-specific
[30]	Do et al., 2025	Multi-modal federated TinyML	≈96.8	✓	✓	✗	✗	✗	Communication overhead
[32]	Kamesh and Gobalakrishnan, 2026	Trust-aware privacy aggregation	≈97.1	✗	✓	✗	✓	✗	Network-layer focus
	Proposed Framework	Adaptive privacy-preserving TinyML control	97.4/98.1	✓	✓	✓	✓	✓	—

Notation: ✓ = included; ✗ = not included. For [27], the values indicate accuracy/F1-score; for the proposed framework, they indicate accuracy/secure-event detection.

3. Methodology

3.1. Overall Proposed Privacy-Preserving TinyML Edge Architecture

A TinyML-based IoT edge architecture for privacy-preserving low-latency smart sensing and autonomous AI-based control is proposed. The architecture aims to minimize reliance on the cloud by processing sensing, pre-processing, privacy encoding, TinyML inference, secure decision validation, and control execution at the edge node. Conventional IoT systems send raw sensor data to cloud servers for analysis, leading to high bandwidth consumption, energy usage, latency, and privacy risks. To address these restrictions, the presented framework aims to process raw streams of the sensors locally and send encrypted features, decision summaries, or alerts if necessary. The six main stages of the entire pipeline are smart sensing data acquisition, lightweight edge pre-processing, privacy-preserving feature encoding, adaptive TinyML inference, trust-aware secure decision validation, and autonomous control generation. The complete processing flow is shown as Equation (1):

$$X\mathrm{ₜ}\to W\mathrm{ᵢ}\to X^{\prime }\mathrm{ᵢ}\to F\mathrm{ᵢ}\to F\mathrm{p}\mathrm{ᵢ}\to M*\to \mathrm{ŷ}\mathrm{ᵢ}\to S\mathrm{ᴅ}\to A\mathrm{ₜ}$$

(1)

where X_t is the raw sensor packet at time t, W_i is the temporal sensor window, X′_i is the pre-processed window, F_i is the extracted feature vector, F^p_i is the privacy-preserved feature, M* is the selected TinyML model, ŷ_i is the predicted output, Sᴅ is the secure decision score, and A_t is the final autonomous control action. The proposed architecture locally pre-processes sensor data, runs TinyML inference, processes sensor data privately, validates it with trust-awareness, and executes real-time control in Figure 1.

Figure 1. Overall privacy-preserving TinyML edge architecture for real-time smart sensing, secure inference, trust validation, and local autonomous control. Black arrows indicate the direction of processing and feedback through the sensing, preprocessing, TinyML, and decision-control stages; the differently colored dots below the feature-vector block are an illustrative grouping of extracted feature vectors and do not encode an additional quantitative variable.

3.2. Dataset Collection, Smart Sensing Acquisition, and Window Formation

The dataset collection and smart sensing data acquisition stage is included in the proposed methodology to illustrate how the raw IoT sensing data is prepared for privacy-preserving TinyML inference. The proposed framework is validated with heterogeneous IoT sensor streams from smart sensors deployed in smart sensing applications like industrial monitoring, smart-home automation, environment sensing, wearable sensors or autonomous embedded control. Each data sample is a set of reads from the various sensors and channels, a set of timestamps, a set of signal-quality indicators, and a set of authentication indicators. Depending on the application, the sensor channels can be temperature, humidity, vibration, pressure, gas concentration, light intensity, voltage, current, acoustic signal, motion, or physiological signals. Each sensor packet is provided in Equation (2).

$$X_{\mathrm{t}}=s_{1\mathrm{t}},s_{2\mathrm{t}},\dots ,s_{\mathrm{n}\mathrm{t}},{\tau }_{\mathrm{t}},q_{\mathrm{t}},a_{\mathrm{t}}$$

(2)

The variables s_1t to s_nt are n sensor-channel readings, the variable τ_t represents the timestamp, the variable q_t represents the quality of the signal, and the variable a_t indicates the level of authentication. In order to keep the temporal behavior, the continuous stream is segmented into windows of fixed length, as described in Equation (3).

$$W_{\mathrm{i}}=X_{\mathrm{t}},X_{\mathrm{t}+1},\dots ,X_{\mathrm{t}+\mathrm{k}-1}$$

(3)

The i-th sensing window is W_i and the window length is k. The data set is then split into a training set, a validation set, and a test set, typically 70:15:15. This window-based formation supports low-memory TinyML inference without losing signals’ variations in time, abnormal transitions, and real-time control patterns. The proposed framework was tested with a heterogeneous IoT sensing dataset consisting of 24,000 temporal sensing windows obtained from various edge sensing applications. Each sensing window had 128 samples of eight synchronized sensor channels, namely temperature, humidity, vibration, pressure, ambient light, acoustic signal level, voltage, and current measurements, as shown in Table 2. Before feature extraction, all sensor streams have been aligned with a timestamp-based alignment.

Table 2. Class-wise distribution of the experimental dataset across training, validation, and test sets.

Class	Training Set (70%)	Validation Set (15%)	Test Set (15%)	Total Samples	Distribution (%)
Normal operation	6720	1440	1440	9600	40.00
Environmental anomaly	3780	810	810	5400	22.50
Device fault	3360	720	720	4800	20.00
Security event	2940	630	630	4200	17.50
Total	16,800	3600	3600	24,000	100.00

3.3. Lightweight Edge Pre-Processing

In practice, IoT sensor streams are plagued by noise, missing data, delayed packets, outliers, duplicated data, and inconsistent sampling. Hence, a lightweight edge pre-processing module is used prior to feature extraction and TinyML inference. The pre-processing operations are kept to a minimum, memory efficient and microcontroller level appropriate as the proposed system is intended for resource constrained edge devices. Initially, the time delay is calculated for the packets, and if the received sensor data is delay-free, then it can be used for real-time decision-making in Equation (4).

$$D_{\mathrm{t}}={\tau }_{\mathrm{r}}-{\tau }_{\mathrm{s}}$$

(4)

where τᵣ is the packet reception time, and τ_s is the packet sending time. If D_t is greater than the maximum allowed delay D_max, the packet is marked as unreliable. Then, invalid readings and outliers are removed based on sensor-specific physical thresholds. To suppress short-term signal fluctuations, a moving-average filter is applied in Equation (5)

$$\overline{x_{\mathrm{t}}}=\left(1/m\right){{\Sigma }_{\mathrm{j}=0}}^{\mathrm{m}-1}{x}_{\mathrm{t}-\mathrm{j}}$$

(5)

Here, m is the filter length. After filtering, each signal channel is normalized using min–max scaling in Equation (6):

$$x\mathrm{\prime }\mathrm{ₜ}=\left(x\mathrm{ₜ}-x\mathrm{ₘ}\mathrm{ᵢ}\mathrm{ₙ}\right)/\left(x\mathrm{ₘ}\mathrm{ₐ}\mathrm{ₓ}-x\mathrm{ₘ}\mathrm{ᵢ}\mathrm{ₙ}+\epsilon \right)$$

(6)

where ε is added to prevent dividing by zero. This pre-processing step enhances the signal quality, renders TinyML inference more stable, decreases the false alarm rate, and enables embedding of TinyML inference in INT8.

3.4. Privacy-Preserving Feature Encoding

One of the key modules of the proposed architecture is the privacy-preserving feature encoding module. The raw streams from sensors can provide insight into sensitive user behavior, health status, location patterns, occupancy, industrial operation status, or environmental activities in many IoT applications. Thus, the proposed framework does not involve transmitting raw sensor signals on an ongoing basis. Compact statistical, temporal, and quality-aware features are extracted locally from each pre-processed window instead. A feature vector is provided in Equation (7):

$$F\mathrm{ᵢ}=\left[\mu ,\sigma ,RMS,E,\Delta x,H,ZCR,Q\right]$$

(7)

The symbols μ (mean), σ (standard deviation), RMS (root mean square), E (signal energy), Δx (temporal variation), H (entropy), ZCR (zero-crossing rate), and Q_s (signal-quality score) indicate their definitions in the respective formulas. The mean and standard deviation are calculated as Equations (8) and (9):

$$\mu =\left(1/k\right){{\Sigma }_{\mathrm{t}=1}}^{\mathrm{k}}{x\mathrm{\prime }}_{\mathrm{t}}$$

(8)

$$\sigma =\surd \left[\left(1/k\right){{\Sigma }_{\mathrm{t}=1}}^{\mathrm{k}}{\left({x\mathrm{\prime }}_{\mathrm{t}}-\mu \right)}^2\right]$$

(9)

The RMS and energy are calculated as Equations (10) and (11):

$$RMS=\surd \left[\left(1/k\right){{\Sigma }_{\mathrm{t}=1}}^{\mathrm{k}}{\left({x\mathrm{\prime }}_{\mathrm{t}}\right)}^2\right]$$

(10)

$$E={{\Sigma }_{\mathrm{t}=1}}^{\mathrm{k}}{\left({x\mathrm{\prime }}_{\mathrm{t}}\right)}^2$$

(11)

To protect the extracted features, lightweight masking or encryption is applied in Equation (12):

$$F\mathrm{p}\mathrm{ᵢ}=Enc\left(F\mathrm{ᵢ},K\mathrm{ₑ}\right)$$

(12)

where Enc(.) is the privacy-preserving transformation, and K_e is the edge encryption key. With this, only the protected features or decision summaries are passed, and the raw data are left in the edge device. The local sensor features are then encrypted before being transmitted for privacy-preserving TinyML inference, as illustrated in Figure 2.

Figure 2. Privacy-preserving feature encoding for secure TinyML inference. Solid arrows indicate the local processing and protected transmission flow; the crossed raw-signal path denotes that unencrypted sensor streams are not transmitted. The different trace/node colors distinguish sensor streams and schematic processing/inference groups only; they do not represent an additional quantitative scale.

The proposed method is not a new paradigm of privacy-preserving learning, like Federated Learning, Differential Privacy, Homomorphic Learning, or Secure Multi-Party Computation. Its contribution is a resource-efficient privacy-by-design communication mechanism for microcontroller-class TinyML nodes. Raw sensor windows are retained on the device; 64-dimensional statistical and temporal feature vectors are extracted locally, and only AES-128-GCM-encrypted features or compact decision summaries are transmitted. The privacy contribution therefore revolves around minimizing the exposure of raw data, and directly embedding the communication of protected features with TinyML inference, trust validation, and edge control.

The design is based on a privacy-by-design principle comprising local feature extraction and AES-128 encrypted feature transmission. The threat model assumed is that communication channels are not trusted; however, trusted edge devices keep encryption keys local. As a consequence, raw sensor streams never leave the edge device, significantly decreasing the exposure of raw data in communication. The proposed architecture is mostly for the confidentiality of the data in communication, and does not completely prevent the leakage of metadata due to packet timing, transmission frequency, or device identifiers. This side channel information has not been considered in the current threat model, but it is recognized as a limitation for future investigations. While some statistical features are able to maintain limited information about behavior, this is significantly less than continuous raw streams of data from the sensors. The features are selected to enable efficient and low-power TinyML inference and are secured with encrypted transmission to reduce exposure while ensuring real-time inference on low-resource edge devices.

3.5. TinyML-Based Edge Inference Engine

TinyML inference engine: Predictions are made on the IoT edge device using lightweight, optimized AI models, in real-time. The new engine will operate within tight memory, energy, and latency requirements. The architecture enables the use of a model pool, comprising lightweight machine learning, INT8 quantized neural inference, and compact temporal TinyML models, instead of relying on a single model for all sensing conditions. TinyML inference output is written as Equation (13)

$$\mathrm{ŷ}\mathrm{ᵢ}=fTinyML\left(F\mathrm{p}\mathrm{ᵢ};\theta q\right)$$

(13)

In this instance, the model parameters are quantized, and privacy-preserved feature vectors are denoted as Fᵔ_i, where ŷ_i is the predicted state or control class, and $\theta q$ are the quantized model parameters. If the inference is light, a simple classifier can be used to get the prediction probability in Equation (14):

$$P\left(y|F\mathrm{ᵢ}\right)=\sigma \left(WF\mathrm{ᵢ}+b\right)$$

(14)

where W is the weight matrix, b is the bias term, and σ(.) is the sigmoid (or softmax) activation function. To minimize the memory usage and inference time, the weights of the FP32 model are quantized to INT8 representation in Equation (15):

$$w_q=round\left(w/s\right)+z$$

(15)

where $w_q$ is the quantized weight, w is the original floating-point weight, s is the scale factor, and z is the zero-point. This allows for quicker inferences while requiring less memory and energy. Thus, the TinyML engine can enable low-latency smart sensing and autonomous control without cloud computing. TinyML edge inference engine with model selection, INT8 inference, and local decision output shown in Figure 3.

Figure 3. TinyML-based edge inference engine for real-time local decision-making. Arrows indicate the data/model flow from offline optimization and privacy-preserved inputs through the model pool, adaptive selector, inference, and output stages; the different colors distinguish functional modules and do not represent quantitative values.

3.6. Resource-Aware Trust-Guided Adaptive Model Selection

To improve accuracy, latency, memory usage, energy efficiency, and decision safety, the proposed framework combines resource-aware model selection with trust-aware secure validation. In real IoT edge deployments, device conditions continuously change due to battery drain, memory limitation, processor load, chip temperature, latency deadline, and input complexity. As shown in Figure 4, the adaptive selector chooses the optimal TinyML path using resource, complexity, trust, and decision scores.

Figure 4. Resource-aware trust-guided adaptive TinyML path-selection framework. Arrows indicate the flow of resource, input-complexity, trust, and secure-decision scores into path selection; M* denotes the selected TinyML model/path.

Therefore, instead of using a fixed TinyML model, the proposed system first evaluates the current resource vector shown in Equation (16):

$$R_{\mathrm{t}}=\left[M_{\mathrm{a}},B_{\mathrm{l}},C_{\mathrm{p}},L_d,T_{chip}\right]$$

(16)

where Mₐ, B_l, C_p, ${\mathit{L}}_{\mathit{d}}$, and ${\mathit{T}}_{\mathit{c}\mathit{h}\mathit{i}\mathit{p}}$ represent available memory, battery level, processor load, latency deadline, and chip temperature. The input complexity is estimated as Equation (17):

$$C_{\mathrm{x}}={\alpha }_{1}Var\left(W_{\mathrm{i}}\right)+{\alpha }_{2}H\left(W_{\mathrm{i}}\right)+{\alpha }_{3}A\left(W_{\mathrm{i}}\right)$$

(17)

Based on these values, the optimal TinyML model is selected as Equation (18):

M* = argmin M [λ₁L(M) + λ₂E(M) + λ₃Mem(M) − λ₄Acc(M)]

(18)

After inference, the prediction is validated using signal quality, authentication reliability, delay reliability, confidence, and anomaly score in Equations (19)–(21):

$$T_{\mathrm{s}}={\beta }_1{Q}_{\mathrm{s}}+{\beta }_2{A}_{\mathrm{r}}+{\beta }_3{D}_{\mathrm{r}}+{\beta }_4{P}_{\mathrm{c}}-{\beta }_{5}A\mathrm{n}$$

(19)

$$P\mathrm{꜀}=max\left(P\left(y|F\mathrm{ᵢ}\right)\right)$$

(20)

$$S_{\mathrm{ᴅ}}={\gamma }_{1}P\mathrm{꜀}+{\gamma }_2{T}_{\mathrm{s}}-{\gamma }_{3}A\mathrm{ₙ}$$

(21)

When $S_{\mathrm{ᴅ}}$ reaches the threshold, the decision is accepted, or the system resamples or scales up to a more powerful TinyML model. The coefficients used in adaptive model selection and trust-aware validation were determined using the validation set rather than being selected arbitrarily. A constrained grid search was performed with coefficient increments of 0.05, while requiring the weights in each score to sum to one. The resource score gives the following weight for available memory, battery level, processor availability, latency compliance, and thermal safety: 0.24, 0.18, 0.15, 0.27, and 0.16. The weights of the trust score are as follows: 0.28 for signal quality, 0.24 for authentication reliability, 0.14 for delay reliability, 0.22 for prediction confidence and 0.12 for anomaly consistency.

The decision is accepted if the trust score is above 0.75 and the secure decision score is above 0.80; otherwise, the sample is re-acquired or passed to a more competent model. The adaptive model selector is not a straightforward if—else process. For each sensing window, it finds the best utility score (weighted) for each deployable model that meets the current memory, latency, energy, and temperature constraints. The lightweight classifier, INT8 neural model, and temporal TinyML model are chosen when the normalized resource score is below 0.45, between 0.45 and 0.70, and above 0.70, respectively.

3.7. Autonomous AI-Based Control Unit

The validated TinyML prediction is converted to an instant control response by an autonomous AI-based control unit. This module can make the proposed architecture a closed-loop control system at the edge with real-time control. Depending on the application, the control output may be an activation of actuators, shutdown of selected devices, warning alert, regulation of the speed of the motors, switching energy modes, environment adjustment, fault isolation, and emergency response. The final decision action is based on the predicted state and secure decision score and the current resource situation in Equation (22):

$$A\mathrm{ₜ}=\pi \left(\mathrm{ŷ}\mathrm{ᵢ},S\mathrm{ᴅ},R\mathrm{ₜ}\right)$$

(22)

where A_t is the final autonomous control action, π(.) is the control policy, ŷ_i is the predicted output, Sᴅ is the secure decision score, and R_t is the device-resource vector. The use of a multi-level decision policy for the control unit in Equation (23) improves the operational safety:

$$A_t=\{\begin{array}{cc}{A}_{\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}\mathrm{a}\mathrm{l}},& \mathrm{if} S_D\ge {\theta }_h,\\ A_{\mathrm{w}\mathrm{a}\mathrm{r}\mathrm{n}},& \mathrm{if} {\theta }_l\le S_D<{\theta }_h,\\ A_{\mathrm{s}\mathrm{e}\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{e}},& \mathrm{if} S_D<{\theta }_l.\end{array}$$

(23)

where θ_h and θ_l are high and low decision thresholds, respectively. In normal mode, the action will be executed immediately. In warning mode, limited control and alert notification are carried out. For unreliable data, the system will reject it in secure mode, asking for resampling. This ensures safe and privacy-aware autonomous control. The autonomous AI control loop is presented in Figure 5, which includes autonomous TinyML prediction, trust validation, action execution, and sensor feedback.

Figure 5. Autonomous AI-based control unit with closed-loop feedback. Arrows show data/control/feedback flow; ŷi, SD, Rt, π(·), θl/θh, and At denote prediction, secure decision score, resource state, control policy, low/high thresholds, and final action. Colored letters in panel (c) schematically represent the validation factors combined by the secure-decision logic.

3.8. Embedded Deployment and Model Optimization

The designed TinyML edge architecture is tailored to run on embedded hardware like microcontrollers, low-power processors, and small AI accelerators, as shown in Figure 5. The model needs to be trained and then compressed for deployment on IoT edge devices with limited memory (RAM and flash), compute resources, and battery. The TinyML model is trained offline with float32 accuracy. Then, various optimization techniques are implemented, such as pruning, INT8 quantization, operator fusion, and memory-aware buffering to reduce storage, latency, and energy consumption. The compression ratio of the model is given by Equation (24):

$$CR=SizeFP32/SizeINT8$$

(24)

where SizeFP32 is the size of the original model with full precision, and SizeINT8 is the size of the model compressed after quantization. From Equation (25), the energy used per inference is estimated.

$$E_{inf}=P_{avg}\times T_{inf}$$

(25)

where $P_{avg}$ is the average power consumption and $T_{inf}$ is the inference time. Total decision latency is calculated as in Equation (26):

$$T_{total}=T_{pre}+T_{feat}+T_{inf}+T_{trust}+T_{ctrl}$$

(26)

The processing time is composed of $T_{pre}$, $T_{feat}$, $T_{inf}$, $T_{trust}$, and $T_{ctrl}$, representing the pre-processing time, feature extraction time, TinyML inference time, trust-validation time, and control execution time, respectively. The optimization process ensures that the proposed framework can work under strict latency, energy, and memory constraints and still yield reliable autonomous control performance.

The proposed pre-processing and feature extraction modules exhibit linear time complexity, O(n), with respect to the sensing window length, while the INT8 TinyML inference complexity is proportional to the number of model parameters. Memory complexity remains O(n + p), where n denotes the sensing-window size and p represents the quantized model parameters, making the framework suitable for resource-constrained embedded devices.

The autonomous control unit is not offered as a new reinforcement learning or planning algorithm. It is a deterministic safety-constrained closed-loop decision layer that translates a validated TinyML prediction into one of three decisions: execute, execute in restricted warning mode, and reject and resample. Its novelty is architectural integration: an action is executed only after privacy-preserving inference, resource-aware model selection, authentication checking, trust validation, and secure-decision thresholding have been completed locally. Thus, the contribution is the unified low-latency edge pipeline rather than a fundamentally new control-theoretic decision algorithm.

3.9. Overall Working Algorithm

To improve readability and modularity, the overall framework is decomposed into three complementary algorithms. Algorithm 1 describes privacy-preserving sensor pre-processing and feature encoding, Algorithm 2 presents resource-aware TinyML model selection with trust-aware decision validation, and Algorithm 3 details secure decision generation and autonomous edge control. Together, these algorithms represent the complete end-to-end workflow of the proposed privacy-preserving TinyML-driven IoT edge architecture. The novelty of the algorithm is that it combines privacy-aware sensor data collection, adaptive TinyML inference, trust-aware decision verification, and self-regulatory decision-making in a single edge-executable pipeline.

Algorithm 1. Privacy-Preserving Sensor Pre-processing and Feature Encoding

Input: IoT sensor stream Xi, authentication state ai, encryption key Ke Output: Privacy-preserved feature vector Fkp   1: Form a temporal sensing window Wk using n = 128 samples.   2: Compute packet delay Di = tᵣ − ts; reject and resample if Di > Dmax or ai = 0.   3: Filter and normalize each sensor channel using min–max normalization.   4: Extract $\mu \mathrm{k},\sigma \mathrm{k},RMS\mathrm{k},E\mathrm{k},\Delta x\mathrm{k},H\mathrm{k},ZCR\mathrm{k},$ and Qk.   5: Construct the 64-dimensional feature vector Fk.   6: Encrypt the feature vector using AES-128-GCM: Fkp = Enc(Fk, Ke).   7: Return Fkp.

Algorithm 2. Resource-Aware TinyML Model Selection and Trust Validation

Input: Fkp, resource state Rᵢ, signal-quality score Qk Output: Selected model M*, prediction ŷ, trust score Tscore   1: Compute sensing-complexity score Ck.   2: Compute normalized resource score Rscore from memory, battery, processor availability, latency compliance, and thermal state.   3: Evaluate candidate TinyML models using the validation-derived utility weights.   4: Select the lightweight ML path when Rscore < 0.45, INT8 TinyML when 0.45 ≤ Rscore < 0.70, and temporal TinyML when Rscore ≥ 0.70, subject to memory and latency constraints.   5: Execute the selected model and obtain ŷ and prediction confidence Pc.   6: Compute Tscore from signal quality, authentication reliability, delay reliability, prediction confidence, and anomaly consistency.   7: If Tscore < 0.75, reject the result and request resampling.   8: Return M*, ŷ, and Tscore.

Algorithm 3. Secure Decision and Autonomous Edge Control

Input: ŷ, Tscore, anomaly score An, resource state Ri Output: Secure decision score SD, control action At   1: Compute the secure decision score SD.   2: If SD ≥ 0.80, accept the prediction and execute the corresponding control action.   3: If 0.60 ≤ SD < 0.80, escalate to a stronger TinyML path and issue a warning-level action.   4: If SD < 0.60, reject the decision, request sensor resampling, and activate fail-safe mode.   5: Compute total processing latency and inference energy.   6: Store only the encrypted feature representation, validated prediction, secure decision score, and control action.   7: Return SD and At.

4. Experimental Setup and Evaluation Metrics

4.1. Experimental Design

Considering real-time sensing, secure inference, and autonomous IoT edge AI-based control, the experimental design proposes the evaluation of the proposed privacy-preserving TinyML-driven IoT edge architecture. The primary goal is to determine the feasibility of the proposed framework in terms of high prediction accuracy, low latency, energy consumption, memory consumption, raw data exposure, and unsafe control decisions. The feature vectors obtained from the methodology stage as the input to the TinyML model pool are pre-processed and privacy preserved. The entire experiment is broken down into five stages of evaluation: AI classification performance, embedded deployment performance, privacy-preserving transmission, trust-aware secure validation, and autonomous control response. To make a fair comparison between all baseline models and the proposed framework, the same training, validation, and testing protocol is used for all the models. The proposed method is compared with conventional ML, static TinyML, INT8 TinyML, compact temporal TinyML, edge-only inference, and cloud-based inference. Table 3 represents the experimental design summary.

Table 3. Experimental design summary.

Evaluation Aspect	Description
Main goal	Low-latency privacy-preserving TinyML edge inference
Input format	Pre-processed and privacy-preserved sensing features
Processing mode	Local edge inference and autonomous control
Compared methods	ML, static TinyML, INT8 TinyML, temporal TinyML, cloud, proposed
Key focus	Accuracy, latency, energy, memory, privacy, security, control response
Output	Secure autonomous control decision

The evaluation problem was cast as a four-class temporal IoT event classification problem: Normal Operation, Environmental Anomaly, Device Fault, and Security Event. The proposed framework was compared with the fixed TinyML deployment with and without assistance from cloud inference, and with identical training, validation, and testing partitions. Stratified sampling was performed on the independent test set of 3600 sensing windows to retain the class imbalance, and the performance of the model was tested on this set.

A secure event was considered to be a sensing instance where the correct classification criterion was met, and the trust score was also ≥0.75 and the secure decision score was also ≥0.80. Security-event labels comprise authenticated normal operation, verified anomalies, verified device faults, and validated security events created following the predefined experimental protocol. The secure-event detection rate reported was measured on the independent test set.

The proposed architecture is application independent; however, the experimental validation is based on the industrial IoT condition monitoring application as the main deployment scenario. The tests of all reported experiments, adaptive model selection, trust validation, and autonomous control evaluation were performed on multi-sensor time-series data obtained from industry. Other IoT applications presented in the manuscript are not experimental validation cases but are possible deployment domains.

4.2. Model Training and Optimization Setup

The TinyML models are trained offline using full-precision (FP32) computation and then transferred to efficient edge deployable models. Normalized sensing features are fed as input during training, and outputs are sensing or control-state classes. Cross-entropy loss is used for classification, and confidence-based scoring is used for decision validation. To avoid overfitting, early stopping is done based on the validation loss. Model compression is done after training by INT8 quantization, pruning, operator fusion, and a memory-aware buffer. Quantization reduces the model size by replacing 32-bit floating-point weights with 8-bit integers. Pruning eliminates the low-impact parameters and repeated computation in embedded execution by operator fusion. Table 4 shows the training and optimization configuration. These optimizations guarantee that even the proposed model can be efficiently executed in a low-power edge device without compromising the inference performance.

Table 4. Training and optimization configuration.

Parameter	Configuration
Training precision	FP32
Deployment precision	INT8
Optimizer	Adam/AdamW
Loss function	Cross-entropy
Batch size	32/64
Epochs	100–150
Regularization	Dropout/early stopping
Optimization	Quantization, pruning, operator fusion
Deployment format	TFLite Micro/ONNX/Edge Impulse
Main objective	Low latency, low memory, high reliability

All deployment results reported in this study were obtained from physical hardware measurements rather than analytical profiling. The ESP32-S3 (Espressif Systems, Shanghai, China), STM32H743ZI (STMicroelectronics, Geneva, Switzerland), Raspberry Pi 4 Model B (4 GB; Raspberry Pi Ltd., Cambridge, UK), and Jetson Nano Developer Kit (NVIDIA Corporation, Santa Clara, CA, USA) were individually programmed and benchmarked using the same trained INT8 model under identical experimental conditions. Energy measurements were acquired using an INA219 power monitor (Texas Instruments, Dallas, TX, USA) operating at 1 kHz sampling frequency with a regulated 5.0 V supply. Each reported value represents the average of 1000 consecutive inferences, after subtracting the idle power consumption of the target device. The reported energy includes both TinyML inference and wireless communication energy associated with feature transmission.

4.3. Implementation Details

Experiments were conducted using Python 3.11.5, TensorFlow 2.16.1, PyTorch 2.3.1, TensorFlow Lite Micro commit r2.16, Edge Impulse Studio (July 2026 release), STM32Cube.AI v9.0.0, and ONNX Runtime 1.18.0. Training employed Adam (learning rate = 1 × 10⁻³, batch size = 64, 100 epochs, early stopping = 10 epochs, random seed = 42). The TinyML model consists of two fully connected INT8 layers (64–32 neurons) with ReLU activation and Softmax output.

4.4. Embedded Hardware and Software Setup

The embedded deployment setup tests whether the deployment framework is feasible on IoT edge devices with limited resources. Microcontroller-level testing involves experiments using ESP32-S3 to test ultra-low-power TinyML inference and real-time control feasibility with STM32H7. Intermediate inference and local decision processing are performed at the edge-gateway platform based on Raspberry Pi 4. For a small deep learning comparison, Jetson Nano is used as a high-capacity edge reference platform. The software environment consists of several components, such as Python for pre-processing and training the models, TensorFlow or PyTorch for model development, TensorFlow Lite Micro for deployment on microcontrollers, and software tools like Edge Impulse and STM32Cube (Table 5). AI for embedded profiling and ONNX Runtime for edge inference testing. The latency is defined as the time between the pre-processing and the generation of the control action. Average power and inference time are used for estimating energy consumption, as shown in Table 6.

Table 5. Embedded deployment configuration.

Platform	Processor/Accelerator	RAM/SRAM	Precision	Role
ESP32-S3	Dual-core Xtensa LX7	512 KB SRAM	INT8	Ultra-low-power TinyML node
STM32H7	ARM Cortex-M7	1 MB SRAM	INT8/FP16	Real-time embedded controller
Raspberry Pi 4	ARM Cortex-A72	4 GB RAM	INT8/FP16/FP32	Edge gateway
Jetson Nano	ARM Cortex-A57 + GPU	4 GB RAM	INT8/FP16/FP32	High-capacity edge reference

Table 6. Software tools used for deployment.

Tool/Framework	Purpose
Python 3.x	Pre-processing and training
TensorFlow/PyTorch	Model development
TensorFlow Lite Micro	Microcontroller deployment
Edge Impulse	TinyML profiling
STM32Cube.AI	STM32 deployment optimization
ONNX Runtime	Edge inference testing
Power profiler/INA219	Energy measurement
Cycle counter/timer	Latency measurement

The cloud baseline was evaluated under a controlled local-area network using MQTT over Wi-Fi (IEEE 802.11ac) with an average uplink bandwidth of 95 Mbps, round-trip latency of 18.4 ± 2.1 ms, and an Intel Core i7-12700 processor (Intel Corporation, Santa Clara, CA, USA). The reported cloud latency (42.6 ms) represents the average of 1000 inference requests, including communication, serialization, server inference, and response transmission times.

4.5. Evaluation Metrics

A set of metrics for classification, embedded deployment, privacy, security, and autonomous control are used to evaluate the proposed architecture. The performance of classification is evaluated by accuracy, precision, recall, F1-score, and AUROC. Total latency, energy per inference, throughput, model size, and compression ratio and memory footprint are used to measure embedded performance. Transmitted data reduction, raw-data exposure reduction, encrypted feature usage, and privacy-preserved decision rate are the four metrics used to assess privacy Table 7. Secure-event detection, spoofed-packet rejection, unreliable-packet rejection, and false secure-decision rate are measures for the evaluation of secure decision performance. The autonomous control performance measures include control response time, successful control execution rate, warning-mode activation, and fail-safe activation.

Table 7. AI and embedded evaluation metrics.

Metric	Formula/Measurement	Desired Value
Accuracy	(TP + TN)/(TP + TN + FP + FN)	Higher
Precision	TP/(TP + FP)	Higher
Recall	TP/(TP + FN)	Higher
F1-score	2PR/(P + R)	Higher
AUROC	Area under ROC curve	Higher
Total latency	Tpre + Tfeat + Tinf + Ttrust + Tctrl	Lower
Energy/inference	Pavg × Tinf	Lower
Compression ratio	SizeFP32/SizeINT8	Higher
Throughput	Processed windows/second	Higher

The transmission reduction was computed relative to raw sensor transmission. Each raw sensing window contained 128 samples × 8 channels × 2 bytes = 2048 bytes, whereas the proposed framework transmits a 64-dimensional encrypted feature vector (256 bytes) together with a 32-byte AES-GCM authentication tag and a 16-byte decision summary, resulting in 304 bytes per inference. This corresponds to a 74.5% reduction in transmitted data.

5. Results and Discussions

The proposed privacy preserving TinyML enabled IoT edge architecture was validated based on classification reliability, embedded deployment efficiency, privacy preservation, secure decision validation and autonomous control response. The performance was compared to conventional cloud-based inference for IoT, edge-only inference, static TinyML, quantized TinyML, and the proposed adaptive privacy-preserving TinyML. The results show that the proposed framework can provide improved decision accuracy with reduced latency, less energy consumption, and better privacy protection. The major improvement is achieved by processing the raw sensor data locally, using privacy-preserved feature vectors for inference, and by dynamically switching on the most suitable TinyML branch through the help of the resource-aware model-selection unit. Furthermore, the trust-aware validation module ensures that low-quality, late, spoofed, or doubtful sensor windows cannot lead to unsafe autonomous control. The results are analyzed under classification performance, embedded efficiency, privacy-preserving transmission, trust-aware secure validation, autonomous control response, ablation analysis and statistical validation.

5.1. Classification Performance Analysis

The accuracy, precision, recall, F1-score, and AUROC were used to assess the classification performance of the proposed framework. Table 8 indicates that the conventional machine learning models obtained moderate performance, which relied on the handcrafted features and could not fully represent the temporal sensor variations. Static TinyML was able to increase the classification performance but used the same inference path for all the input windows, meaning it used too many resources in simple cases and was not reliable enough in complex cases. INT8 TinyML reduced latency and memory usage but was still missing adaptive path selection. The proposed framework obtained the highest accuracy of 97.4%, precision of 97.1%, recall of 96.7%, F1-score of 96.9%, and AUROC of 98.3%. This improvement is mainly due to the combination of privacy-preserving feature encoding, adaptive TinyML model selection, and trust-aware decision validation. Figure 6 shows that the proposed framework achieves the highest classification performance across all evaluation metrics.

Table 8. Classification performance comparison.

Model	Accuracy (%)	Precision (%)	Recall (%)	F1-Score (%)	AUROC (%)
Logistic Regression	89.8	88.9	88.2	88.5	91.4
Decision Tree	90.7	89.8	89.1	89.4	92.1
Random Forest	92.6	92.1	91.4	91.7	94.0
Static TinyML	94.5	94.0	93.6	93.8	95.8
INT8 TinyML	95.8	95.4	95.0	95.2	96.9
Compact Temporal TinyML	96.6	96.1	95.8	95.9	97.5
Proposed Framework	97.4	97.1	96.7	96.9	98.3

Figure 6. Classification performance comparison of baseline and proposed TinyML models.

5.2. Embedded Deployment Performance

Latency, energy per inference, memory footprint, throughput, and model size were used to analyze the embedded deployment performance. As observed from Table 9, the proposed method successfully decreases the inference delay in addition to energy consumption as compared to cloud-based and static edge inference. For cloud-based inference, it took 42.6 ms latency to send the data to the cloud and to process it remotely. Edge-only inference resulted in 26.8 ms, and static TinyML in 21.3 ms. The proposed framework performed the lowest total latency of 14.8 ms as the feature extraction, adaptive inference and trust validation were also performed locally on the optimized INT8 TinyML models. This shows that energy consumption was reduced from 9.3 mJ in cloud-assisted processing to 4.1 mJ in the proposed method. Table 9 shows an embedded deployment performance comparison. The throughput also rose to 67.5 windows/s, indicating that the proposed architecture is appropriate for real-time smart sensing and autonomous control. Figure 7 shows that the proposed framework reduces latency, energy, and memory usage while improving throughput.

Table 9. Embedded deployment performance comparison.

Method	Latency (ms)	Energy/Inference (mJ)	Memory Usage (KB)	Throughput (Windows/s)	Model Size
Cloud-based IoT	42.6	9.3	512	23.4	2.84 MB
Edge-only inference	26.8	7.2	386	37.3	1.96 MB
Static TinyML	21.3	6.4	214	46.9	684 KB
INT8 TinyML	17.6	5.2	138	56.8	286 KB
Proposed Framework	14.8	4.1	96	67.5	184 KB

Figure 7. Resource-efficient IoT–TinyML performance analysis.

5.3. Privacy-Preserving Performance Analysis

The privacy preservation was assessed by the raw data exposure, transmitted data volume, encrypted feature usage, and privacy-preserving decision rate. In traditional cloud-based IoT applications, the whole sensor data stream is sent for analysis, which poses high privacy risks. The framework, on the contrary, locally processes raw sensor data and only sends encrypted feature vectors or decision summaries. The proposed architecture reduced the volume of data transmitted by 74.5% as well as the raw-data exposure by 91.2% against cloud-based IoT processing, as shown in Table 10. The feature transmission rate was 98.6% with privacy preserved, which means that most decisions were achieved without revealing raw sensing streams. This validates that the proposed approach is well suited for privacy-sensitive applications like healthcare monitoring, smart homes, industrial sensing, and autonomous embedded control. Figure 8 shows that the proposed framework achieves lower raw-data exposure and higher privacy-preserved decision rates.

Table 10. Privacy-preserving performance comparison.

Method	Raw Data Exposure (%)	Data Transmission Reduction (%)	Encrypted Feature Usage (%)	Privacy-Preserved Decision Rate (%)
Cloud-based IoT	100.0	0.0	0.0	41.8
Edge-assisted IoT	68.4	35.6	32.7	66.9
Federated TinyML	42.5	58.3	71.4	84.6
Static TinyML	28.7	63.9	76.8	88.2
Proposed Framework	8.8	74.5	98.6	96.7

Figure 8. Privacy-preservation metric trend analysis across IoT–TinyML methods.

The reported privacy metrics are implementation-oriented deployment metrics rather than formal differential privacy guarantees. Raw-data exposure is the percentage of sensing windows transmitted without being abstracted from raw data, encrypted feature usage denotes the percentage of transmitted encrypted feature vectors, and privacy-preserved decision rate signifies the percentage of autonomous decisions made without releasing raw streams from sensing windows.

5.4. Trust-Aware Secure Decision Validation

The validation module with trust was tested by secure-event detection rate, unreliable-packet rejection rate, spoofed-input rejection rate, and false secure-decision rate. As can be seen from Table 11, the proposed method has obtained a 98.1% secure-event detection rate and 97.3% unreliable-packet rejection rate. If not validated by the trust score, bad or late packets may be fed to the inference model, leading to incorrect control actions. Before making the final decision, the proposed trustscore considers the signal quality, the authentication reliability, the delay reliability, the anomaly score, and the prediction confidence. This enhances the trustworthiness of the autonomous control system as the input is filtered to remove uncertain windows and move to increased TinyML inference for moderate-risk windows. The false secure-decision rate was lowered to 1.9%, which proves that the trust-aware module increases the safety of the decision. Figure 9 shows that the proposed framework improves secure-event detection and packet rejection while reducing false secure decisions.

Table 11. Secure decision validation performance.

Method	Secure-Event Detection (%)	Unreliable-Packet Rejection (%)	Spoofed-Input Rejection (%)	False Secure Decision (%)
Static TinyML	91.4	88.6	87.2	7.8
INT8 TinyML	93.6	90.9	89.5	6.1
TinyML + Anomaly Check	95.8	94.1	93.7	4.2
Proposed Framework	98.1	97.3	96.8	1.9

Figure 9. Trust-aware secure decision validation analysis.

5.5. Autonomous Control Response Analysis

Control response time, successful control execution rate, activation of warning mode, and fail-safe activation were used to analyze the autonomous control performance. Table 12 shows that the average control response time of the proposed method is 18.2 ms, which is suitable for real-time smart sensing applications. Cloud-based control took 58.4 ms, which could not be used for latency-sensitive applications due to transmission delay and remote processing. The proposed framework managed to control successfully 97.6% of the time and still provide fail-safe activation for risky and uncertain decisions. This outcome is a testament to the fact that the architecture can sense, infer, and stabilize closed-loop autonomous control at the edge. Figure 10 shows that the proposed framework achieves faster control response with higher execution stability and lower risk activation.

Table 12. Autonomous control response performance.

Method	Control Response Time (ms)	Successful Control Execution (%)	Warning Mode Activation (%)	Fail-Safe Activation (%)
Cloud-based control	58.4	89.2	8.7	4.8
Edge-only control	34.7	92.8	7.4	4.1
Static TinyML control	26.5	94.1	6.2	3.5
Proposed Framework	18.2	97.6	4.8	2.1

Figure 10. Autonomous control response performance analysis. Shading marks visual response intervals only; it is not a confidence interval or an additional measured variable.

The reported latency (14.8 ms), energy consumption (4.1 mJ/inference), memory usage, throughput, and model size correspond to measurements obtained on the STM32H743ZI evaluation board operating at 480 MHz with INT8 TensorFlow Lite Micro inference. Results on the remaining hardware platforms are presented separately for comparative analysis.

5.6. Ablation Study

To understand the role played by each of the important modules in the proposed architecture, an ablation study was carried out. It can be seen from Table 13 that the deletion of privacy-preserving feature encoding leads to greater data exposure and lower privacy-preserved decision reliability. If this removes the adaptive model selection, it will reduce accuracy and latency by not being able to choose the best path of inference. Without trust-aware validation, the number of false secure decisions rises, and the number of secure-event detections decreases. Model size, memory consumption, and inference latency will grow if INT8 quantization is not used. The overall performance of the full proposed framework was the best, with accuracy of 97.4%, latency of 14.8 ms, energy of 4.1 mJ, and 98.1% on secure-event detection rate. This validates the proposed modules, which are complementary to each other, and enhance the privacy, accuracy, latency, energy efficiency, and decision safety. Figure 11 shows the normalized sensitivity response of the ablation configurations across accuracy, latency, energy, privacy, and security metrics.

Table 13. Ablation study of proposed framework.

Configuration	Accuracy (%)	Latency (ms)	Energy (mJ)	Data Reduction (%)	Secure Detection (%)
Without privacy encoding	96.8	15.4	4.5	38.2	96.4
Without adaptive selection	95.9	19.8	5.7	71.3	96.8
Without trust validation	96.5	13.9	3.9	73.8	91.2
Without INT8 quantization	97.1	23.5	6.8	72.6	97.5
Full proposed framework	97.4	14.8	4.1	74.5	98.1

Figure 11. Ablation sensitivity across accuracy, latency, energy, and privacy–security metrics.

5.7. Statistical Validation

For the proposed framework, statistical validation was carried out on several independent runs to check the stability of the proposed framework. Table 14 includes the mean, standard deviation, maximum, minimum, and confidence interval for key performance indicators. The proposed framework achieved a mean accuracy of 97.4 ± 0.3%, F1-score of 96.9 ± 0.4%, latency of 14.8 ± 0.6 ms, and secure-event detection rate of 98.1 ± 0.2%. Low standard deviation means that the proposed architecture has a stable and repeatable performance for different runs. The confidence interval also indicates that the proposed system behaves uniformly for different sensing conditions and states of resources.

Table 14. Statistical validation across repeated trials.

Metric	Mean	Standard Deviation	Best	Worst	95% Confidence Interval
Accuracy (%)	97.4	0.3	97.8	96.9	±0.21
F1-score (%)	96.9	0.4	97.3	96.2	±0.28
Latency (ms)	14.8	0.6	13.9	15.7	±0.42
Energy (mJ)	4.1	0.2	3.8	4.5	±0.14
Secure detection (%)	98.1	0.2	98.5	97.7	±0.13

5.8. Overall Discussion

Finally, the overall results show that the proposed privacy-preserving TinyML-driven IoT edge architecture offers a good compromise between accuracy, privacy, latency, energy efficiency, and autonomous control reliability. In comparison to normal cloud-based IoT systems, the proposed framework provides a smaller latency of 65.3%, a lower energy cost of 55.9%, and a lower volume of transmitted data of 74.5%. The proposed approach achieved higher accuracy (2.9%), lower latency (30.5%), and higher secure-event detection (6.7%) than static TinyML. These improvements are attained because the proposed method does not perceive privacy, inference, trust, and control as distinct elements. Instead, all the modules are integrated together into the same Architecture that can be executed from the edge. The privacy-preserving feature encoding module reduces the visibility of raw data, the adaptive TinyML engine optimizes inference efficiency, and the trust-aware validation layer avoids decisions under unreliable conditions. Hence, the proposed framework is applicable to smart healthcare, industrial automation, smart building, environment monitoring, and real-time autonomous IoT control.

The present work evaluates deployment-oriented privacy rather than resistance against advanced privacy attacks. Formal evaluation of membership inference, attribute inference, feature reconstruction, traffic analysis, and side-channel leakage will be investigated in future work to further strengthen the security assessment of the proposed architecture.

6. Conclusions

A Privacy-Preserving TinyML-Driven IoT Edge Architecture for Low-Latency Smart Sensing and Autonomous AI-Based Control was presented in this paper. The proposed framework is a unified pipeline consisting of local sensor pre-processing, privacy-preserving feature encoding, resource-aware TinyML inference, trust-aware decision validation, and autonomous control execution. The proposed architecture is different from the existing cloud-based IoT architectures because it does not require transmitting raw data from the sensors to the cloud all the time, but it processes sensor streams at the edge. The experimental results revealed that the proposed framework had 97.4% accuracy, 96.9% F1-score, 98.3% AUROC, and a 98.1% rate of secure event detection. It also cut down on latency (42.6 ms to 14.8 ms), energy usage (9.3 mJ to 4.1 mJ per inference), and transmitted data volume (74.5% less than cloud-based processing). The ablation study showed that each of the four techniques contributes to the overall performance, namely, privacy encoding, adaptive model selection, trust validation and INT8 quantization. The proposed framework is thus suitable for privacy-sensitive, energy-constrained and latency-critical smart sensing applications.

Future research will involve deploying the system in the real world on larger and more heterogeneous IoT networks, side-channel security protection at the hardware level, adaptive selection of the strength of the encryption, federated TinyML updates, and visualization of control decisions for explainability in safety-critical autonomous IoT systems.