💻 computer science

GenAutoML: An Agentic Framework for Dynamic Architecture Generation and Optimization in Time-Series Analysis

GenAutoML is an agentic framework that leverages Large Language Models to dynamically generate and optimize task-specific, ultra-lightweight neural architectures for time-series analysis, featuring a sandboxed reflection loop for code refinement and a Dynamic Reversible Instance Normalization wrapper to ensure robustness and efficiency in resource-constrained Edge AI deployments.

Original authors: Oleeviya Babu Poikarayil, Cédric Schockaert, Abdulrahman Nahhas, Christian Daase, Mursal Dawodi, Jawid Ahmad Baktash

Published 2026-06-05

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Oleeviya Babu Poikarayil, Cédric Schockaert, Abdulrahman Nahhas, Christian Daase, Mursal Dawodi, Jawid Ahmad Baktash

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a custom machine to predict the weather or spot a broken machine part. Traditionally, you'd need a team of expert engineers to manually design the machine's blueprints, tweak its gears, and test it over and over. If the machine breaks, you have to start from scratch.

GenAutoML is like hiring a brilliant, tireless AI Architect who doesn't just tweak existing blueprints but can invent entirely new machine designs on the fly, just by listening to your description of the problem.

Here is how this system works, broken down into simple concepts:

1. The "Architect" (The Brain)

Instead of a human drawing the plans, a Large Language Model (LLM) acts as the architect. You tell it in plain English, "I need a lightweight model to track power grid fluctuations," and it writes the actual computer code (PyTorch) to build that machine.

The Analogy: Think of it like asking a master chef to invent a new recipe just by saying, "I need a spicy, low-calorie soup." The chef doesn't just pick from a menu; they create a brand-new dish from scratch.

2. The "Safety Sandbox" (The Test Kitchen)

AI sometimes makes mistakes, like writing code that doesn't fit together (e.g., trying to pour a gallon of soup into a teacup). To prevent this, GenAutoML uses a Sandboxed Reflection Loop.

The Analogy: Before the chef serves the soup to a customer, they taste-test it in a private kitchen. If the soup is too salty or the pot is the wrong size, the system catches the error, tells the chef, "Hey, this doesn't fit," and the chef instantly rewrites the recipe. This happens automatically and repeatedly until the code is perfect, ensuring no broken machines ever reach the real world.

3. The "Universal Adapter" (The Stabilizer)

Time-series data (like temperature or stock prices) is often "non-stationary," meaning its patterns change unpredictably over time. This confuses most AI models. GenAutoML wraps the AI's new design in a special layer called Dynamic Reversible Instance Normalization (Dyn-RevIN).

The Analogy: Imagine the AI architect is building a house on shifting sand. The Dyn-RevIN is like a floating foundation that keeps the house stable no matter how the ground moves. It ensures the math stays steady even when the data is chaotic, preventing the model from crashing.

4. The "Hot-Swap" Engine (The Instant Upgrade)

Usually, if you want to change a machine's design, you have to shut it down, rebuild it, and restart. GenAutoML uses a Just-In-Time (JIT) system.

The Analogy: This is like a Formula 1 pit crew changing a car's engine while the car is still moving at 200 mph. The system can swap in a brand-new AI design instantly without stopping the training process, allowing it to test and improve designs in real-time.

5. The Result: Tiny, Fast, and Reliable

The paper tested this system on real-world data (like electricity transformer temperatures and weather patterns).

Speed vs. Size: Big, famous AI models (Foundation Models) are like giant cruise ships: they are powerful but slow and expensive to run. GenAutoML builds speedboats: they are tiny, incredibly fast (predicting in less than 0.01 milliseconds), and can run on small, low-power devices (Edge AI).
Creativity: The system didn't just copy existing designs. In one test, it invented a completely new architecture called WaveInterferenceNet based on physics concepts, proving it can be truly creative, not just a copycat.
Stability: While other models might fail if you restart the computer or change a random setting, the models built by GenAutoML are deterministic. They behave exactly the same way every time, which is crucial for safety-critical jobs like monitoring power grids.

Summary

GenAutoML is a framework that turns a chatbot into a self-correcting, instant-building AI engineer. It listens to your needs, designs a custom neural network, tests it in a safe sandbox, stabilizes it against chaotic data, and deploys it instantly. The result is a super-fast, tiny, and reliable AI model that can run on small devices, solving complex time-series problems without needing a massive supercomputer.

Technical Summary: GenAutoML

Problem Statement

Designing neural architectures for multivariate time-series forecasting and anomaly detection in industrial environments (e.g., power grid monitoring, IoT) is hindered by two primary challenges: the Stationarity Problem and the limitations of current Automated Machine Learning (AutoML) systems.

The Stationarity Paradox: Real-world datasets (such as ETTh1, ETTm1, and Weather benchmarks) exhibit non-stationary characteristics and complex temporal interdependencies. Traditional deep learning models (LSTMs, Transformers) often struggle with these distributions, while manual architecture design relies on static inductive biases that may be inadequate.
Limitations of Existing AutoML/NAS: Current Neural Architecture Search (NAS) frameworks rely on predefined, static search spaces. They lack "Semantic Creativity," meaning they cannot invent novel structural components (e.g., custom temporal mixing layers) beyond fixed interconnection patterns. Furthermore, the "design-to-deployment" gap is significant; integrating a new model often requires a complete system restart.
Edge AI Constraints: While Time-Series Foundation Models (TSFMs) like Chronos offer high accuracy, their massive parameter counts (100M+) and high inference latency make them unsuitable for resource-constrained, real-time Edge AI deployments.

Methodology: GenAutoML Framework

GenAutoML is an agentic framework that shifts the paradigm from "model search" to "Agentic Neural Engineering." It utilizes Large Language Models (LLMs) as autonomous "Neural Architects" to translate natural language requirements into executable PyTorch code. The framework operates through a closed-loop architecture comprising four core components:

1. Agentic Neural Synthesis (The Semantic Interface)

The core engine uses an LLM (specifically Llama 3-70B) to interpret natural language constraints and generate neural module definitions.

Structural Geometric Contract: The agent is constrained to generate modules that accept a 3D input tensor ( $B \times L \times D$ ) and return a prediction tensor ( $B \times H \times D$ ), ensuring compatibility with downstream pipelines.
Dynamic Registry: Generated code is written directly to a dynamic registry, allowing the system to "invent" complex structures (e.g., multi-scale Inception blocks) based on user descriptions.

2. Sandboxed Reflection Loop

To mitigate code hallucinations and dimension mismatches common in zero-shot LLM generation:

The generated architecture is isolated in a safe execution sandbox.
The agent instantiates the model and performs a simulated forward pass using dummy tensors.
If the output shape mismatches the expected horizon or errors occur (e.g., traceback logs), the system feeds these errors back to the LLM as an additional prompt.
This multi-turn feedback loop allows the agent to iteratively debug tensor reshapes and channel permutations until a structurally sound model is produced.

3. Just-In-Time (JIT) Architectural Integration

GenAutoML employs a Reflection-based Orchestration pipeline to integrate new models into a live optimization environment without system restarts:

Hot-Swapping: Using Python's importlib.reload, the system updates the module cache in real-time.
Signature-Aware Invocation: The system uses runtime introspection (inspect.signature) to match runtime tensors to the generated module's arguments.
Shape-Agnostic Projection: If the LLM generates a model with arbitrary hidden channel counts, a projection layer ( $\hat{Y} = W_{proj} \cdot M_{gen}(\hat{X}) + b_{proj}$ ) mathematically bridges the latent features to the required target dimensions, preventing catastrophic failures.

4. Statistical Hardening via Dynamic RevIN

To address non-stationarity and gradient explosion in volatile industrial data:

The framework wraps LLM-generated logic within a Dynamic Reversible Instance Normalization (Dyn-RevIN) layer.
This layer decouples the untrusted architectural logic from statistical stationarity constraints. It normalizes input data to a stationary distribution before the model processes it and denormalizes the output to the original signal domain.
This acts as a "safety guardrail," ensuring convergence even if the generated architecture is poorly scaled.

Key Contributions

Agentic Neural Synthesis with Sandboxed Reflection: A novel interface translating semantic needs into executable PyTorch code, validated through an autonomous debugging loop that ensures mathematical validity before deployment.
Runtime Architectural Injection: A pipeline enabling "Hot-Swaps" of generated neural modules into active Optuna-based optimization loops, eliminating the need for system reboots and allowing real-time validation.
Mathematical Hardening (Dyn-RevIN): The integration of a Dynamic Reversible Instance Normalization framework that enforces stationarity on the input-output manifold, stabilizing training for non-stationary signals.
End-to-End Conversational Pipeline: A workflow allowing users to upload datasets, perform exploratory data analysis via a Pandas DataFrame agent, and request custom architecture designs, all validated in a federated sandbox.

Experimental Results

The framework was evaluated on three multivariate benchmarks: ETTh1, ETTm1, and Weather.

Forecasting Performance: Agent-synthesized models (e.g., ResNet, Inception) achieved competitive performance against state-of-the-art (SOTA) Transformers like TimesNet and CrossFormer. On the ETTm1 dataset, a synthesized ResNet (MAE = 0.532) closely matched leading linear models.
Anomaly Detection: Synthesized models demonstrated superior sensitivity. The agent-designed ResNetBlock achieved a discrimination gap (Anomalous MSE / Clean MSE) of ~~265x on ETTh1, significantly outperforming TimesNet (~~33x) and DLinear (~8x).
Inference Latency & Efficiency:
- While massive foundation models (e.g., Chronos-T5-Mini) achieve high accuracy, they suffer from high latency (~988 ms/sample).
- The agent-generated WaveInterferenceNet achieved an inference latency of <0.01 ms per sample, representing a ~100,000x speedup over foundation models.
- The search cost was minimal: WaveInterferenceNet required only ~2 minutes of GPU tuning time (5 Optuna trials) compared to significantly longer times for traditional baselines.
Stability and Reproducibility:
- Zero-Variance Convergence: Unlike standard baselines (e.g., DLinear) which showed extreme sensitivity to random seeds (MAE fluctuation $\sigma = 0.760$ ), the agent-synthesized WaveInterferenceNet maintained zero variance ( $\sigma = 0.000$ ) across independent trials when seed determinism was enforced.
- Ablation Studies: The study confirmed that Dyn-RevIN is critical for volatile datasets (improving MAE by ~94% on ETTh1) but can sometimes mask periodic signals in stable datasets (Weather), validating the need for an automated, agent-driven search to determine optimal configurations.

Significance and Claims

The paper positions GenAutoML not merely as a tool for maximizing raw predictive accuracy, but as a framework for deterministic, edge-deployable synthesis.

Paradigm Shift: It moves the field from "massive model search" to "Agentic Neural Engineering," prioritizing ultra-lightweight architectures (under 1M parameters) that trade marginal fractions of accuracy for microsecond inference latencies and highly stable deployment characteristics.
Safety-Critical Suitability: By prioritizing highly deterministic, zero-variance convergence over raw accuracy, the framework yields architectures uniquely suited for safety-critical, resource-constrained Edge AI deployments (e.g., embedded industrial sensors).
Semantic Creativity: The framework demonstrates the ability to synthesize genuinely novel topologies (e.g., WaveInterferenceNet using trigonometric projections) based on abstract natural language directives, moving beyond the repetition of standard motifs like ResNets or LSTMs.

The authors conclude that while the framework relies on LLM API response times (a current limitation), it successfully bridges the gap between the creative potential of generative AI and the rigorous stability requirements of industrial time-series analysis.