For informational purposes regarding emerging 6G networking standards, the following report details the architectural mechanisms of Semantic Communications (SemCom). SemCom represents a fundamental paradigm shift in telecommunications, moving beyond Claude Shannon’s 1948 Information Theory which treated all data as mathematically equivalent bits regardless of meaning. As the foundational architecture of the upcoming 6G era (projected for the early 2030s), SemCom abandons bit-level equivalence to transmit the underlying meaning or specific features necessary for downstream Artificial Intelligence tasks. By integrating deep neural networks directly into the physical and medium access layers, SemCom achieves staggering bandwidth savings—up to 99%—by optimizing for task-oriented intelligence rather than perfect data reconstruction. This report deconstructs the structural transition from legacy syntactic protocols to meaning-based semantic architectures, the pioneering of Deep Joint Source-Channel Coding (DeepJSCC), and the massive hardware synchronization requirements necessary for deploying AI-Native edge networks.

For nearly eight decades, the architectural foundation of global telecommunications has rested on a single, unassailable mathematical framework: Claude Shannon’s 1948 Information Theory. Shannon’s genius lay in decoupling the meaning of a message from its transmission, treating all data—whether a Shakespearean sonnet or random atmospheric noise—as mathematically equivalent strings of bits. This abstraction birthed the digital age, enabling the hyper-scaled architectures of 4G and 5G. However, as Artificial Intelligence proliferates at the edge and machine-to-machine traffic overtakes human communication, this foundational paradigm is catastrophically fracturing. The relentless pursuit of bit-perfect transmission in bandwidth-constrained environments has created an insurmountable efficiency bottleneck. Enter Semantic Communications (SemCom), the foundational architecture of the upcoming 6G era, which abandons Shannon’s bit-level equivalence to transmit the underlying meaning of data natively using deep neural networks [cite: 1, 2].

• The Post-Shannon Paradigm: Traditional networks optimize for Bit Error Rate (BER), treating all bits equally. Semantic communications optimize for Semantic Error Rate (SER), transmitting only the features necessary to convey meaning or execute a downstream task.
• Joint Source-Channel Coding (JSCC): By replacing discrete, modular communication blocks (quantization, modulation, error correction) with end-to-end differentiable neural networks, DeepJSCC enables continuous, analog-like transmission of AI latent spaces [cite: 3, 4].
• Task-Oriented Architecture: In machine-to-machine telemetry, perfect data reconstruction is irrelevant. The semantic paradigm shifts the objective function from data fidelity to downstream inference accuracy, governed by the Information Bottleneck principle [cite: 5].
• The Hallucination Dilemma: While semantic decoders exhibit unprecedented resilience to low Signal-to-Noise Ratio (SNR) environments, they introduce a novel failure mode: semantic hallucination, where channel noise alters the fundamental meaning of the decoded message.

The transition from syntactic to semantic communications represents one of the most profound architectural shifts in the history of information technology. By integrating Artificial Intelligence directly into the physical layer (PHY) and Medium Access Control (MAC) layers of the network stack, we are moving from networks that blindly shuttle bits to networks that understand the data they carry. This comprehensive report deconstructs the theoretical foundations, architectural implementations, and critical bottlenecks of the semantic communication paradigm.

The Collapse of the Separation Principle

To understand the necessity of semantic communications, one must first deconstruct the core architectural assumption of modern telecommunications: the Separation Principle. Formulated by Shannon, this theorem states that source coding (compressing data to remove redundancy) and channel coding (adding structured redundancy to protect against transmission errors) can be designed independently and concatenated without any loss of optimality, provided the channel capacity is infinite or block lengths are infinitely long.

In practice, this led to the highly modular, siloed architecture of modern radios. A JPEG algorithm compresses an image, an Advanced Encryption Standard (AES) algorithm encrypts it, a Forward Error Correction (FEC) block adds parity bits, and a Quadrature Amplitude Modulation (QAM) block maps these bits into electromagnetic waves. The system is agnostic to the fact that it is transmitting a picture of a stop sign meant for an autonomous vehicle.

However, the Separation Principle breaks down under two modern conditions:

• Strict Latency Constraints: The theorem assumes infinite block lengths to achieve theoretical capacity. Edge AI, autonomous robotics, and real-time control systems cannot wait for infinite blocks; they require ultra-low latency, operating in the finite blocklength regime where the separation principle is demonstrably suboptimal.
• The Data-Spectrum Discrepancy: The volume of data generated by high-fidelity sensors (LiDAR, 8K video, hyperspectral imaging) is growing exponentially, while available electromagnetic spectrum remains a finite, physics-bound resource. We can no longer afford the bandwidth to transmit every pixel perfectly when the receiving AI only needs to know if an obstacle is present.

By forcing AI agents to communicate through networks designed for human-centric data reconstruction, we introduce massive inefficiencies. Semantic communication bridges this gap by merging the source and channel coding into a unified, AI-driven process.

Weaver’s Tripartite Model: The Theoretical Foundation

While Shannon famously declared that the semantic aspects of communication were "irrelevant to the engineering problem," his co-author Warren Weaver envisioned a broader framework. In 1949, Weaver categorized the communication problem into three distinct levels:

• Level A (The Technical Problem): How accurately can the symbols of communication be transmitted? (This is where Shannon focused, and where 1G through 5G have operated).
• Level B (The Semantic Problem): How precisely do the transmitted symbols convey the desired meaning?
• Level C (The Effectiveness Problem): How effectively does the received meaning affect conduct in the desired way?

For seven decades, the telecommunications industry lacked the mathematical tools and computational hardware to address Levels B and C. The rise of foundation models, transformer architectures, and neuromorphic computing has finally unlocked the capacity to engineer Level B (Semantic Communication) and Level C (Task-Oriented Communication) architectures directly into the transceiver pipeline [cite: 2, 5].

In this framework, meaning is extracted by mapping raw data into a compact, low-dimensional semantic space. Instead of transmitting raw syntactic entropy, the network transmits Semantic Entropy—a measure of the ambiguity of meaning rather than the predictability of symbols. Carnap and Bar-Hillel’s early theories on semantic information based on logical probability have been resurrected and modernized through the lens of deep latent variable models.

Architecting Deep Joint Source-Channel Coding (DeepJSCC)

The operational heart of a semantic communication system is the Deep Joint Source-Channel Coding (DeepJSCC) architecture. Unlike traditional digital systems that rely on discrete alphabets (converting everything to 1s and 0s), DeepJSCC utilizes continuous, unquantized analog transmission of neural network activations. This represents a paradigm shift back to analog communication, but governed by deep learning rather than simple waveform modulation.

This paradigm shift is actively transitioning from theory to institutional prototyping. For example, pioneering research on DeepJSCC by Deniz Gündüz and colleagues has demonstrated successful semantic image transmission across orthogonal frequency-division multiplexing (OFDM), multiple-input and multiple-output (MIMO), and feedback channels, definitively challenging Shannon's separation theorem by outperforming state-of-the-art concatenated compression and channel coding schemes [cite: 3, 4, 6]. Similarly, industry leaders like Nokia Bell Labs have recently partnered with KT Corporation to validate these concepts in real-world industrial settings, utilizing novel controller-network interfaces to achieve over 60% bandwidth reduction in wireless robot control while maintaining critical service availability and stability [cite: 1].

In a standard DeepJSCC pipeline, the transmitter and receiver are jointly optimized as a single autoencoder architecture, separated by a non-differentiable stochastic channel. The transmitter neural network (Semantic Encoder) compresses the input into a latent representation. Crucially, it simultaneously applies error-correction features tailored to the specific noise profile of the channel. These latent features are power-normalized and mapped directly to the In-Phase and Quadrature (I/Q) components of the radio frequency frontend, bypassing traditional QAM constellations entirely.

Below is a simplified architectural representation of a DeepJSCC transceiver for image transmission over an Additive White Gaussian Noise (AWGN) channel, utilizing PyTorch.

import torch
import torch.nn as nn

class DeepJSCC_Transceiver(nn.Module):
 def __init__(self, channel_snr_db, latent_dim):
 super(DeepJSCC_Transceiver, self).__init__()
 self.latent_dim = latent_dim
 self.channel_snr = 10 ** (channel_snr_db / 10.0)
 
 # Semantic Encoder (Transmitter)
 # Extracts meaning and robustly encodes for the channel
 self.encoder = nn.Sequential(
 nn.Conv2d(3, 64, kernel_size=5, stride=2, padding=2),
 nn.PReLU(),
 nn.Conv2d(64, 128, kernel_size=5, stride=2, padding=2),
 nn.PReLU(),
 nn.Flatten(),
 nn.Linear(128 * 8 * 8, self.latent_dim) # Assuming 32x32 input
 )
 
 # Semantic Decoder (Receiver)
 # Reconstructs meaning from noisy channel observations
 self.decoder = nn.Sequential(
 nn.Linear(self.latent_dim, 128 * 8 * 8),
 nn.PReLU(),
 nn.Unflatten(1, (128, 8, 8)),
 nn.ConvTranspose2d(128, 64, kernel_size=5, stride=2, padding=2, output_padding=1),
 nn.PReLU(),
 nn.ConvTranspose2d(64, 3, kernel_size=5, stride=2, padding=2, output_padding=1),
 nn.Sigmoid()
 )

 def power_normalization(self, z):
 # Enforce average power constraint (E[||z||^2] <= P)
 norm_factor = torch.sqrt(torch.mean(z**2, dim=1, keepdim=True))
 return z / (norm_factor + 1e-8)

 def awgn_channel(self, z):
 # Simulate physical transmission layer noise
 signal_power = torch.mean(z**2)
 noise_power = signal_power / self.channel_snr
 noise = torch.randn_like(z) * torch.sqrt(noise_power)
 return z + noise

 def forward(self, x):
 # Tx Process
 semantic_features = self.encoder(x)
 tx_signal = self.power_normalization(semantic_features)
 
 # Physical Channel
 rx_signal = self.awgn_channel(tx_signal)
 
 # Rx Process
 reconstructed_semantics = self.decoder(rx_signal)
 return reconstructed_semantics

This architecture reveals several profound deviations from classical systems. Firstly, there is no quantization block; the floating-point tensors are transmitted natively. Secondly, the system avoids the "cliff effect" inherent to digital communications. In a 5G network, if the Signal-to-Noise Ratio (SNR) drops below the threshold required for a specific QAM constellation, the packet is entirely lost, resulting in a sudden drop to zero throughput (the cliff). In contrast, DeepJSCC exhibits graceful degradation. Because the mapping is continuous, an increase in noise simply results in a fuzzier semantic space, allowing the receiver to still extract high-level meaning even in catastrophic channel conditions.

The Information Bottleneck and Task-Oriented Communications

While DeepJSCC is revolutionary for reconstructing data based on meaning, the ultimate realization of Weaver’s Level C (Effectiveness) requires abandoning reconstruction altogether. This is the domain of Task-Oriented Communications, where the transmitter extracts and sends only the specific features required by the receiver to perform a downstream inference task, such as object detection, sentiment analysis, or robotic actuation.

The mathematical framework underpinning task-oriented SemCom is the Information Bottleneck (IB) principle, originally formulated by Naftali Tishby. The IB principle formalizes the extraction of relevant information by balancing two competing objectives: maximizing the predictive power of the transmitted representation regarding the target task, while minimizing the total information transmitted.

In standard notation, if $X$ is the raw input (e.g., a high-resolution drone camera feed), $Y$ is the target variable (e.g., bounding boxes of enemy vehicles), and $Z$ is the semantic latent representation transmitted over the channel, the objective is to find a mapping $p(Z|X)$ that minimizes the IB Lagrangian:

L = I(X; Z) - β I(Z; Y)

Here, $I(X; Z)$ represents the compression term (the mutual information between the raw data and the transmitted signal, equivalent to the bandwidth used), and $I(Z; Y)$ represents the relevance term (the mutual information between the transmitted signal and the target task, equivalent to the inference accuracy). The hyperparameter β controls the tradeoff. As β approaches infinity, the system cares only about accuracy, consuming more bandwidth. As β approaches zero, the system prioritizes extreme compression at the cost of task failure.

By implementing the Information Bottleneck directly into the loss function of the transceiver, the transmitter dynamically prunes features that are irrelevant to the receiver's task. For instance, if the receiver is a facial recognition system, the transmitter will automatically discard background scenery, lighting variations, and clothing details, transmitting only the highly compressed latent vectors corresponding to facial topography. This achieves bandwidth reductions of up to 99% compared to H.265 video streaming, with zero loss in downstream classification accuracy.

Metrics of Meaning: The Metrological Shift

A paradigm shift in architecture necessitates a paradigm shift in metrology. The legacy metrics of telecommunications—Bit Error Rate (BER), Frame Error Rate (FER), and Peak Signal-to-Noise Ratio (PSNR)—measure syntactic fidelity. They are structurally incapable of measuring semantic fidelity. If a transmitter sends "The automobile is fast" and the receiver decodes "The car is quick", a BER metric would register a catastrophic failure due to the high character mismatch. However, semantically, the transmission was perfectly successful.

The industry is currently standardizing a new suite of semantic evaluation metrics, categorized by modality and objective.

The following table outlines the architectural transition from legacy syntactic metrics to modern semantic metrics across various transmission modalities.

Modality / Domain	Legacy Syntactic Metric (Level A)	Modern Semantic Metric (Level B & C)	Architectural Implication
Natural Language Text	Bit Error Rate (BER), Symbol Error Rate	BLEU (Bilingual Evaluation Understudy), BERTScore, Semantic Similarity	Permits synonym substitution and grammar restructuring during channel noise recovery without triggering retransmission protocols like ARQ (Automatic Repeat reQuest).
Computer Vision (Images)	Peak Signal-to-Noise Ratio (PSNR), Mean Squared Error (MSE)	FID (Fréchet Inception Distance), LPIPS (Learned Perceptual Image Patch Similarity)	Prioritizes the transmission of structural edges, facial features, and context over exact pixel-color reconstruction in background regions.
Audio & Speech	Signal-to-Interference-plus-Noise Ratio (SINR)	PESQ (Perceptual Evaluation of Speech Quality), WER (Word Error Rate)	Focuses on transmitting phonemic latent structures and prosody, allowing reconstruction of intelligible speech even if the specific voice timber shifts.
Task-Oriented IoT	Throughput (Mbps), Latency (ms)	mAP (Mean Average Precision), Semantic Error Rate (SER)	Throughput becomes irrelevant. Success is strictly defined by whether the receiving AI agent successfully executes its actuation or classification task.

This metrological shift is more than an academic exercise; it dictates the optimization loops of the network hardware. When a base station allocates Radio Resource Blocks (RRBs) to user equipment based on Semantic Similarity rather than BER, it fundamentally alters the scheduling algorithms at the Medium Access Control (MAC) layer. Users attempting to send simple semantic commands in poor channel conditions will be prioritized over users attempting to send high-entropy, low-meaning data streams.

Knowledge Base Synchronization and Semantic Drift

The transition to meaning-based communication relies on a foundational assumption that Shannon deliberately avoided: Shared Background Knowledge. For a receiver to accurately interpret a highly compressed semantic representation, it must possess the same contextual understanding of the world as the transmitter. In SemCom architectures, this shared context is formalized as a Knowledge Base (KB), typically constructed as a multi-relational Knowledge Graph [cite: 7].

Consider a semantic transmitter extracting the triplet (Entity: Jaguar, Action: Moving, Speed: High). If the transmitter is operating in an automotive context, "Jaguar" refers to a vehicle. If the receiver's local Knowledge Base is tuned to a biological or zoological context, it will decode this representation as a large feline. This disconnect is known as Semantic Mismatch or Semantic Drift.

In highly dynamic environments, such as decentralized swarm robotics or vehicular-to-everything (V2X) communication networks, maintaining synchronization between distributed Knowledge Bases becomes a critical infrastructural challenge. Architecting the synchronization layer requires moving away from static ontologies and embracing dynamic, meta-learning frameworks.

Modern Semantic Transceivers utilize a two-tier communication protocol to resolve this:

• The Control Plane (Background Update): Low-bandwidth (e.g., functioning effectively even when transponder rates are limited to the kbps level [cite: 8]), continuous synchronization of the Knowledge Graph architecture using Federated Learning. Instead of exchanging raw data, nodes exchange model weight updates (gradients) to ensure their semantic encoders and decoders evolve uniformly.
• The Data Plane (Semantic Payload): High-speed transmission (scaling to support the 6G target of 1 Tbps peak data rates and sub-0.1 ms latency [cite: 2]) of the actual semantic latent vectors. If the receiver detects an anomaly—for instance, a latent vector that maps to an empty or low-probability region of its semantic space—it triggers a "Knowledge Request" over the control plane, asking the transmitter to define the novel concept syntactically before resuming semantic transmission.

To address the next logical question—how massive, multi-relational Knowledge Graphs can physically reside on highly constrained edge devices—the architecture relies on a cloud-edge collaborative deployment strategy [cite: 7]. Because standard IoT sensors and mobile devices operate under strict microjoule energy budgets and kilobyte memory footprints, they cannot host massive global master KBs [cite: 2]. Instead, the system utilizes sub-graph allocation, selectively extracting, caching, and serving task-specific "edge sub-bases" from the cloud master base depending on dynamic user preferences and local environment parameters [cite: 7]. To further minimize the memory footprint natively on the device, semantic encoders undergo extreme compression via split computing and model pruning, which research demonstrates can reduce semantic encoder size by up to 99.98%, yielding on-device models with as few as 640 parameters [cite: 2]. Some frameworks, such as the Offline Knowledge Base and Attention-driven Semantic Communication (OKBASC) paradigm, precompute compact semantic masks entirely offline; these masks are then rapidly fused at runtime using sparse attention modules, reducing transmission redundancies without overburdening edge-side inference [cite: 9].

The computational overhead of maintaining synchronized KBs remains the primary energy bottleneck in SemCom architectures. While inference over the latent space is highly efficient, continuously updating the Knowledge Graph via Graph Neural Networks (GNNs) on battery-constrained edge devices necessitates dedicated neuromorphic processing units.

Semantic Noise and the Hallucination Dilemma

Every paradigm shift introduces novel failure vectors, and Semantic Communications is no exception. In classical digital systems, the impact of physical channel noise (e.g., thermal noise, electromagnetic interference) is highly predictable: it flips bits. A flipped bit in an uncompressed image might result in a single dead pixel. A flipped bit in the header of a packet might result in the packet being dropped and retransmitted. The errors are syntactic.

Because SemCom relies on generative neural networks to decode the continuous latent space back into meaning, channel noise manifests fundamentally differently. In a deep semantic decoder, physical channel noise perturbs the input tensor. When pushed through the non-linear activation functions of the neural network, this perturbation can cascade, causing the decoder to generate perfectly coherent, yet entirely false, information. This is the Semantic Hallucination Dilemma.

If a drone transmits the semantic representation of a "civilian vehicle" and a burst of Rayleigh fading perturbs the latent vector, the receiving semantic decoder does not output a corrupted, static-filled image of a civilian vehicle. Instead, it might confidently output a crystal-clear image of a "military tank", because the perturbed vector crossed a decision boundary in the latent space. The decoded message is highly readable, syntactically perfect, and catastrophically wrong.

This vulnerability is exacerbated by the existence of Adversarial Semantic Noise. In military and highly secure environments, adversaries do not need to jam the entire spectrum. By injecting carefully crafted, low-power adversarial perturbations into the channel (analogous to adversarial patches in standard computer vision), an attacker can systematically control the semantic output of the receiver. Because the noise is introduced in the physical analog channel, cryptographic digital signatures applied at higher layers are entirely bypassed.

Mitigating semantic hallucinations requires integrating Information Theory back into Deep Learning. Researchers are currently architecting Semantic Confidence Bounds—utilizing Bayesian Neural Networks at the receiver end. Rather than outputting a deterministic point estimate, a Bayesian semantic decoder outputs a probability distribution over the semantic space. If the variance of the decoded meaning is too high, the system detects a potential hallucination and seamlessly falls back to a legacy digital transmission protocol (like 5G QAM) to request a syntactically exact verification.

The Evolution Towards 6G and Beyond

The commercialization of Semantic Communications is inextricably linked to the rollout of 6G networks, projected for the early 2030s. The 3rd Generation Partnership Project (3GPP), the consortium responsible for global telecommunications standards, has already begun outlining semantic protocols in their exploratory working groups.

The integration of SemCom into 6G architecture will not occur overnight. It will follow a hybrid, phased rollout. The network will dynamically switch between the Shannon Paradigm (for applications requiring exact data replication, like downloading an executable binary file) and the Semantic Paradigm (for applications requiring meaning and inference, like remote robotic surgery, metaverse rendering, and autonomous vehicle swarms).

To support this, the core architecture of the cellular base station is being completely reimagined. The traditional baseband unit, which relies on rigid Application-Specific Integrated Circuits (ASICs) for hardware-accelerated Fourier transforms and Viterbi decoding, is being replaced by AI-Native Radio Access Networks (AI-RAN). These architectures utilize massive clusters of Tensor Processing Units (TPUs), GPU-accelerated platforms, and distributed AI-RAN nodes at the network edge, capable of running deep semantic decoders in real-time across hundreds of parallel user streams, and engineered to operate within strict microjoule energy budgets while sustaining peak terabit-per-second (Tbps) data streams [cite: 2, 10]. This transition embodies the coexistence of AI and RAN, formally categorized into AI-for-RAN (optimizing radio operations), AI-on-RAN (executing general-purpose inference at the edge), and AI-and-RAN (representing true shared-infrastructure convergence) [cite: 10]. Furthermore, standardization bodies like ATIS, ETSI, and TTA are actively adopting Open RAN configurations to pave the way for this intelligent AI-native infrastructure layer globally [cite: 11].

We are witnessing the end of an era where communications and computing were treated as distinct scientific disciplines. By unifying Shannon’s Information Theory with deep latent variable models, Semantic Communications establishes a unified mathematical paradigm for the future of connectivity. The network is no longer a passive pipe carrying opaque bits; it is an active, intelligent medium, dynamically computing and routing the underlying meaning of the world’s data.

Sources & References

1. nokia.com
2. arxiv.org
3. arxiv.org
4. imperial.ac.uk
5. arxiv.org
6. semanticscholar.org
7. mdpi.com
8. arxiv.org
9. mdpi.com
10. northeastern.edu
11. liteon.com