Paper deep dive
Autonomous Discovery of Wireless Communications Algorithms
Fayçal Aït Aoudia, Jakob Hoydis, Sebastian Cammerer, Gian Marti, Merlin Nimier-David, Nicolas Roussel, Alexander Keller
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 7/21/2026, 5:36:45 AM
Summary
The paper introduces The AI Telco Engineer (AITE), a framework for autonomously discovering wireless communication algorithms using Large Language Model (LLM)-driven evolutionary search. AITE addresses the gap in applying evolutionary search to wireless communications by designing algorithms for complex physical-layer problems, specifically an equalizer for Orthogonal Time-Frequency Space (OTFS) systems and a receiver for Orthogonal Frequency-Division Multiplexing (OFDM) systems without pilots. The framework utilizes a two-tier architecture with an orchestrator generating algorithmic ideas and workers implementing them in isolated environments, optimizing for both performance and computational complexity.
Entities (10)
Relation Signals (8)
AITE → appliedto → OTFS
confidence 95% · We showcase AITE on two challenging physical-layer problems: designing an equalizer for an orthogonal time-frequency space (OTFS) system
AITE → appliedto → OFDM
confidence 95% · constructing a receiver algorithm for an orthogonal frequency-division multiplexing (OFDM) system
AITE → developedby → NVIDIA
confidence 95% · Authors are affiliated with NVIDIA
AITE → uses → LLM-driven evolutionary search
confidence 95% · AITE is an LLM-driven framework that iteratively explores the space of algorithms
AITE → implementsin → Python
confidence 90% · implemented in Python using LangChain
AITE → optimizesfor → Pareto Front
confidence 90% · The optimization objective is to expand the Pareto front by iteratively evolving a population of algorithms.
AITE → uses → Sionna
confidence 90% · In our experiments, AITE uses Sionna [24] to perform link-level simulations.
AITE → uses → Optuna
confidence 85% · runs Bayesian multiobjective optimization using Optuna [23]
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Large language model (LLM)-driven evolutionary search is an emerging algorithm-discovery paradigm that has already produced novel results in several scientific fields. Yet its application to wireless communications remains largely unexplored. To bridge this gap, we introduce The AI Telco Engineer (AITE), a framework to autonomously design algorithms for complex communication problems, while navigating performance-complexity tradeoffs. We showcase AITE on two challenging physical-layer problems: designing an equalizer for an orthogonal time-frequency space (OTFS) system, and constructing a receiver algorithm for an orthogonal frequency-division multiplexing (OFDM) system using a custom constellation and operating without pilots. For the first task, AITE develops algorithms that outperform the best-known solutions while reducing computational latency by a factor of 3.6 compared to the strongest baseline. For the second task, it discovers the first explicit, explainable algorithms that achieve performance parity with state-of-the-art neural receivers. These results demonstrate the strong potential of LLM-driven evolutionary search for the autonomous discovery of next-generation wireless communications algorithms.
Tags
Links
- Source: https://arxiv.org/abs/2607.17762v1
- Canonical: https://arxiv.org/abs/2607.17762v1
Trouble viewing inline? Open PDF directly →
Full Text
87,348 characters extracted from source content.
Expand or collapse full text
Autonomous Discovery of Wireless Communications Algorithms Fayçal Aït Aoudia 1 , Member, IEEE, Jakob Hoydis 1 , Fellow, IEEE, Sebastian Cammerer 2 , Senior Member, IEEE, Gian Marti 3 , Member, IEEE, Merlin Nimier-David 3 , Nicolas Roussel 3 , and Alexander Keller 2 1 NVIDIA, 92400 Courbevoie, France 2 NVIDIA, 10623 Berlin, Germany 3 NVIDIA, 8004 Zürich, Switzerland Corresponding author: Fayçal Aït Aoudia (e-mail:faitaoudia@nvidia.com). Parts of this article were presented at European Wireless, June 2026 [1]. Code repository: https://github.com/nvlabs/the-ai-telco-engineer ABSTRACTLarge language model (LLM)-driven evolutionary search is an emerging algorithm-discovery paradigm that has already produced novel results in severalscientific fields. Yet its application to wireless communications remains largely unexplored. To bridge thisgap, we introduce The AI Telco Engineer (AITE), a framework to autonomously design algorithms for complex communication problems, while navigating performance–complexity tradeoffs. We showcase AITE on two challenging physical-layer problems: designing an equalizer for an orthogonal time–frequency space (OTFS) system, and constructing a receiver algorithm for an orthogonal frequency-divisionmultiplexing (OFDM) system using a custom constellation and operating without pilots. For the first task, AITE develops algorithms that outperform the best-known solutions while reducing computational latency by a factor of 3.6 compared to the strongest baseline. For the second task, it discovers the first explicit, explainable algorithms that achieve performance parity with state-of-the-art neural receivers. These results demonstrate the strong potential of LLM-driven evolutionary search for the autonomous discovery of next-generation wireless communications algorithms. INDEX TERMSalgorithm discovery, evolutionary search, large languagemodel (LLM), pilotless commu- nication, orthogonal frequency-time space (OTFS), wireless communications I. Introduction A LGORITHMS are central to modern communication systems. They largely determine reliability and effi- ciency, and serve as important product differentiators. De- signing and implementing such algorithms is a demanding task for communications system engineers, requiring domain expertise, mathematical insight, and extensive experimenta- tion to identify robust implementations and suitable hyperpa- rameters. Moreover, solutions that perform well analytically or in simulation may behave unexpectedly once integrated into a full system, where finding the root cause may be difficult. Large language models (LLMs) and agentic arti- ficial intelligence (AI) have advanced rapidly, creating an opportunity to dramatically reduce the human effort required for algorithm development. In this article, we therefore in- vestigate their ability to autonomously discover, implement, and optimize wireless communication algorithms. An algorithm exists at two levels: an abstract mathematical description and a concrete implementation that can be exe- cuted. Thus, the optimization of an algorithm can be cast as a programming problem. The target of the problem depends on properties of the concrete implementation, such as its ac- curacy or latency when run on a specific hardware platform. One way of tackling such problems is genetic programming (GP) [2]. GP relies on evolutionary algorithms to improve computer programs by iteratively applying genetic operators, such as random mutation and crossover, to a generation of seed programs. One of the main problems of GP relates to the definition of the search space, i.e., the set of valid code modifications, which makes scaling to complex programs difficult and requires deep domain expertise. The integration of LLMs into GP has gradually expanded the field into LLM-driven evolutionary search. The authors of [3] were among the first to replace GP’s mutation operator with an LLM that actually understands the code and provides logical program modifications, instead of random edits. This idea was further developed in [4] and [5], where LLMs were also used for crossover operations. The first provably 1 arXiv:2607.17762v1 [cs.IT] 20 Jul 2026 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms new scientific results were generated by FunSearch [6], which leveraged a fixed programmatic skeleton restricting the LLM’s search to an isolated target function, combined with island-based population management. This idea was scaled to multifile codebases in AlphaEvolve [7], which was reproduced shortly thereafter as the open-source framework OpenEvolve [8]. Since then, there has been a rapid prolif- eration of LLM-based evolutionary methods for algorithm discovery, such as ShinkaEvolve [9], GEPA [10], and the SkyDiscover framework [11] (including AdaEvolve [12] and EvoX [13]). They introduce several critical capabilities, such as embedding-based novelty rejection, multiarmed bandit LLM selection, adaptive exploration and compute budget control, as well as optimization of the search strategy code itself. Recently, the code-generation step was extended from a single LLM invocation to tool-using coding agents that iteratively implement, evaluate, and refine solutions before submitting them [1], [14]. This extension is particularly im- portant for challenging coding problems that require the use of debugging and profiling tools or documentation lookups. In this article, we report on initial experiments applying LLM-driven evolutionary search to the design of wireless communications algorithms, providing a useful starting point for others interested in this direction. Notably, even these early results match or surpass the state of the art on the con- sidered tasks, suggesting that agentic AI may have crossed a critical capability threshold, with profound implications for the future of research and development in our field. The only directly related publications we are aware of are [15] and [16], which apply LLM-driven evolutionary search to the optimization of deletion-correcting codes and antenna port selection in a fluid antenna system, respectively. The authors of [17] describe a versatile platform capable of automating research within a large-scale radio testbed, without providing detailed technical results. The rest of this article is structured as follows. Sec- tion I describes the architecture of our evolutionary search framework called The AI Telco Engineer (AITE), which is available as open-source software [18] and implemented in Python using LangChain [19]. We did not rely on existing frameworks such as [8], [9], [11], although these could have been adapted. In Sections I and IV, we describe two specific physical-layer problems that AITE was tasked with, namely developing an equalizer for an orthogonal time– frequency space (OTFS) system [20] as well as a receiver algorithm for an orthogonal frequency-division multiplexing (OFDM) system operating without pilots and with custom constellations [21]. We choose these two tasks because, although both are nontrivial, they are very different in nature. Equalizer design for OTFS is well studied, so the main challenge is to find efficient implementations that simultaneously improve on existing solutions. The pilotless receiver, in contrast, has essentially no prior art, so the biggest challenge is to discover a working algorithm. For the first task, AITE found algorithms that outperform state- The AI Telco Engineer Task description Evaluation tool Set of algorithms FIGURE 1.AITE from an input–output perspective. The user describes a task, i.e., a problem description paired with an evaluationtool, and AITE returns a set of algorithms that explores the metric–complexity tradeoff. of-the-art equalizers while running about3.6×faster. For the second task, only solutions based on neural networks were known, and AITE found novel explicit algorithms with comparable performance. Section V concludes the article with a discussion of open problems and future directions. The Appendices provide detailed descriptions of selected algorithms generated by AITE and illustrate the depth and implementation complexity of the discovered solutions. I. Architecture of The AI Telco Engineer AITE is an LLM-driven framework that iteratively explores the space of algorithms that solve a specified problem. An input–output view of the system is shown in Fig. 1. AITE takes as input atask, defined by a natural-language problem description paired with an immutable, task-specificevalua- tion tool. The evaluation tool executes algorithm implemen- tations and returns a scalar metric evaluating the algorithm’s performance and a scalar measuring the complexity of the implementation (e.g., via the measured latency). Because the evaluation tool is not editable by the system and can only be invoked, AITE prevents “metric gaming” in which the scor- ing procedure is modified to artificially inflate performance. AITE does not focus on evolving a single best solution, but rather aims to output asetof solutions that spans the performance–complexity tradeoff. Concretely, solutions are positioned in the two-dimensional plane spanned by the task metric and the complexity measure returned by the evaluation tool, yielding a point cloud from which the user can pick an operating point after the run, without being involved in the optimization itself. The optimization objective is to expand the Pareto front by iteratively evolving a population of algorithms. The same principle would extend naturally to a higher-dimensional objective space, although we have not explored this in our experiments. A. Global Architecture As illustrated in Fig. 2, AITE follows a two-tier architecture inspired by [6], [7], [9]. Most importantly, it relies on agentic code generation as in [1], [14], instead of a single LLM invocation. This architecture proved effective for the tasks considered here. Anorchestratordrives the global optimiza- tion loop, while a pool ofworkersimplements and refines solutions in parallel. Optimization proceeds over multiple generations. At each generation, the orchestrator proposes Ndistinct abstract algorithmic ideas, and a population of Mworkers is distributed across these ideas, withM/N 2 Orchestrator Idea 1Idea 2 IdeaN · · · Worker 1 Worker 2 Worker 3 Worker 4 Worker M−1 Worker M · · · Worker pool Implemented algorithms FIGURE 2.Overview of the idea-driven iterative optimization loop. The orchestrator generates ideas that are distributed to parallel workers, each operating in its own workspace. Implemented algorithms flowback to the orchestrator to seed the next generation. workers assigned to each. Each worker runs independently, in parallel, and within its own containerized environment referred to as aworkspace. Neither the orchestrator nor the workers have internet access. Assigning multiple workers to the same idea exploits LLM stochasticity (assuming a nonzero decoding temperature). Different workers implementing the same idea tend to pro- duce different implementations, thereby reducing the risk of discarding a promising idea due to a single poor implemen- tation. After all workers in a generation complete, the or- chestrator aggregates the resulting implementations, updates a globalleaderboard, and uses the accumulated outcomes to propose the next generation of ideas. Subsequent ideas can be entirely novel approaches, refinements of previously explored ones, or combinations thereof, depending on the current state of the performance–complexity frontier. B. Orchestrator The orchestrator architecture is shown in Fig. 3. It co- ordinates the optimization by (i) generating diverse ideas, (i) dispatching them to workers, (i) post-processing and summarizing the algorithms produced by the workers, and (iv) maintaining a global leaderboard that records all al- gorithm implementations and their evaluation scores. The leaderboard groups algorithms by their assigned idea and stores multiple (metric, complexity) evaluation points per algorithm when postrun hyperparameter tuning is enabled (Section I-C1). The Pareto front across all implementations is also maintained. 1) Idea Generation At each generation, the orchestrator LLM is instructed to produceNdistinctalgorithmic ideas that span the metric– complexity tradeoff. Centralizing this step avoids a scenario where independent workers each choose their own approach and then tend to converge on similar methods, causing the explored space to collapse. Beyond the first generation, the idea budget must be split betweenrefiningpreviously explored approaches (exploitation) and proposingfreshones (exploration). Because the number of workers, and hence the per-generation budget, is limited, this allocation is critical to search efficiency [9], [12]. AITE delegates this tradeoff to the orchestrator LLM and instructs it to consistently reserve a part of the budget for fresh ideas throughout the run. For the initial generation, the orchestrator LLM receives only the user query and is instructed to output exactlyN distinct algorithmic ideas, since there are no prior ones to refine. For subsequent generations, idea generation is conditioned on previously explored ideas and their corre- sponding implemented algorithms. However, providing the entire leaderboard to the orchestrator is not scalable due to the limited context window of the LLM. Instead, AITE uses a two-part context construction: Pareto-front entries are always included, and additional off-front entries are sampled randomly. Off-front sampling includes at most one representative algorithm per idea and excludes algorithms that did not follow the assigned approach, based on a verdict produced by the post-processing stage (cf. Section I-B3). Off-front entries are sampled without replacement using a temperature-controlled softmax over a spread-normalized metric gap. Letm i denote the metric of algorithmiin the off-front pool and letm ⋆ be the best metric in the pool. Define the gapg i =|m i −m ⋆ |and the pool spreadS= max i g i . The normalized gap is ̃g i =g i /S. IfS= 0, we set ̃g i = 0for alli, resulting in uniform sampling. The sampling probability is thenp i ∝exp (− ̃g i /T), whereT >0is a temperature hyperparameter that remains fixed throughout the run. Smaller values ofTyield greedier selection, whereas larger values yield nearly uniform sampling. 2) Job Launching Once a generation’s ideas have been generated, the job- launching stage turns them into work units and dispatches them to the worker pool. TheNideas are distributed across theMavailable workers, withM/Nworkers assigned to each idea (see Fig. 2). Every worker therefore receives a single idea and is tasked with implementing it in its own dedicated workspace. For each worker, the orchestrator assembles ajob: a self- contained initial context that fully specifies what the worker must do. Beyond the assigned idea, this context includes the task description shared by all workers and, when refining ideas, references to one or more earlier implementations that the worker should build upon. Concretely, a job is materialized as a single prompt template into which the task description, the assigned idea, and the source code of optional reference algorithms are injected. The references’ achieved metrics are deliberately withheld. Exposing them tends to bias the worker toward small edits of an existing solution rather than implementing the assigned approach. As detailed in Section I-B4, the prompt template is not fixed but refined across generations to improve worker effi- 3 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms Idea generation Leaderboard Post-processingJob launchingPrompt refinement Worker pool Orchestrator Task description ideas Pareto and off-front algorithms ideas ideas jobs code summaries, verdicts code, metric, complexity journals Evaluation tool refined prompt FIGURE 3.Orchestrator internal structure. Idea generation is conditioned on the task description together with Pareto-front and off-front algorithms drawn from the leaderboard. The job-launching stage dispatches ideas to the worker pool. Workers return code, metric, and complexity to the leaderboard. The post-processing module pairs each implementation with its assigned idea to produce summaries and adherence verdicts, which are also stored in the leaderboard. Worker journals feed the prompt-refinement stage, whose refined prompts are injected into subsequent jobs. ciency, while protected placeholders guarantee that the task description and the assigned idea are preserved verbatim. 3) Post-Processing of Generated Algorithms Worker outputs do not always follow their assigned ideas, especially when an idea is difficult to implement or when the worker LLM fails to adhere to the provided approach description. We empirically observed that state-of-the-art LLMs (e.g., GPT-5.5) diverge from the assigned idea less frequently than smaller open-weight models (e.g., MiniMax- M2.5 or gpt-oss-120b). Regardless of its source, such diver- gence can mislead the orchestrator, e.g., into discarding an idea that appears to perform poorly when, in fact, it was never actually implemented. To mitigate this, AITE post- processes each completed workspace by reading the resulting code and prompting the orchestrator LLM to produce a concise summary prefixed with a ternary verdict—yes,par- tial, orno—indicating whether the implemented algorithm follows the assigned idea, independent of its achieved score. These summaries serve two purposes. First, they provide a compact, human-readable description of what each algorithm actually implements, allowing the orchestrator to reason over a large history of explored methods. Second, they act as a filter when sampling off-front entries for idea generation (see Section I-B1). Only the best-scoring implementations with ayesverdict are eligible to represent an idea, preventing the orchestrator from being misled by spurious deviations. 4) Worker Prompt Refinement AITE is designed to operate with different LLMs, which can vary widely in their tool-use patterns and ability to adhere to instructions. To improve worker efficiency across generations, AITE refines the worker prompt template using a dedicated prompt-refinement stage. After each worker completes, its execution journal (which records all LLM and tool calls together with their outcomes) is read and structured process statistics (e.g., number of evaluation attempts, file reads and writes, and timeouts) are extracted. An LLM is then used to produce a behavioral critique. At the end of a generation, the orchestrator aggregates these behavioral critiques and requests an LLM to produce a refined prompt template for the next generation, which is used when launching the next generation’s jobs (see Section I-B2). For example, if multiple workers make the same coding error, the refined prompt may include a warning to avoid this error in the future. The refinement affects only the generic instructions that govern how a worker operates. The task description and the assigned approach are injected through placeholders and are therefore never altered. This design lets AITE adapt to different LLM behaviors while keeping algorithm selection and exploration decisions centralized in the orchestrator’s idea-generation stage. C. Worker Workflow Having described the orchestrator, we now turn to the work- ers that implement the ideas it dispatches. Workers operate in parallel, each running as a separate process that hosts a single LLM-driven ReAct agent [22] which repeatedly reasons about what to do, takes an action using a tool, observes the result, and adapts until it completes the task. The resulting worker architecture is shown in Fig. 4. Tasks are distributed by a worker pool, which submits them to the worker processes and collects their completion results asyn- chronously. Each task is associated with a fresh workspace, isolated through a container interface to prevent interference across workers and to protect the host environment. Within a workspace, the worker follows a two-file work- flow:draft.pyis used for iterative development and 4 LLM Evaluation Sionna doc Run code Edit filesystem Install packages Tools Workspace Hyperparameter tuning (Optuna) solution.py evaluate trials (metric, complexity) points and hyperparameters FIGURE 4.Worker architecture. Each worker runs an agentic ReAct loop [22] operating inside an isolated containerized workspace with access to tools, including the evaluation tool. Once the worker completes, an optional postrun stage tunes the algorithm’s hyperparameters. experimentation, whilesolution.pystores the best- performing code encountered so far. 1 The evaluation tool is invoked repeatedly by the worker LLM ondraft.py. When a new best metric is achieved, the framework automat- ically copiesdraft.pytosolution.py, ensuring that progress is preserved even if the worker is interrupted. The worker is terminated either when the worker LLM decides to stop or when a generation-level timeout is reached. In either case,solution.pyis retained as the worker’s output for downstream processing. 1) Hyperparameter Fine-Tuning To reduce the risk of discarding a promising algorithm due to poorly chosen hyperparameters, AITE performs optional postrun hyperparameter tuning on each successful worker output, as shown in Fig. 4. The worker LLM is instructed to declare tunable hyperparameters by calling one of the following forms: HP.get("name", default, low=..., high=...) HP.get("name", default, choices=[...]) corresponding, respectively, to a bounded numerical range and a categorical choice set. The framework parses the abstract syntax tree ofsolution.pyto extract the implied search space, then runs Bayesian multiobjective optimization using Optuna [23] over the task metric and complexity. Each Optuna trial evaluatessolution.pyfor one can- didate hyperparameter configuration using the evaluation 1 Although we use Python in this work, having AITE write code ina different language is straightforward. tool and yields a single (metric, complexity) point. Because the two objectives often conflict, tuning does not return a single best configuration but a set of Pareto-optimal ones. Each retained configuration is then attached to the worker’s generated algorithm in the global leaderboard as a distinct (metric, complexity) point, tagged with its hyperparameter values. A single worker output may therefore contribute several leaderboard points, rather than just one. 2) Sionna In our experiments, AITE uses Sionna [24] to perform link- level simulations. To help workers write correct Sionna code (in PyTorch [25]), the framework provides a documentation tool offering three operations:Search,Help, andList.Search performs semantic retrieval over the Sionna application pro- gramming interface (API) docstrings and curated tutorials using a FAISS [26] vector store with an external reranker. Helpretrieves the full docstring and signature of a Sionna symbol, whileListenumerates available classes and func- tions within a given Sionna module. 3) Task-Specific Evaluation Tool The evaluation tool is a critical component of the system. It is supplied by the user as part of the task specification and, by defining the metric and the complexity proxy to optimize, fixes the two objectives that drive the entire search. In our experience, it is also typically the bottleneck of the optimization, consuming the largest share of the compute and time budget. Communication algorithms are usually assessed through Monte Carlo simulations, which trade accuracy for compute. More accurate or exhaustive simulations therefore come at the cost of slower evaluations and, for a fixed time and compute budget, fewer generations of the framework. In AITE, each task provides its evaluation tool as a pluggable component that executes worker code and returns a standardized, parseable output. The first line follows one of two forms:SUCCESS, <metric>, <complexity>or a bareFAILURE. A binary success/failure flag is thus always available and, on success, the returned metric and complexity define the algorithm’s position in the two-objective plane. Beyond scoring, the evaluation tool can enforce constraints by returning a failure whenever a requirement is violated (e.g., when a secondary metric exceeds a threshold), thereby restricting metric optimization to a feasible set. It can also return error messages and warnings. To prevent any single evaluation from stalling the optimization loop, each invoca- tion is subject to a configurable timeout. Moreover, workers can invoke the evaluation tool but cannot modify it, which prevents direct modification of the scoring procedure while still allowing arbitrary user-defined evaluation code. I. OTFS Equalizer Design The first task assigned to AITE is to implement an equalizer for an OTFS system [20]. In short, the receiver makes the 5 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms noisy observationy=Hx+wof a vector of constellation symbolsxthrough a channel matrixH. KnowingHand the varianceN 0 of the elements of the noise vectorw, the equalizer must produce bitwise log-likelihood ratios (LLRs) for a channel decoder. Equalizers are ranked by the normalized validation error (NVE) [27], the ratio of the coded block error rate (BLER) achieved by the equalizer to that of a reference equalizer, averaged over a set of signal- to-noise ratio (SNR) valuesS, NVE = 1 |S| X SNR∈S BLER cand (SNR) BLER ref (SNR) ,(1) so thatNVE≤1means the equalizer matches or beats the reference on this averaged metric. The latency of the equal- izer (which must be compatible withtorch.compile) is used as a proxy for complexity. A. System Model We consider an OTFS system whose transmit signal is, for every sub-block, an OFDM waveform with a cyclic prefix (CP). The data symbolsx[l,k]are defined on the delay– Doppler (D) grid, for0≤l < Mand0≤k < N, where MandNdenote the delay and Doppler bin count, respec- tively. The data symbols are mapped to the time–frequency grid by the inverse symplectic finite Fourier transform X tf [n,m] = 1 √ MN M−1 X l=0 N−1 X k=0 x[l,k]e j2π ( nk N − ml M ) (2) and then modulated onto a CP-OFDM waveform with a rectangular transmit pulse, CP lengthT cp , subcarrier spac- ing∆f, symbol periodT= 1/∆f, and sample period T s =T/M. We assume a linear time-varying multipath chan- nel withPpaths h(τ,ν) = P X i=1 h i δ(τ−τ i )δ(ν−ν i ),(3) where pathihas gainh i , delayτ i , and Dopplerν i . The CP is assumed longer than the delay spread and the path parametersh i ,τ i , andν i are constant over the OTFS frame. As shown in Appendix A, one can derive the following input–output relation for the OTFS system: y=Hx+w,(4) wherex,y∈C MN are the vectorized transmitted and received symbols, respectively,H∈C MN×MN is the ef- fective D channel matrix with elements given by (14), and w∈C MN is a vector of complex additive white Gaussian noise (AWGN) with varianceN 0 . As discussed at greater length in the appendix, one may truncate the channel matrix to a row-sparse approximation e H, e.g., by keeping only the top-kstrongest taps per row, with little loss in accuracy. This structure can be efficiently exploited by several classes of equalizers. Since Sionna [24] does not support OTFS in its current version, we provide a new Sionna OTFS module with all required functionality in the article’s code repository. B. Prior Art Most practical OTFS equalizers are iterative schemes that operate on the row-sparse e Hchannel representation instead of the denseHmatrix. This avoids the prohibitively high complexity of inverting a largeMN×MNmatrix, as in, for example, the linear minimum mean-square error (LMMSE) estimate b x= (H H H+N 0 I) −1 H H y. The interference- cancellation message passing (MP) detector of [28] is the canonical example, exchanging beliefs over the discrete constellation symbols on the factor graph induced by the sparse channel. Gaussian-message variants reduce the per- edge cost while retaining calibrated soft outputs, e.g., the unitary approximate message passing (UAMP) detector [29] and the expectation propagation (EP) detector [30]—which serves as the reference baseline in this work due to its excel- lent performance and low complexity. All of these exploit the row sparsity of e H, so their per-iteration complexity scales asMNS, whereSis the number of retained taps per row, rather than as(MN) 2 . Low-complexity LMMSE receivers in [31], [32] exploit afullblock-circulant-with-circulant- blocks effective D channel matrix, which reduces equaliza- tion to a 2-D discrete Fourier transform (DFT). That stronger property holds for ideal biorthogonal pulses with integer or slowly varying Doppler, but fails under the rectangular-CP waveform withcontinuousdelayandDoppler considered here. The channel nevertheless remains block-circulant along the Doppler index [28], so that a Doppler DFT still decouples theMN×MNsystem intoNindependentM×Mblocks. Most competitive algorithms discovered in this task exploit this structure. C. Simulation Setup We consider an OTFS system withM=N= 64delay and Doppler bins, a carrier frequency of 4 GHz, a subcarrier spacing of∆f=15 kHz, and a16-sample CP. Information bits are encoded by a rate-1/25G low-density parity-check (LDPC) code with block length 16 384, mapped to a16- quadrature amplitude modulation (QAM) constellation, and then placed on the D grid. As perfect channel state infor- mation (CSI) is assumed, no pilots need to be sent. We use the continuous D channel model (13) (see Appendix A) withP= 6paths. Per frame, the path gains are independently and identically distributed accord- ing toCN(0,1/P), the delays are uniform on[0,14T s ] (i.e., up to 14.6μs), and the Doppler shifts are uniform on[−0.5∆f,0.5∆f](i.e., from −7.5 kHz to 7.5 kHz). The first path is fixed at zero delay and zero Doppler. The path parameters are constant over the frame and the exact full- period input–output relation is used for the simulation ofy. An equalizer can use either the dense representation or a row-sparse version obtained by retaining the top-kstrongest taps per row, where the number of retained taps is a free pa- rameter. The noise variance follows the unit-average-symbol- energy conventionN 0 = 10 −SNR dB /10 , and the evaluation 6 TABLE 1.Algorithm families explored in the candidate search for theOTFS equalizer design task FamilyCore operationCandidatesBest NVELatency of best VAMP / OAMP [33], [34]Block-FFT linear module with extrinsic Gaussian–QAM iterations5570.4965.28 ms EP / EC [30], [35]Linear Gaussian updates alternating with extrinsic QAM denoiser3920.4966.40 ms Proximal MAP / ADMM [36], [37]Projected-gradient or ADMM steps with QAM proximal thresholding1160.5496.56 ms List /K-best [38], [39]Local search over a small QAM neighborhood with residual scoring880.5613.36 ms GAMP / AMP [40], [41]Scalar AMP on the sparse D graph with Onsager correction1080.63037.60 ms Linear / LMMSE [31], [32]One-shot Wiener solve, dense or Doppler-FFT block-structured2520.6592.24 ms BP / MP [28]Sparse-graph belief propagation with leave-one-out interference970.67719.52 ms PIC / SIC [28]Parallel or successive interference cancellation on sparse residuals1150.67710.64 ms Krylov / PCG [42]Iterative solve of the regularized normal equations1301.14210.64 ms Fusion / gating [43]Weighted combination of multiple detector LLR streams221.2583.28 ms Low-rank / subspace [44]Reduced-dimension solve via low-rank channel approximation131.8235.60 ms Abbreviations:vector approximate message passing (VAMP), orthogonal approximate message passing (OAMP), expectation propagation(EP), expectation consistency (EC), maximum a posteriori (MAP), alternatingdirection method of multipliers (ADMM), generalized approximate message passing (GAMP), approximate message passing (AMP), linear minimum mean-square error (LMMSE), belief propagation (BP), message passing (MP), parallel interference cancellation (PIC), successive interference cancellation (SIC), preconditioned conjugate gradient (PCG). SNR grid for the NVE calculation isS=13dB,16 dB, with EP [30] (top-k= 256) as the reference equalizer. D. Results Over 60 generations, AITE produced 1890 working can- didates implementing 1114 distinct equalizer architectures. We used GPT-5.5 as the underlying LLM and a cluster of 16 graphics processing units (GPUs) running 32 workers per generation. The search broadly explored the accuracy– latency tradeoff across a large variety of algorithm families cataloged in Table 1. Fig. 5(a) shows the evolution of the best NVE across generations and the corresponding latency. The best NVE decreases from0.677to0.549by generation 3 and reaches0.496by generation 9, with no further improvement observed thereafter. The search then focused on ways to re- duce latency without degrading performance. Fig. 5(b) shows the Pareto front together with off-front solutions, zoomed to the low-NVE-low-latency region for readability. Notably, many families of algorithms reach comparable performance, especially with the right hyperparameter tuning. All well- performing algorithms exploit the block-circulant channel structure mentioned earlier. We select a candidate from the expectation consistency (EC) family found in the 59th generation with an interesting accuracy–latency tradeoff (NVE = 0.549, latency 2.17ms), highlighted in Fig. 5(b), as a representative example for comparison with several baselines. As shown in Fig. 6, the generated algorithm beats all conventional baselines in coded BLER, including MP [28], EP [30], and UAMP [29]. At the same time, Table 2 shows a per-frame latency of 2.17 ms on an NVIDIA RTX PRO 6000 and 3.52 ms on an NVIDIA DGX Spark. These values correspond to speedups of around3.6×over the most competitive baseline, 1102030405060 0.5 0.55 0.6 0.65 0.7 Generation Best NVE 0 10 20 30 40 Latency of best (ms) NVE Latency (a) Best NVE across generations and their corresponding latency 246 1 2 Off-front Pareto front Selected Latency (ms) NVE (b) Generated equalizers in the latency–NVE plane FIGURE 5.Results of the AITE run for the OTFS equalizer task. UAMP [29], on both platforms and of66×and210×over LMMSE on the RTX PRO 6000 and DGX Spark, respec- tively. Note that all baselines underwent the same Optuna- based hyperparameter tuning [23] as the generated algo- rithms, and their implementations were optimized for latency 7 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms 121314151617 10 −3 10 −2 10 −1 10 0 SNR (dB) Coded BLER LMMSE NVE reference MP EP UAMP Generated algorithm FIGURE 6.Coded BLER versus SNR for various OTFS equalizers. The values in parentheses show the speedup relative to LMMSE on an NVIDIA RTX PRO 6000. LMMSE uses the dense channel representation; MP uses top-k= 512; UAMP uses top-k= 2048; EP uses top-k= 512; and the generated algorithm uses top-k= 2560. The equalizer used as a reference for the NVE in(1)is EP with top-k= 256. TABLE 2.Per-frame inference latency. Speedup is relative to LMMSE RTX PRO 6000DGX Spark EqualizerLatencySpeedupLatencySpeedup LMMSE143.84 ms1.0×741.92 ms1.0× MP58.56 ms2.5×365.92 ms2.0× EP18.64 ms7.7×108.00 ms6.9× UAMP7.76 ms18.5×12.16 ms61.0× Generated2.17 ms66.3×3.52 ms 210.8× with the help of agentic coding tools. A detailed discussion of the generated algorithm and how it achieves state-of-the- art performance at lower latency is deferred to Appendix B. This fine-grained optimization was performed across hun- dreds of candidates explored in parallel, illustrating how evolutionary agentic search can apply implementation-level refinement at scale. IV. Explainable Pilotless OFDM Receiver The second task assigned to AITE is to generate an ex- plainable pilotless OFDM receiver. This line of work builds on prior results on pilotless OFDM communication [21], which showed that the OFDM waveform can operate without reference signals when the transmitter and receiver are jointly optimized through end-to-end learning. In that setting, a learned constellation shown in Fig. 7 is used to modulate the transmitted bits on all resource elements (REs) of the OFDM resource grid, and a neural-network-based receiver maps the received grid directly to LLRs for the coded bits. The objective of this experiment is to retain the pilotless transmission scheme using the learned constellation, while replacing the black-box neural receiver with an explainable receiver algorithm discovered by AITE. Algorithms using −1−0.5 0 0.5 1 −1 −0.5 0 0.5 1 In-phase Quadrature FIGURE 7.Learned2 M -point constellation (M= 6). OFDM symbols Subcarriers (a) With DMRS OFDM symbols Subcarriers (b) Pilotless (all data) FIGURE 8.Resource grids (12×14REs in this figure) for pilot-assisted and pilotless transmission. Dark REs carry DMRS; light REs carry data. In (a), DMRS symbols are placed in OFDM symbolst∈ 3,12. sparse pilots exist [45], [46], [47], as do fully pilotless schemes relying on multiple constellations to enable channel estimation [48], [49]. However, the literature still lacks a non-neural pilotless OFDM method that uses a single constellation over all REs. Moreover, none of the existing solutions seems to address the computation of LLRs for the transmitted bits, which are required for channel decoding and are challenging to obtain as they rely on accurate calculation of the channel estimation error. It is thus unlikely that AITE can reproduce an algorithm from its LLM training data. A. System Model We consider a single-input single-output OFDM link operat- ing on a resource grid withN F subcarriers andN T OFDM symbols per slot, yieldingN F N T REs indexed by(f,t)with 1≤f≤N F and1≤t≤N T . The constellation used to modulate the transmitted bits is denoted byC ⊂C, with |C|= 2 M , whereMis the number of bits per symbol. Fig. 8 contrasts the resource allocation in a conventional pilot-assisted grid and in the pilotless grid. In the former case, a subsetPof REs carries known demodulation refer- ence signal (DMRS) symbols. In the latter case,P=∅and all REs are occupied by data symbols. On the receiver side, after cyclic-prefix removal and DFT, the complex baseband received symbols satisfy Y=X⊙H+W,(5) 8 BitsTransmitter OFDM channel Equalization Demap. Channel estimation LLRs Receiver QAM constellation (a) Pilot-based baseline Bits Transmitter OFDM channel Neural receiver LLRs Learned constellation (b) Pilotless with neural receiver Bits Transmitter OFDM channel Generated receiver LLRs Learned constellation (c) Pilotless with AITE-generated receiver FIGURE 9.End-to-end OFDM receivers considered in this section: (a) conventional pilot-based baseline with QAM and DMRS; (b) pilotless system with learned constellation and neural receiver [21]; (c) pilotless system with learned constellation and AITE-generated receiver. whereX∈C N F ×N T are the transmitted symbols,H∈ C N F ×N T is the channel matrix,W∈C N F ×N T is AWGN with per-RE varianceN 0 ,Y∈C N F ×N T is the received grid, and⊙denotes elementwise multiplication. The pilotless system we build upon was introduced in [21], in which the constellation at the transmitter is jointly opti- mized with a neural network at the receiver, as shown in Fig. 9(b). The neural receiver substitutes for channel esti- mation, equalization, and demapping. It maps the received resource grid to LLRs. In this work, the neural receiver is a residual convolutional neural network as in [21]. On the transmitter side, only the constellation is learned, while the remainder of the transmission pipeline stays conventional. The trainable parameters consist of a set of2 M complex numbers e C=ec 1 ,...,ec 2 M, which are centered and nor- malized to form the constellationCused to modulate the transmitted data, C= ec−μ q 1 2 M P ̃c ′ ∈ ̃ C |ec ′ | 2 −|μ| 2 ec∈ e C ,(6) whereμ= 1 2 M P ̃c∈ ̃ C ec, so thatChas zero mean and unit average power. Centering prevents the learned constellation from embedding a superimposed pilot in its mean, which would act as a known reference signal. The learned constel- lation is applied to every RE of the resource grid, as shown in Fig. 8(b). Consequently, the resulting scheme uses neither orthogonal nor superimposed pilots. The results reported in [21] show that the neural receiver is able to recover the transmitted bits despite the lack of pilots. Removing pilots frees the REs that conventional systems reserve for reference signals and reallocates them to data, which translates into significant throughput gains. Achieving this requires the learned constellation to adopt an unconventional geometry, shown in Fig. 7. While effective, the neural receiver inherits the general lack of explainability of neural networks. This makes the design difficult to analyze and extend, e.g., to multiple spatial streams or different mod- ulation orders. It also motivates the search for an explainable algorithmic receiver that AITE is asked to find. B. Simulation Setup We consider an OFDM system withN F = 72subcarriers andN T = 14OFDM symbols. To train the end-to-end learning system (Fig. 9(b)) and generate algorithms with AITE (Fig. 9(c)), we use the TDL-C channel model with a nominal delay spread of 100 ns, a carrier frequency of 2.6 GHz, a subcarrier spacing of 30 kHz, and user speeds between 0 and 3 m/s. The constellation optimized through end-to-end learning, shown in Fig. 7, is reused unchanged for generating algorithms with AITE. The evaluation tool returns the NVE defined in (1), computed over two SNR points, 15 dB and 20 dB, using the pilot-based baseline in Fig. 9(a) as the reference. The average latency required to run the algorithm is used as a proxy for complexity. We benchmark the generated algorithm on the TDL-A and TDL-D models, which are non-line-of-sight (NLoS) and line-of-sight (LoS) models, respectively, with the same nominal delay spread and user speeds. Evaluating on channel models unseen during training probes the generalization capabilities of the receivers. For all receivers considered in this section, the resulting LLR vector is passed to the same LDPC decoder with code rater c = 0.7, which outputs hard decisions on the transmitted information bits. C. Results We ran the framework for 42 generations with GPT-5.5 as the LLM and 32 workers per generation on a cluster of 16 GPUs. Fig. 10(a) reports the evolution of the search. The best NVE decreases rapidly during the first generations and reaches1.02at generation 25; among tied-best solutions, latency continues to decrease through generation 34. In total, AITE produced 1240 functional receivers. Rather than the monotone refinement of a single algorithm, the search can be described as a broad exploration that gradually concen- trated around a small number of ideas. The first generation instantiated more than a dozen different receiver families, most of them performing poorly. Compared to the OTFS equalizer task, this task proved more challenging for AITE, requiring more than 20 gen- erations to converge, as shown in Fig. 10(a). Since no directly applicable prior art is available, AITE had to dis- cover the key methods enabling blind detection, in what 9 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms resembles a research process. Progress originated from a small number of breakthroughs rather than from incremental tuning of a single approach. The first key realization was that the structure of the learned constellationCcan be leveraged to initialize the channel estimate blindly. Because the transmitted symbols are drawn fromCon every RE, the local empirical moments of the received grid relate to those of the constellation, i.e., over a small time–frequency neighborhood,E[Y m ]≈H m E[C m ]for integerm, where Cis uniformly distributed onC. Estimating these moments and taking themth root therefore yields a per-RE channel estimate up to a discretem-fold phase ambiguity, with the residual ambiguity resolved by selecting the root that maxi- mizes the likelihood P c∈C exp −|Y−Hc| 2 /N 0 , which is possible only because the learned constellation, unlike QAM, has no rotational symmetry. The resulting estimate is accurate enough to seed an expectation–maximization (EM) refinement loop that alternates between soft symbol posteriors and a channel update. This single idea moved the receiver out of the failure regime, and essentially every subsequent frontier solution descends from it. A second breakthrough was not to commit to a single channel estimate, but to retain a small set of competing channel hypotheses per RE and use a log-sum-exp demapper that marginalizes the likelihood over both the candidate chan- nels and the constellation points when computing the per-bit LLRs. From these two ideas, the improvements that mattered were obtained by stacking complementary mechanisms onto this backbone rather than by replacing it. Several of the families that had failed as standalone receivers reappeared at the Pareto front by being injected as refinements. These auxiliary refinements are of three kinds. First, a belief-propagation refinement exploits the similarity of the channel gains at neighboring REs. These gains largely cancel in the ratio of the two received samples, leaving a relationship governed primarily by the two transmitted constellation points. Treating these pairwise relationships as soft constraints and propagating them across the grid sharpens the symbol decisions where the channel is hard to estimate directly. Second, a decision-directed channel- tracking candidate turns the receiver’s soft estimate of the transmitted symbols into virtual pilots, from which an ad- ditional channel estimate is formed and smoothed. Third, a local affine model assumes that the channel varies approxi- mately linearly within a small time–frequency patch and fits an affine plane to each patch to denoise the channel estimate. In summary, after broad, divergent exploration, the lowest- NVE solutions share a common receiver backbone, with the bulk of the gain explained by a few enabling ideas and by the recombination of mechanisms that were individually insufficient. Fig. 10(b) shows the Pareto front of the set of generated receivers together with the off-front solutions, with the view zoomed in on the low-NVE region. Several algo- rithms attain the lowest NVE of1.02. Among them, we select the one with the lowest latency, highlighted in Fig. 10(b), for 110203040 1 2 3 4 5 Generation Best NVE 0 0.5 1 1.5 2 2.5 Latency of best (ms) NVE Latency (a) Best NVE achieved so far and their corresponding latency 0.511.52 1 2 3 4 Off-front Pareto front Selected Latency (ms) NVE (b) Generated algorithms in the latency–NVE plane FIGURE 10.Results of the AITE run for the pilotless receiver task. evaluation against the baselines. A more detailed description of this algorithm is provided in Appendix C. We benchmark the selected algorithm against two base- lines: a pilot-based baseline (Fig. 9(a)) and the neural receiver trained jointly with the constellation for pilotless communication (Fig. 9(b)). The pilot-based baseline follows a standard processing chain, i.e., least-squares channel es- timation at the pilot positionsP, linear interpolation of the channel estimates and error variances onto all data REs, LMMSE equalization, and a posteriori probability demapping to LLRs. This baseline is implemented with the corresponding components from Sionna [24] and employs a 2 M -QAM constellation. The goodput achieved by the evaluated receivers on TDL- A and TDL-D is reported in Fig. 11(a) and 11(b), respec- tively, and is defined as Goodput= (1−BLER)r c r p M,(7) wherer c = 0.7is the code rate andM= 6is the number of bits per constellation symbol. The factorr p is the fraction of REs carrying data:r p = 1for the pilotless approaches and the perfect-CSI upper bound, andr p = 12/14for the pilot- based baseline. As the figures show, the generated algorithm achieves goodput on par with that of the neural receiver on both channel models. Both pilotless receivers realize the expected throughput gain over the pilot-based baseline, which comes from reallocating pilots to data. 10 812162024 0 1 2 3 4 SNR (dB) Goodput (bit/RE) Perfect CSI Generated algorithm Neural receiver Pilot baseline (a) Goodput on TDL-A (NLoS) 812162024 0 1 2 3 4 SNR (dB) Goodput (bit/RE) (b) Goodput on TDL-D (LoS) FIGURE 11.Evaluation of the selected AITE-generated receiver algorithm against the pilot-based baseline and the neural receiver. The perfect-CSI upper bound uses2 M -QAM on every RE, exact channel coefficients, and the same demapper and LDPC decoder as the pilot-based baseline. The latency, measured on an NVIDIA RTX PRO 6000, is 0.694 ms for the neural receiver and 1.23 ms for the generated algorithm. The longer latency is somewhat ex- pected because, with the used PyTorch backend, the con- volutional layers of the neural receiver map efficiently onto the GPU, whereas the generated algorithm relies on non- neural signal-processing operations that are less amenable to straightforward parallelization. Being explainable, however, the generated algorithm is easier to analyze and improve. For instance, it could be extended to other modulation orders and multiple spatial streams, or accelerated through a dedicated CUDA implementation. Both are left to future work. V. Concluding Discussion Our experiments demonstrate that LLM-driven evolutionary search can discover novel wireless algorithms that are on par with or even surpass the current state of the art. Such methods allow for the parallel exploration and implemen- tation of a large number of algorithmic ideas for a specific problem with the goal of building a performance–complexity Pareto front of solutions from which the most suitable can be selected. We believe that agentic tools like AITE are likely to become essential for the design of competitive algorithms in the future, and the broader impact of this development has been discussed by some of us [50]. Developing AITE led us to identify several practical enablers and limitations, which we discuss in the remainder of this section. A. Impact of the Underlying LLM The quality of the generated algorithms is strongly affected by the capabilities of the LLMs used. Experiments with smaller, less capable LLMs yielded significantly less com- petitive algorithms on complex tasks and required a larger number of iterations to converge. Even when smaller LLMs proposed strong ideas, they often struggled to implement them correctly or to follow the instructions provided by the orchestrator, resulting in a higher rate of unexploitable algorithms. This observation motivated the use of a frontier model (GPT-5.5) for the experiments reported in this article. Each task took approximately four days on a cluster of 16 GPUs and incurred an LLM inference cost of about USD 2500 at the time of writing. However, this cost is likely to decrease significantly in the future. Quantifying the run- to-run variability of the search outcome remains open. B. The Importance of the Evaluation Tool The definition of the evaluation metric is one of the most im- portant design decisions because evolutionary search will re- lentlessly try to optimize for it and, as in supervised machine learning, there is a risk of overfitting to the evaluation tool (including channel models and target hardware platforms). One way to circumvent this could be avalidation toolwhose outputs would only be used to detect when algorithms start to overfit so that they are not selected for refinement in future generations. In addition, we observed that AITE spends most of the running time evaluating candidate algorithms, as opposed to generating and implementing them. For the two tasks considered in this article, this evaluation is based on Monte Carlo simulations of BLER curves for the NVE as well as latency measurements of PyTorch-compiled code. The more accurate the desired metric estimates, the longer the evaluation takes. Designing an efficient evaluation tool is therefore a critical enabler for the scalability of evolutionary search methods. This becomes even more important when evaluations are carried out in large digital twin networks or with hardware-in-the-loop requiring time-consuming compi- lation or high-level synthesis. C. Hyperparameter Tuning Most generated algorithms have hyperparameters, whose number typically grows as the evolutionary search progresses and the algorithms become more complex. As described in Section I-C1, AITE provides a hyperparameter fine-tuning stage, which was applied to every candidate algorithm in the experiments reported here. However, Bayesian optimization becomes impractical with even a few dozen hyperparameters. One solution would be to replace Bayesian optimization with gradient descent for differentiable continuous hyper- parameters, combined with a separate optimization method for those defined in discrete spaces, such as the number of iterations. A different approach would be to run substantially fewer generations of the framework and to perform more 11 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms exhaustive hyperparameter fine-tuning for each candidate. The optimal allocation problem remains unresolved. D. Idea Generation: Exploration Versus Exploitation Evolutionary search frameworks like AITE need to solve an exploration–exploitation tradeoff at the start of each generation, when a finite number of workers must be tasked either with exploring novel ideas or refining ideas from previous generations. Insufficient exploration may cause po- tential breakthrough ideas to be missed, while insufficient exploitation may cause promising ideas to be discarded prematurely. In AITE, the orchestrator LLM is responsible for solving this tradeoff through careful prompt refinement. Other frameworks adopt different strategies [9], [11], [12]. Improving the sample efficiency of the search is an important direction for future work that would also allow reallocating resources to hyperparameter tuning, cf. Section V-C. E. Measuring Complexity We can characterize algorithmic complexity in many ways. Theoretical complexity concepts such as floating-point oper- ations or asymptotic analysis are important for high-level comparisons, but they are often unreliable indicators of actual latency or throughput on target hardware, such as a GPU or a central processing unit. Unfortunately, measuring these concrete metrics requires direct access to the target hardware, which is often infeasible in large compute clus- ters. Frameworks like AITE can in principle use arbitrary complexity metrics, but, much like the evaluation metric, these metrics must be chosen carefully to properly steer the search toward practically relevant outcomes. Appendix A OTFS Input–Output Relation Based on the system model in Section I-A, we derive a closed-form input–output relation for the OTFS system for use in the evaluation tool’s Monte Carlo simulations. Let us introduce the normalized D coordinates e l i ,τ i M∆f=l i +ε i , e k i ,ν i N(T+T cp ) =k i +κ i ,(8) with nearest integersl i ,k i ∈Zand fractional partsε i ,κ i ∈ (− 1 2 , 1 2 ]. The received signaly[l,k]on the D grid after matched filtering, sampling at rate1/T s , CP removal, and the unitary per-sub-blockM-point DFT and symplectic finite Fourier transform is then given by (13), where Φ i (l) =e −j2πν i τ i e j2πν i lT s ,(9) D Q (ξ) = 1 Q Q−1 X q=0 e j2πqξ/Q (10) are per-path phase terms andQ-point Dirichlet kernels, respectively. Here,(·) Q denotes reduction moduloQ, and w[l,k]is standard complex AWGN with varianceN 0 . The values ofγ τ andγ ν run over the windows W τ =−⌊M/2⌋,...,⌈M/2⌉−1,(11) W ν =−⌊N/2⌋,...,⌈N/2⌉−1(12) of size exactlyMandNfor either parity. Collecting the D symbols into vectorsx,y,w∈C MN by assigning each cell(l,k)the scalar indexn(l,k),k+ Nl(row-by-row stacking, with the Doppler index varying fastest, so that[x] n(l,k) =x[l,k], and likewise foryandw), we can write the input–output relation (13) compactly as y=Hx+w, whereH∈C MN×MN is the effective D channel matrix with elements given by (14). For the full windowsW τ ,W ν , the summations over the Kronecker deltas have exactly one nonzero term for everyl,l ′ ,k,k ′ , so thatHis generally dense for noninteger delays or Dopplers. In practice, the windows can be truncated with little loss in accuracy to f W τ =−N τ ,...,N τ and f W ν = −N ν ,...,N ν with2N τ +1≪Mand2N ν +1≪N. When these truncated windows are used in (14), only the (2N τ + 1)(2N ν + 1)columns nearest the integer shift (l−l i ,k−k i )are nonzero for each path, yielding a row- sparse matrix e Hwith at mostS=P(2N τ + 1)(2N ν + 1) nonzero entries per row. Alternatively, rather than fixing the windows a priori, one can compute the exact denseHand retain in each row only the top-kentries with the largest absolute value. This yields a controlled sparse approximation whose accuracy increases monotonically withk, and—in contrast to the fixed window above—adapts to the actual location of the dominant taps, which is advantageous under pronounced fractional-delay or fractional-Doppler leakage. Equalizers can choose to work with such truncated channel matrices for efficiency, whereas the simulation ofyalways uses the full channel matrix. Appendix B Discussion of an OTFS Equalizer Candidate For an observationyand perfect channel knowledgeH, the equalizer’s goal is to compute the posterior marginals p(x r |y)forr∈ 0,...,MN−1under the channel likelihood (4) and a discrete priorp(x r ), which accounts for the fact that all symbols are drawn from a QAM constellation Q=α 1 ,...,α Q of orderQ. Computing the joint posterior p(x|y)∝p(y|x)p(x)is prohibitive because all symbols are discrete and coupled by the matrixH. The algorithm sidesteps this by approximating the posteriorp(x|y)with a Gaussianq(x)whose marginal moments are made consistent between two simpler views of the problem, iterating until both agree. This two-module moment-matching construction is an EC approximation [35] and works as follows: A. Module A: Linear Model with Gaussian Prior The first view corresponds to the linear model (4) with a Gaussian symbol priorp B (x)which it receives from Module B. This prior is defined by its natural parameters, the precisionp B ∈R MN + and precision-weighted mean η B ∈C MN . In the first iteration this message is initialized to the unit-energy Gaussian prior,p B =1andη B =0, 12 y[l,k] = P X i=1 h i Φ i (l) X γ τ ∈W τ X γ ν ∈W ν D M (γ τ −ε i )D N (γ ν +κ i )x[(l−l i −γ τ ) M ,(k−k i +γ ν ) N ] +w[l,k](13) [H] n(l,k), n(l ′ ,k ′ ) = P X i=1 h i Φ i (l) X γ τ ∈W τ D M (γ τ −ε i )δ[l ′ −(l−l i −γ τ ) M ] X γ ν ∈W ν D N (γ ν +κ i )δ[k ′ −(k−k i +γ ν ) N ](14) so that Module A reduces to a plain linear (LMMSE-type) estimate. Under this assumption, the corresponding posterior is also Gaussian with natural parameters ̃ p A and ̃ η A : ̃ p A =1⊘diagpart A −1 (15) ̃ η A = ̃ p A ⊙ A −1 η B + 1 N 0 H H y (16) A= diag (p B ) + 1 N 0 H H H,(17) where⊙and⊘denote elementwise multiplication and division, respectively. Module A sends to Module B only the extrinsic Gaussian with natural parameters p A = ̃ p A −p B ,η A = ̃ η A −η B .(18) B. Module B: QAM Denoiser via Moment Matching This view treats the discrete prior exactly and accounts for the channel only through the message it receives from Module A, which it interprets as a per-symbol Gaussian pseudo-observation of the transmitted symbols r A =x+n,(19) wherer A =η A ⊘p A , andn∼ CN(0,diag(p A ) −1 ). As- suming equiprobable constellation symbols, it then computes for each symbol indexrthe discrete posteriorγ r,q =p(x r = α q |r A,r )over theQconstellation points: γ r,q = exp −p A,r |r A,r −α q | 2 P Q q ′ =1 exp (−p A,r |r A,r −α q ′ | 2 ) .(20) As this tilted posterior is not Gaussian, Module B projects it back onto a Gaussian by matching its first two moments, giving the posterior mean ̃ r B and variance ̃ v B with ̃r B,r = Q X q=1 γ r,q α q , ̃v B,r = Q X q=1 γ r,q |α q | 2 −| ̃r B,r | 2 ,(21) which lead to the natural parameters ̃ p B =1⊘ ̃ v B and ̃ η B = ̃ p B ⊙ ̃ r B . Module B then forms the extrinsic message p ext B = ̃ p B −p A ,η ext B = ̃ η B −η A (22) and sends a damped version back to Module A: p B ←(1−β)p B +βp ext B ,η B ←(1−β)η B +βη ext B , (23) withβ∈(0,1]. This exchange is repeated until the marginals of the two modules agree. In this generic form, the per-bit LLRs are read off from the final symbol posteriorsγ r,q . C. Optimized Implementation The generated algorithm is a performance- and latency- optimized version of this algorithm based on the following key modifications: 1)Per-Dopplerblock-diagonalization.The input– output relation (13) is a block-circulant convolution along the Doppler index which can be diagonalized by anN-point DFT along the Doppler axis [28]. This decouples theMN×MNsystem intoNindependent M×Mblocks which can be treated in parallel. The implementation further shares a single precision per delay across all Doppler bins,p B ∈R M + (the mean η B ∈C M×N stays per cell), so the samediag(p B ) regularizes every block. 2)No matrix inversion.Module A never formsA −1 . In (16), Module A uses Cholesky factorization followed by forward/back substitution to obtain ̃ η A for each Doppler block. The posterior precisions in (15) are approximated by a second-order Jacobi estimate of diagpart(A −1 ), averaged over Doppler to one vari- ance per delay index. 3)Few iterations plus one Richardson half-step.The algorithm runs for only two full EC iterations. In the third, the Cholesky solve to compute (16) is replaced by a single low-complexity damped Jacobi (i.e., diag- onally preconditioned Richardson) update [42]: x R = ̃ r B +ωdiag(A) −1 η B + 1 N 0 H H y−A ̃ r B , with relaxation factorω. The associated precision ̃ p A is obtained from (15), and the resultingRichardson cavityfollows by the same extrinsic subtraction as in (18), now withx R in place of the exact posterior mean, p R A = ̃ p A −p B ,r R A = ̃ p A ⊙x R −η B ⊘p R A .(24) This cavity is not fed back to Module B; it is passed directly to the final demapper. 4)Fused demapping from multiple log-metrics.Let L r,q (r,p) =−p r |r r −α q | 2 denote the constellation log-metric of a Gaussian pseudo-observation(r,p), i.e., the numerator exponent ofγ r,q in (20). Rather than demapping a single posterior, the implementation linearly fuses three such metrics, evaluated at the Richardson cavity(r R A ,p R A ), the last cavity(r A ,p A ), 13 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms and the last linear posterior( ̃ η A ⊘ ̃ p A , ̃ p A ), L f r,q =w c L r,q (r R A ,p R A ) +w t L r,q (r A ,p A ) +w ℓ L r,q ( ̃ η A ⊘ ̃ p A , ̃ p A )(25) and reads the per-bit LLRs by max-log demapping, λ r,k = max q∈S 1 k L f r,q −max q∈S 0 k L f r,q ,(26) whereS b k =q:thekth label bit ofα q isb. 5)Scalings and precomputation.The noise variance is scaled, ̃ N 0 =s N 0 N 0 , to correct for model mismatch and used in place ofN 0 . The data terms ̃ N −1 0 H H H and ̃ N −1 0 H H yare formed once per frame and reused across iterations, leaving onlydiag(p B )and the prior- pull term in (16) to update. The output LLRs are finally rescaled by a factors λ before the LDPC decoder. 6)Hyperparameters.The tuned hyperparameters com- prise the channel sparsity, numerical clipping thresh- olds, relaxation and damping factors, fusion weights, noise and LLR scalings, and final demapping rule. They are selected by the framework’s postrun hyper- parameter optimization (Section I-C1). Appendix C Discussion of a Pilotless OFDM Receiver Candidate The receiver maps the received gridYto LLRs through a sequence of stages. For clarity, we only describe the key operation of each stage and omit details such as windowing, damping, and reliability gating. The complete implementa- tion is available in the code repository [18]. Throughout, h·i f,t denotes a local average over a small time–frequency window centered at(f,t). A. Multiscale Moment Initialization The receiver first forms a set of candidate channel estimates using moment matching. Since the constellation has unit average power, the amplitude follows from the received energy: d |H| f,t = q max h|Y| 2 i f,t −N 0 ,0 .(27) The phase is recovered from themth-order moments through the approximationhY m i f,t ≈H m f,t μ m , withμ m = 1 |C| P c∈C c m . Taking themth root leaves anm-fold ambi- guity, b θ (m,r) f,t = 1 m arg hY m i f,t μ m + 2πr m , r= 0,...,m−1, (28) so that the ordersm∈ 2,3,4,6used in the algorithm yield2 + 3 + 4 + 6 = 15candidate phases, hence15 candidate channels b H (m,r) f,t = d |H| f,t e j ̂ θ (m,r) f,t . The moments are estimated at three time–frequency window aspect ratios for the averagingh·i f,t to cover different Doppler and delay profiles. At each scale, theN top candidates with the highest log-likelihood, S (m,r) f,t = * ln X c∈C exp − Y f,t − b H (m,r) f,t c 2 N 0 + f,t , (29) are retained, leaving3N top winners per RE. To these are addedN top candidates obtained by fusing the rank-matched winners of the three scales through a score-weighted average, leading to a cross-scale blended estimate where the scales agree, while the per-scale winners are retained where they disagree. The result is a pool ofK= 4N top candidates per RE, which we reindex by a single labelkand denote by b H (k) f,t K k=1 , with corresponding log-likelihoodsS (k) f,t K k=1 . B. Hypothesis Smoothing Since the moment-based estimates are computed locally and the channel varies smoothly, the discrete choice among the Kcandidates should be coherent across the grid. This is achieved by modeling the resource grid as a conditional random field over the candidates. Let us denote byℓ u the random variable that assigns to each REuthe “true” channel candidate index out of theKcandidates, and byℓ=ℓ u the grid-wide assignment. The posterior onℓis modeled as P(ℓ|Y)∝exp − 1 τ −α X u S (ℓ u ) u +λ X (u,v)∈E w uv b H (ℓ u ) u − b H (ℓ v ) v 2 ! ,(30) whereαandλare hyperparameters andEcollects pairs of neighboring REs. Thew uv are uniform weights over a boxcar window in time and frequency. Since the scoresS (k) u are log-likelihoods, the unary term is the log-likelihood of ℓover the resource grid under an independence assumption. The pairwise term penalizes neighbors that select channels with dissimilar values. Computing the marginals of (30) is intractable, so the posterior is approximated by a product of per-node distribu- tionsQ(ℓ) = Q u q u (ℓ u ), withq u (k)≥0, P K k=1 q u (k) = 1, chosen to minimize the Kullback–Leibler divergence KL QkP(·|Y) . Each factorq u (k)is then the approximate marginal probability that nodeutakes candidatek. Zeroing the gradient of this divergence with respect to eachq u (k) yields the fixed-point update q u (k)∝exp 1 τ αS (k) u −λ b H (k) u − ̄ H u 2 ! (31) for allk∈1,...,K, in which each node sees its neighbors only through ̄ H u = X v∈N(u) w uv K X k=1 q v (k) b H (k) v ,(32) that is, the soft-assigned average channel of neighbors N(u). Note that the implementation approximates (32) by 14 a boxcar window centered onu, which also includes the node’s own soft channel. Since ̄ H u in (32) depends on the same assignments updated by (31), the two are applied alternately: starting from the unary-only assignmentq u (k)∝ exp αS (k) u /τ , a few sweeps iterate (32) and (31). C. Expectation-Maximization The previous two stages aim to provide strong initializations for an EM loop that jointly refines the channel estimates and computes posterior symbol probabilities. Each of the Kcandidates is refined in parallel, withYas the observed data, the channelHas the parameter to be estimated, and the transmitted symbols as the latent variables. The E-step computes soft symbol posteriors under the current channel, p (k) f,t (c)∝exp − Y f,t − b H (k) f,t c 2 /N 0 , c∈C.(33) The M-step re-estimates the channel by treating the resulting soft symbols as pseudo-pilots, implementing a confidence- weighted least-squares fit over the local window, b H (k) f,t ← hw (k) f,t Y f,t bc (k)∗ f,t i f,t hw (k) f,t bv (k) f,t i f,t ,(34) with soft momentsbc (k) f,t = P c p (k) f,t (c)c,bv (k) f,t = P c p (k) f,t (c)|c| 2 , and a per-candidate weightw (k) f,t ∝ (q f,t (k)) κ (max c p (k) f,t (c)) β that combines the posterior q f,t (k)from the previous stage with the symbol-decision probabilities, whereκandβare hyperparameters. After the EM loop, a probability mass function over the candidates is defined by blending the smoothed posterior with how well each candidate explains the received data, π f,t (k)∝ q f,t (k) ρ exp 1−ρ τ π S (k) f,t ,1≤k≤K,(35) such that P K k=1 π f,t (k) = 1, whereS (k) f,t is the local mixture log-likelihood of the form (29) re-evaluated at the converged channel b H (k) f,t ,q f,t (k)is the mean-field posterior obtained by reapplying the smoothing of (31) to these refined scores, and ρ∈[0,1]andτ π are hyperparameters. These weights yield a fused posterior on the transmitted symbols ̄p f,t (c) = K X k=1 π f,t (k)p (k) f,t (c), c∈C.(36) The loop also returns a per-RE channel-estimation variance σ 2 H,f,t , used later for computing the LLRs. D. Ratio-Prior Belief Propagation While (36) gives probability mass functions for all symbols in the resource grid, the true posteriors are coupled, because the channel is approximately constant over neighboring REs. Hence, more accurate marginals of the grid-wide poste- rior can be obtained through a belief propagation-inspired scheme on a Markov random field. This first refinement approximates, for each RE, the marginal of its symbol under the grid-wide posterior, P(c f,t |Y) = X c f,t P(c|Y),(37) wherec=c f,t is the grid-wide symbol labeling, and turns it into a per-RE symbol log-domain refinementΓ f,t (c)that is fed back into the estimation. As all the REs are coupled through the unknown channel, (37) is intractable. It is assumed that the dependency between symbols is restricted to time- and frequency-adjacent REs, which makes P(c|Y)a pairwise Markov random field on the resource grid. For such a field, the Hammersley–Clifford theorem gives the factorization into unary and pairwise potentials, P(c|Y)∝ Y u ψ u (c u ) Y (u,v)∈E ψ uv (c u ,c v ),(38) whereuandvindex REs andEis the set of neighboring RE pairs. The two potentials are set as follows. The unary potential is set toψ u (c) = ̄p u (c) w src , wherew src is a hy- perparameter. The pairwise potential scores adjacent symbols through the ratio of their received samples: two adjacent REs are assumed to experience approximately the same channel (H u ≈H v ), so the channel approximately cancels in that ratio, Y u Y v = H u X u +W u H v X v +W v ≈ X u X v ,(39) and the observed ratioq uv =Y u /Y v depends on the two symbols only. The corresponding potential is ψ uv (c u ,c v ) =e φ uv (c u ,c v ) ,with φ uv (c u ,c v ) =−gln 1 + |q uv −c u /c v | 2 σ 2 uv ! ,(40) withga hyperparameter and ratio-error varianceσ 2 uv ∝ N 0 (1 +|q uv | 2 )/|Y v | 2 . This factor has heavy Cauchy-like tails, which suppress edges near a deep fade where|Y v |is small and the ratio is unreliable. The marginals (37) of the field (38) are approximated by a belief propagation-inspired approach, with each symbol restricted to the setM f,t ⊂Cof its most likely values under the EM posterior. The edge messages are μ v→u (c)∝ X c ′ ∈M v exp (φ uv (c,c ′ ) +w bp b v (c ′ )),(41) withw bp a hyperparameter. The node beliefb u (c)combines the incoming log-messages with the unary log-potential, b u (c) = 1 d u X v∈N(u) w uv ln (μ v→u (c)) +w src R u ln ( ̄p u (c)),(42) whereN(u)is the set of neighbors ofuandd u = P v∈N(u) w uv is the weighted node degree. HereR u ∈[0,1] is a per-node reliability andw uv an edge weight, whose detailed definitions are omitted. While the messages and 15 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms beliefs could be updated alternately over the grid, the imple- mentation runs a single sweep, comprising one frequency- and one time-adjacent pass. The resulting beliefs, mapped back onto the constellation, give the per-RE symbol refinementΓ f,t (c). This refinement is added as a symbol log-prior in a further EM pass, which re-estimates the channel b H (k) f,t and the symbol posteriors using the following E-step in place of (33): p (k) f,t (c)∝exp − Y f,t − b H (k) f,t c 2 /N 0 +w ′ Γ Γ f,t (c) , (43) wherew ′ Γ is a hyperparameter. E. Decision-Directed Tracking and Fusion The second refinement consists in using the fused soft symbol estimatebc f,t = P c∈C ̄p f,t (c)cas a virtual pilot to form a decision-directed estimate, b H ddtf f,t = Y f,t bc ∗ f,t b E f,t , b E f,t = X c∈C ̄p f,t (c)|c| 2 .(44) Each RE is assigned a reliability η f,t =χ f,t |H ⋆ f,t | 2 |H ⋆ f,t | 2 +σ 2 ddtf,f,t (45) with σ 2 ddtf,f,t = N 0 +|H ⋆ f,t | 2 Var f,t (c) b E f,t ,(46) whereH ⋆ f,t = P k π f,t (k) b H (k) f,t is the trust-weighted mean channel,Var f,t (c) = b E f,t −|bc f,t | 2 is the soft-symbol vari- ance, andχ f,t ∈[0,1]is a symbol-confidence factor whose computation details are omitted. The estimate is smoothed by a reliability-weighted Gaussian convolution, b H ddtf f,t ← P f ′ ,t ′ G f−f ′ , t−t ′ η f ′ ,t ′ b H ddtf f ′ ,t ′ P f ′ ,t ′ G f−f ′ , t−t ′ η f ′ ,t ′ ,(47) withGa fixed Gaussian kernel, so that confidently esti- mated REs dominate and unreliable ones are filled in from their neighbors. The same convolution returns a channel- estimation varianceσ 2 H,f,t from the smoothedσ 2 ddtf . The smoothed track is appended to the pool as an addi- tional candidate, with its own varianceσ 2 H,f,t . AllK+ 1 candidates are then re-scored to update the trust weights π f,t (k)by the same construction as (35). Each candidate is rated by its local mixture log-likelihood of the form (29), except that the noise is inflated by the channel estimation variance, i.e.,N 0 +|c| 2 σ 2 H,f,t is used instead ofN 0 . F. Local Affine Correction The third refinement denoises the channel within each small time–frequency patch by fitting an affine surface H(f+δf, t+δt)≈p 0 +p 1 δt+p 2 δf=d ⊤ p(48) over a5×3windowδt∈ −2,...,2,δf∈ −1,0,1 centered on(f,t), whered= [1,δt,δf] ⊤ andp= [p 0 ,p 1 ,p 2 ] ⊤ ∈C 3 , so thatp 0 is the channel at the patch center andp 1 ,p 2 are its temporal and spectral gradients. The parameters minimize the following objective over the patch, J(p) = X δf,δt w f ′ ,t ′ E Y f ′ ,t ′ −(d ⊤ p)c f ′ ,t ′ 2 +λ 0 p 0 −H ⋆ f,t 2 +λ s |p 1 | 2 +|p 2 | 2 ,(49) where(f ′ ,t ′ ) = (f+δf,t+δt)and the expectation is taken over the fused soft symbol at each patch RE, yielding E[ Y−(d ⊤ p)c 2 ] = Y−(d ⊤ p)bc 2 + d ⊤ p 2 Var(c). The weightw f ′ ,t ′ = max(max c∈C ̄p f ′ ,t ′ (c), w 0 ) a grows with the demapping confidence of the RE, so that reliably demapped REs contribute most to the fit. The regularization anchors p 0 to the trust-weighted priorH ⋆ f,t = P k π f,t (k) b H (k) f,t with strengthλ 0 and shrinks the slopes with strengthλ s . Being quadratic inp, (49) is solved in closed form, p= P δf,δt w f ′ ,t ′ b E f ′ ,t ′ d ⊤ +R −1 · P δf,δt w f ′ ,t ′ bc ∗ f ′ ,t ′ Y f ′ ,t ′ d+r 0 ,(50) withR= diag(λ 0 ,λ s ,λ s )andr 0 = [λ 0 H ⋆ f,t ,0,0] ⊤ . Here, b E=|bc| 2 + Var(c). The center valuep 0 is blended with its 3×3neighborhood for spatial consistency, then replaces the dominant candidate through a soft gate that opens according to a confidence threshold. The channel-estimation variance σ 2 H,f,t is correspondingly inflated by the patch residual and the magnitude of the applied correction. G. Demapper Finally, the bit LLRs are computed by a demapper that sums the likelihood over both the constellation points and the competing channel candidates. It first forms a per-symbol log-metric in which the noise variance of each candidate is inflated by its own channel-estimation variance. TheKcan- didates refined by the EM loop share the common variance σ 2 H,f,t , whereas the appended decision-directed track carries its own variance and the affine correction inflates the vari- ance of the candidate it replaces. Together these define the per-candidate varianceσ 2,(k) H,f,t . Letν (k) f,t (c),N 0 +|c| 2 σ 2,(k) H,f,t be the inflated noise variance. Then Λ f,t (c) = ln X k π f,t (k) ν (k) f,t (c) exp − Y f,t − b H (k) f,t c 2 ν (k) f,t (c) +w Γ Γ f,t (c).(51) The ratio refinementΓ f,t is added as a log-prior of weight w Γ . Because the inflated variance also depends on the symbol through|c| 2 , this normalizer is symbol-dependent and penalizes the higher-energy symbols. The raw LLR of bitbmarginalizes this metric over the subsetsC b,1 and C b,0 of constellation points whosebth bit equals1and0, respectively, LLR raw f,t,b = ln P c∈C b,1 e Λ f,t (c) P c∈C b,0 e Λ f,t (c) ! .(52) 16 SinceΓ f,t has already been injected upstream into the channel estimates and trust weights, and through (51) into the metric itself, the raw LLR is not extrinsic to the prior. To provide an approximation of the demapper’s extrinsic infor- mation, the receiver subtracts a reliability-weighted fraction of the prior’s standalone bit-LLRL Γ f,t,b , LLR f,t,b = LLR raw f,t,b −λ f,t L Γ f,t,b ,(53) where the dampingλ f,t grows whereΓ f,t is less reliable, so an uncertain prior is suppressed more strongly in the output. Acknowledgment The candidate algorithm code discussed in Sections I– IV and Appendixes B–C was generated by GPT-5.5 within AITE; the authors verified the implementations and edited the accompanying descriptions. OpenAI Codex with GPT- 5.5 was used to check for grammar and spelling errors. REFERENCES [1] F. Aït Aoudia, J. Hoydis, S. Cammerer, L. Maggi, G. Marti,and A. Keller, “The AI Telco Engineer: Toward autonomous discovery of wireless communications algorithms,” inEuropean Wireless, Rimini, Italy, Jun. 2026. [Online]. Available: https://arxiv.org/abs/2604.19803 [2] J. R. Koza,Genetic Programming: On the Programming of Computers by Means of Natural Selection. Cambridge, MA: MIT Press, 1992. [3] J. Lehman, J. Gordon, S. Jain, K. Ndousse, C. Yeh, and K. O.Stanley, “Evolution through large models,” inHandbook of Evolutionary Machine Learning. Springer Nature Singapore, 2024, p. 331–366. [Online]. Available: https://arxiv.org/abs/2206.08896 [4] E. Meyersonet al., “Language model crossover: Variation through few-shot prompting,”ACM Trans. Evol. Learn. Optim., vol. 4, no. 4, p. 1–40, Nov. 2024. [Online]. Available: https://doi.org/10.1145/3694791 [5] A. Chen, D. M. Dohan, and D. R. So, “EvoPrompting: Language models for code-level neural architecture search,” inProc. 37th Conf. Neural Inf. Process. Syst. (NeurIPS), New Orleans, LA, USA, Dec. 2023, p. 7787–7817. [6] B. Romera-Paredeset al., “Mathematical discoveries from program search with large language models,”Nature, vol. 625, no. 7995, p. 468–475, Jan. 2024. [7] A. Novikovet al., “AlphaEvolve: A coding agent for scientific and algorithmic discovery,”arXiv preprint arXiv:2506.13131, Jun. 2025. [Online]. Available: https://arxiv.org/abs/2506.13131 [8] A. Sharma, “OpenEvolve: An open-source evolutionary coding agent,” https://github.com/algorithmicsuperintelligence/openevolve, 2025. [9] R. T. Lange, Y. Imajuku, and E. Cetin, “ShinkaEvolve: Towards open-ended and sample-efficient program evolution,” arXiv preprint arXiv:2509.19349, 2025. [Online]. Available: https://arxiv.org/abs/2509.19349 [10] L. A. Agrawalet al., “GEPA: Reflective prompt evolution can outperform reinforcement learning,” inInt. Conf. Learn. Representations (ICLR), Rio de Janeiro, Brazil, Apr. 2026. [Online]. Available: https://openreview.net/forum?id=RQm2KQTM5r [11] S. Liuet al., “SkyDiscover: A flexible, adaptive framework for AI- driven scientific and algorithmic discovery,” inProc. ACM Conf. AI Agentic Syst. (CAIS’26), San Jose, CA, USA, May 2026, p. 1223– 1227. [12] M. Cemriet al., “AdaEvolve: Adaptive LLM driven zeroth-order optimization,”arXiv preprint arXiv:2602.20133, Feb. 2026. [Online]. Available: https://arxiv.org/abs/2602.20133 [13] S. Liuet al., “EvoX: Meta-evolution for automated discovery,” arXiv preprint arXiv:2602.23413, Feb. 2026. [Online]. Available: https://arxiv.org/abs/2602.23413 [14] T. Chenet al., “AVO: Agentic variation operators for autonomous evolutionary search,”arXiv preprint arXiv:2603.24517, Mar. 2026. [Online]. Available: https://arxiv.org/abs/2603.24517 [15] F. Weindel and R. Heckel, “LLM-guided search for deletion-correcting codes,”Trans. Mach. Learn. Res., Jun. 2026. [Online]. Available: https://openreview.net/forum?id=qZ69Ozpo6v [16] G. Zheng, F. Liu, and Q. Zhang, “LLM-enabled automated algorithm design for multiuser fluid antenna communications,”IEEE Trans. Wireless Commun., May 2026, to appear. [Online]. Available: https://arxiv.org/abs/2605.14661 [17] T. Aghayevet al., “GENESIS: Harnessing AI agents for autonomous 6G RAN synthesis, research, and testing,”arXiv preprint arXiv:2605.27360, May 2026. [Online]. Available: https://arxiv.org/abs/2605.27360 [18] F. Aït Aoudia, J. Hoydis, S. Cammerer, L. Maggi, G. Marti, and A. Keller, “The AI Telco Engineer,” https://github.com/nvlabs/the-ai-telco-engineer, 2026. [19] LangChain, Inc., “LangChain,” https://github.com/langchain-ai/langchain, 2022, version 1.3.11. [20] S. K. Mohammed, R. Hadani, A. Chockalingam, and R. Calderbank, “OTFS—a mathematical foundation for communication and radar sensing in the delay-Doppler domain,”IEEE BITS Inf. Theory Mag., vol. 2, no. 2, p. 36–55, Nov. 2022. [21] F. Aït Aoudia and J. Hoydis, “End-to-end learning for OFDM: From neural receivers to pilotless communication,”IEEE Trans. Wireless Commun., vol. 21, no. 2, p. 1049–1063, Feb. 2022. [22] S. Yaoet al., “ReAct: Synergizing reasoning and acting in language models,” inInt. Conf. Learn. Representations (ICLR), Kigali, Rwanda, May 2023. [Online]. Available: https://arxiv.org/abs/2210.03629 [23] T. Akiba, S. Sano, T. Yanase, T. Ohta, and M. Koyama, “Optuna: A next-generation hyperparameter optimization framework,” inProc. 25th ACM SIGKDD Int. Conf. Knowl. Discovery Data Mining (KDD), Anchorage, AK, USA, Aug. 2019, p. 2623–2631. [24] J. Hoydiset al., “Sionna,” https://nvlabs.github.io/sionna/, 2022, ver- sion 2.0.1. [25] J. Anselet al., “PyTorch 2: Faster machine learning through dynamic Python bytecode transformation and graph compilation,” inACM Int. Conf. Architectural Support Program. Lang. OperatingSyst. (ASPLOS), La Jolla, CA, USA, May 2024, p. 929–947. [Online]. Available: https://doi.org/10.1145/3620665.3640366 [26] J. Johnson, M. Douze, and H. Jégou, “Billion-scale similarity search with GPUs,”IEEE Trans. Big Data, vol. 7, no. 3, p. 535–547, Jul. 2021. [27] T. Gruber, S. Cammerer, J. Hoydis, and S. ten Brink, “On deep learning-based channel decoding,” inProc. 51st Annu. Conf. Inf. Sci. Syst. (CISS), Baltimore, MD, USA, May 2017, p. 1–6. [28] P. Raviteja, K. T. Phan, Y. Hong, and E. Viterbo, “Interference cancellation and iterative detection for orthogonal time frequency space modulation,”IEEE Trans. Wireless Commun., vol. 17, no. 10, p. 6501–6515, Oct. 2018. [29] Z. Yuan, F. Liu, W. Yuan, Q. Guo, Z. Wang, and J. Yuan, “Iterative detection for orthogonal time frequency space modulation with uni- tary approximate message passing,”IEEE Trans. Wireless Commun., vol. 21, no. 2, p. 714–725, Feb. 2022. [30] H. Li, Y. Dong, C. Gong, Z. Zhang, X. Wang, and X. Dai, “Lowcom- plexity receiver via expectation propagation for OTFS modulation,” IEEE Commun. Lett., vol. 25, no. 10, p. 3180–3184, Oct. 2021. [31] S. Tiwari, S. S. Das, and V. Rangamgari, “Low complexityLMMSE receiver for OTFS,”IEEE Commun. Lett., vol. 23, no. 12, p. 2205– 2209, Dec. 2019. [32] G. D. Surabhi and A. Chockalingam, “Low-complexity linear equal- ization for OTFS modulation,”IEEE Commun. Lett., vol. 24, no. 2, p. 330–334, Feb. 2020. [33] S. Rangan, P. Schniter, and A. K. Fletcher, “Vector approximate message passing,”IEEE Trans. Inf. Theory, vol. 65, no. 10, p. 6664– 6684, Oct. 2019. [34] J. Ma and L. Ping, “Orthogonal AMP,”IEEE Access, vol. 5, p. 2020– 2033, Jan. 2017. [35] M. Opper and O. Winther, “Expectation consistent approximate inference,”J. Mach. Learn. Res., vol. 6, no. 73, p. 2177–2204, Dec. 2005. [Online]. Available: https://jmlr.org/papers/v6/opper05a.html [36] P. L. Combettes and J.-C. Pesquet, “Proximal splittingmethods in signal processing,” inFixed-Point Algorithms for Inverse Problems in Science and Engineering. New York, NY, USA: Springer, 2011, p. 185–212. [37] S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein, “Distributed optimization and statistical learning via the alternatingdirection 17 F. Aït Aoudia et al.:Autonomous Discovery of Wireless Communications Algorithms method of multipliers,”Found. Trends Mach. Learn., vol. 3, no. 1, p. 1–122, 2011. [38] B. Hassibi and H. Vikalo, “On the sphere-decoding algorithm I. Expected complexity,”IEEE Trans. Signal Process., vol. 53, no. 8, p. 2806–2818, Aug. 2005. [39] K. W. Wong, C. Y. Tsui, R. S. K. Cheng, and W. H. Mow, “A VLSI architecture of a K-best lattice decoding algorithm for MIMO channels,” inProc. IEEE Int. Symp. Circuits Syst. (ISCAS), Scottsdale, AZ, USA, May 2002, p. I-273–I-276. [40] S. Rangan, “Generalized approximate message passing for estimation with random linear mixing,” inProc. IEEE Int. Symp. Inf. Theory (ISIT), St. Petersburg, Russia, Aug. 2011, p. 2168–2172. [41] D. L. Donoho, A. Maleki, and A. Montanari, “Message-passing algorithms for compressed sensing,”Proc. Nat. Acad. Sci., vol. 106, no. 45, p. 18 914–18 919, Nov. 2009. [42] Y. Saad,Iterative Methods for Sparse Linear Systems, 2nd ed. Philadelphia, PA, USA: SIAM, 2003. [43] R. A. Jacobs, M. I. Jordan, S. J. Nowlan, and G. E. Hinton,“Adaptive mixtures of local experts,”Neural Comput., vol. 3, no. 1, p. 79–87, Mar. 1991. [44] G. H. Golub and C. F. Van Loan,Matrix Computations, 4th ed. Baltimore, MD, USA: Johns Hopkins Univ. Press, 2013. [45] M.-X. Chang and J.-H. Chen, “Efficient blind detection for OFDM systems in selective fading channels,”IEEE Trans. Veh. Technol., vol. 64, no. 5, p. 1779–1792, May 2015. [46] T. Y. Al-Naffouri, A. A. Dahman, M. S. Sohail, W. Xu, and B. Hassibi, “Low-complexity blind equalization for OFDM systems with general constellations,”IEEE Trans. Signal Process., vol. 60, no. 12, p. 6395– 6407, Dec. 2012. [47] S. A. Banani and R. G. Vaughan, “OFDM with iterative blind channel estimation,”IEEE Trans. Veh. Technol., vol. 59, no. 9, p. 4298–4308, Nov. 2010. [48] L. Bariah, A. Al-Dweik, and S. Muhaidat, “Blind channelestimation technique for OFDM systems over time varying channels,” inProc. IEEE 87th Veh. Technol. Conf. (VTC Spring), Porto, Portugal, Jul. 2018, p. 1–7. [49] A. Saci, A. Al-Dweik, A. Shami, and Y. Iraqi, “One-shot blind channel estimation for OFDM systems over frequency-selective fading channels,”IEEE Trans. Commun., vol. 65, no. 12, p. 5445–5458, Dec. 2017. [50] E. Björnson, M. Dohler, J. Hoydis, and R. W. Heath, Jr., “Automating wireless research and development: What remains human?”Preprints, Apr. 2026. [Online]. Available: https://doi.org/10.20944/preprints202604.1172.v1 18