A system for artificial intelligence (AI)-driven enterprise software modernization

Abstract

A system (100) for artificial intelligence (AI)-driven enterprise software modernization, the system (100) comprising: a. a user device (102) with a user interface (104) configured to receive legacy software artifacts including source code, configuration files, database schemas, interface definitions and runtime logs; b. a communication network (106) configured to enable data communication between the system's components and with external repositories and deployment environments; c. a processing unit (108) that is operationally connected to the user interface (104) of the user device (102) via the communication network (106), wherein the processing unit (108) is configured to execute an AI-driven software modernization workflow, the processing unit (108) comprising: i. a data input module (110) configured to receive legacy software artifacts via the user interface (104) and generate normalized artifact data; ii. a preprocessing module (112) configured to perform at least one of the syntactic analysis, dependency extraction, deobfuscation and metadata enrichment on the normalized artifact data; iii. a semantic intermediate representation generation module (114) configured to create a unified semantic representation that fuses static code semantics with behavioral information derived from runtime logs, the semantic intermediate representation comprising at least control flow structures, data flow relationships, API contracts, security constraints and performance attributes; iv. an artificial intelligence (AI) transformation module (118) configured to generate modernized software components based on the semantic intermediate representation; v. a validation module (120) configured to perform structural, behavioral and interface contract equivalence between the modernized software components obtained from the AI ​​transformation module (118) and the legacy software artifacts received via the data input module (110), and to transmit validation results to the AI ​​transformation module (118) for iterative correction; vi. an output module (122) configured to receive the validated modernized software components from the validation module (120) and to generate executable modernization artifacts, including source code, deployment descriptions and interface specifications, the artifacts being provided to the user device (102) via the communication interface (106).

Description

Field of invention

[0001] Embodiments of the present invention relate to systems and methods for software modernization and specifically to a system for artificial intelligence (AI)-driven enterprise software modernization. Description of the related prior art

[0002] Technology enterprises increasingly rely on complex legacy software systems developed over decades using heterogeneous programming languages, frameworks, and architectural paradigms. Such legacy systems often contain monolithic code structures, undocumented dependencies, outdated libraries, and technology stacks incompatible with modern cloud-native environments. Continued operation of these systems results in high maintenance costs, security vulnerabilities, limited scalability, and reduced integration capabilities with contemporary digital platforms.

[0003] Traditional approaches to software modernization have primarily relied on manual code rewriting, rule-based refactoring tools, or partial migration techniques. These approaches require extensive human expertise, are time-consuming, and often result in functional discrepancies between the original legacy behavior and the modernized implementation. Manual modernization also suffers from inconsistencies in the interpretation of undocumented business logic, leading to a loss of critical expertise embedded in legacy artifacts.

[0004] Recent developments in automated modernization tools have introduced static code analyzers and model-driven engineering techniques that extract structural information from legacy source code. While such tools are capable of generating intermediate models, they are limited in their understanding of runtime behavior, implicit dependencies, and the semantic intent of the original system. Consequently, the modernization outputs produced by these tools often require significant rework and manual correction before deployment.

[0005] Artificial intelligence techniques have been applied to specific tasks such as code translation, error detection, and automated test generation. However, existing AI-supported technologies are based on...

[0006] Solutions typically operate on isolated source files or narrowly defined transformation tasks and do not offer an end-to-end modernization workflow that ensures functional equivalence across heterogeneous artifacts, including configuration files, database schemas, interface definitions, and runtime logs. The lack of a unified semantic representation limits such systems' ability to consider cross-component dependencies and behavioral constraints.

[0007] Furthermore, current solutions lack robust mechanisms to validate that the transformed software retains the structural, behavioral, and interface characteristics of the legacy system. Validation is often limited to syntactic correctness or unit tests, which is insufficient to guarantee enterprise-grade reliability. Without automated equivalence verification and iterative correction, organizations are hesitant to adopt AI-generated modernization outputs for business-critical applications.

[0008] Another limitation of the state of the art lies in the generation of ready-to-use artifacts. Existing tools often produce modernized source code without accompanying environment-specific descriptors, container configurations, or continuous integration pipelines, requiring significant manual engineering effort before the software can be run in target cloud or microservice environments.

[0009] Therefore, there is a need for a system for artificial intelligence (AI)-driven enterprise software modernization that creates a machine-interpretable semantic intermediate representation combining static and behavioral knowledge, performs AI-driven transformation with iterative validation, and generates executable modernization artifacts ready for deployment. The present invention addresses these needs by providing a comprehensive, automated, and reliable approach to enterprise software modernization that reduces human effort, preserves functional intent, and enables migration to modern computing environments. SUMMARY OF THE INVENTION

[0010] Embodiments of the present invention relate to a system for artificial intelligence (AI)-driven enterprise software modernization. The system comprises a user device with a user interface configured to receive legacy system software artifacts, including source code, configuration files, database schemas, interface definitions, and runtime logs. The system also comprises a communication network configured to enable data communication between system components and with external repositories and deployment environments. The system further includes a processing unit operationally connected to the user device's user interface via the communication network, the processing unit being configured to execute an AI-driven software modernization workflow.The processing unit includes a data input module configured to receive legacy software artifacts via the user interface and generate normalized artifact data. The processing unit also includes a preprocessing module configured to perform at least one of the following operations on the normalized artifact data: syntactic analysis, dependency analysis, deobfuscation, and metadata enrichment. The processing unit also includes a module for generating a semantic intermediate representation, configured to create a unified semantic representation that combines static code semantics with behavioral information from runtime logs, where the semantic intermediate representation includes at least control flow structures, data flow relationships, API contracts, security constraints, and performance attributes.The processing unit also includes an AI transformation module configured to generate modernized software components based on the semantic intermediate representation. The processing unit also includes a validation module configured to verify the structural, behavioral, and interface contract equivalence between the modernized software components received by the AI ​​transformation module and the legacy software artifacts received via the data input module, and to pass the validation results to the AI ​​transformation module for iterative correction.The processing unit also includes an output module configured to receive the validated modernized software components from the validation module and generate executable modernization artifacts, including source code, deployment descriptions, and interface specifications, with the artifacts being delivered to the user device via the communication interface.

[0011] In accordance with one embodiment of the present invention, the preprocessing module performs language-independent tokenization and normalization, which enables the modernization of heterogeneous programming languages ​​within a unified pipeline.

[0012] In accordance with one embodiment of the present invention, the semantic intermediate representation created by the module for generating the semantic intermediate representation comprises a graph-based model that includes entity nodes for programs.

[0013] Elements and relationship edges for data dependencies, control flows and interface bindings, thereby enabling technology-agnostic analyses of legacy software artifacts.

[0014] In accordance with an embodiment of the present invention, the module for generating the semantic intermediate representation is configured to embed security policies and compliance restrictions, thereby ensuring that the transformed modernized software components comply with the required security and regulatory rules during the transformation.

[0015] In accordance with an embodiment of the present invention, the processing unit further comprises a traceability module configured to maintain bidirectional mappings between legacy software artifacts, nodes of the semantic intermediate representation and modernized software components, thereby enabling audits and rollbacks of transformation decisions.

[0016] In accordance with an embodiment of the present invention, the AI ​​transformation module comprises a plurality of processing agents configured for different transformation tasks, wherein the agents are coordinated by an orchestration controller configured to determine the execution order based on the dependency information contained in the semantic intermediate representation.

[0017] In accordance with an embodiment of the present invention, the orchestration controller is configured to prevent the execution of a transformation task if the prerequisite dependencies defined in the semantic intermediate representation are not satisfied, thereby avoiding the generation of inconsistent modernization artifacts.

[0018] In accordance with an embodiment of the present invention, the validation module is configured to perform a multidimensional equivalence check, which includes at least structural equivalence, behavior-based equivalence derived from runtime protocols, and interface contract equivalence, thereby ensuring a functionally reliable modernization while preventing semantic discrepancies between the legacy software artifacts and the modernized software components and reducing error propagation in target deployment environments.

[0019] In accordance with an embodiment of the present invention, the validation module is further configured to automatically generate test cases based on the semantic intermediate representation generated by the semantic intermediate representation. 1st generation module and to execute the generated test cases on the modernized software components produced by the AI ​​transformation module.

[0020] In accordance with an embodiment of the present invention, the output module is configured to generate environment-specific deployment artifacts, including container images, microservice descriptions, or continuous integration / continuous deployment scripts, based on the validated modernized software components and the semantic intermediate representation, such that the deployment artifacts maintain structural, behavioral, and interface equivalence with the legacy software artifacts.

[0021] In accordance with an embodiment of the present invention, the processing unit further comprises a feedback learning module configured to collect runtime metrics from provided modernization artifacts and to update the transformation parameters of the Kl transformation module, thereby enabling adaptive correction of the modernized software components based on the observed runtime behavior.

[0022] This document also describes a procedure for an artificial intelligence (AI)-driven enterprise software modernization system. The procedure involves receiving legacy software artifacts, including source code, configuration files, database schemas, interface definitions, and runtime logs, via a user interface on a user device. It also includes transferring the received legacy software artifacts from the user device to a processing unit via a communication network. Furthermore, it includes receiving and generating normalized artifact data from the transferred legacy software artifacts via a data input module of the processing unit. Finally, it includes performing at least one of the following processes on the normalized artifact data: syntactic analysis, dependency analysis, deobfuscation, and metadata enrichment via a preprocessing module of the processing unit.The process also includes the creation of a unified semantic intermediate representation, which fuses static code semantics with behavioral information derived from runtime logs via a semantic intermediate representation generation module of the processing unit. The process also includes the generation of modernized software components based on the semantic intermediate representation via a computer-based transformation module of the processing unit. The process also includes the verification and transfer of structural, behavioral, and interface agreement equivalence between the modernized software components and the legacy software artifacts.

[0023] Validation results for iterative correction are obtained via a validation module of the processing unit. The method also includes receiving the validated modernized software components and generating executable modernization artifacts, including source code, deployment descriptions, and interface specifications, with the artifacts being delivered to the user device via an output module of the processing unit over the communication network. BRIEF DESCRIPTION OF THE DRAWINGS

[0024] In order to understand in detail how the aforementioned features of the present invention are to be understood, a more precise description of the invention, which has been briefly summarized above, may be given by reference to embodiments, some of which are illustrated in the accompanying drawings. It should be noted, however, that the accompanying drawings only illustrate typical embodiments of this invention and therefore should not be considered limiting in scope, since the invention may also allow for other equally effective embodiments.

[0025] The invention described herein will be better understood from the following description with reference to the drawings, in which: Fig. a block diagram of a system 100 for AI-controlled enterprise software modernization according to an embodiment of the present invention is illustrated;

[0026] It should be noted that the accompanying figure is intended to illustrate exemplary embodiments of the present disclosure. This figure is not intended to limit the scope of the present disclosure. It should also be noted that the accompanying figure is not necessarily drawn to scale. DETAILED DESCRIPTION OF THE INVENTION

[0027] The following detailed description sets forth numerous specific details to provide a comprehensive understanding of the embodiments of the invention as illustrative or exemplary embodiments. Specific embodiments in which the invention can be practiced are described in sufficient detail to enable those skilled in the art to practice the disclosed embodiments. However, it will be obvious that the embodiments of the invention can be practiced with or without these specific details.

[0028] Specific details: In other cases, known aspects and components were not described in detail in order to avoid unnecessarily obscuring aspects of the embodiments of the invention.

[0029] The following detailed description is therefore not to be understood as limiting, and the scope of the present invention is defined by the appended claims and their equivalents. The terms "comprising," "including," "having," and similar terms are synonymous and are used inclusively, in an open manner, and do not exclude any additional elements, features, actions, operations, etc. Likewise, the term "or" is used in its inclusive sense (and not in its exclusive sense), so that when it is used, for example, to join a list of elements, it means that "or" means one, some, or all of the elements in the list.

[0030] References within the specification to “an embodiment”, “an embodiment”, “elaborations” or “one or more embodiments” are intended to indicate that a particular feature, structure or property described in connection with the embodiment is included in at least one embodiment of the present invention.

[0031] Although the terms first, second, etc., can be used here to describe different elements, these elements should not be restricted by these terms. These terms are generally used only to distinguish one element from another and do not denote any order, rank, quantity, or importance, but merely serve to differentiate one element from another. Furthermore, the terms "a" and "an" here do not denote a restriction of the set, but rather indicate the presence of at least one of the elements mentioned.

[0032] The conditional language used here, such as “can”, “may”, “could”, “is allowed”, “e.g.” and similar terms, unless expressly stated otherwise or understood differently in context, is generally intended to convey that certain embodiments include certain features, elements and / or steps, while other embodiments do not.

[0033] Disjunctive language, such as the phrase "at least one of X, Y, Z," unless explicitly stated otherwise, is generally understood in context to mean that an element, concept, etc., can be either X, Y, or Z, or any combination thereof (e.g., X, Y, and / or Z). Therefore, such disjunctive language is generally not intended to, and should not, imply that certain embodiments require at least one of X, at least one of Y, or at least one of Z to be present, respectively.

[0034] The following brief definition of terms applies to the entire present invention.

[0035] The terms "determine," "measure," "evaluate," "assess," "analyze," and "analyze" can be used interchangeably here to refer to any form of measurement and include determining whether an element is present or not (e.g., detection). These terms can encompass both quantitative and qualitative determinations. The evaluation can be relative or absolute.

[0036] Fig. Figure 1 illustrates a block diagram of a System 100 for an artificial intelligence (AI) controlled modernization of enterprise software, according to an embodiment of the present invention.

[0037] The system 100 comprises a user device 102 with a user interface 104, a communication network 106 and a processing unit 108.

[0038] The user device 102, with a user interface 104, is configured to receive legacy software artifacts, including source code, configuration files, database schemas, interface definitions, and runtime logs. The user interface 104 is further configured to allow manual uploading of legacy software artifacts, automated retrieval from external repositories, or direct integration with version control systems, thus enabling the acquisition of heterogeneous artifacts from various technological environments without prior external conversion.

[0039] The user interface 104 is additionally configured to present status information related to the modernization workflow, including validation results, transformation progress and generated modernization artifacts, so that an operator is able to monitor and control the execution of the AI-driven modernization process via the user device 102 and selectively initiate, pause or repeat individual processing stages.

[0040] In one embodiment, the user device 102 comprises a smartphone, tablet computer, laptop computer or desktop workstation, wherein the user interface 104 is implemented as a graphical application or web-based interface that runs on the respective device, thereby enabling platform-independent access to the modernization workflow and interaction with the processing unit 108 regardless of the hardware form factor.

[0041] The communication network 106 is configured to enable data communication between system components and with external repositories and deployment environments. Communication network 106 provides bidirectional data exchange between the user device 102, the processing unit 108, and external systems using standardized communication protocols, thereby ensuring secure and technology-independent transmission of legacy software artifacts and generated modernization artifacts.

[0042] The communication network 106 is further configured to support authentication mechanisms and encrypted data channels, ensuring the integrity and confidentiality of the transmitted artifacts during interaction with cloud platforms, code repositories, and target runtime environments.

[0043] The processing unit 108, which is operationally connected to the user interface 104 of the user device 102 via the communication network 106, wherein the processing unit 108 is configured to execute an AI-driven software modernization workflow, so that the processing unit 108 coordinates the data exchange between the modules and ensures the sequential and iterative execution of the modernization stages without manual intervention.

[0044] In one embodiment, the processing unit 108 is implemented as a distributed computing platform consisting of a multitude of processing nodes, thereby enabling the parallel processing of multiple legacy software artifacts and the scalable handling of large codebases while maintaining deterministic interaction between the modules.

[0045] The processing unit 108 has several specialized modules, including a data input module 110, a preprocessing module 112, a module for generating semantic intermediate representations 114, a traceability module 116, an AI transformation module 118, a validation module 120, an output module 122 and a feedback learning module 124.

[0046] The data input module 110 is configured to receive legacy software artifacts via the user interface 104 and generate normalized artifact data. Normalization includes the unification of encoding formats, the removal of technology-specific syntax variations, and the creation of a common metadata structure independent of the source platform.

[0047] In one embodiment, the data input module 110 performs an integrity check of the received legacy software artifacts using check digit analysis and schema validation. to prevent the spread of incomplete or damaged artifacts to subsequent processing stages.

[0048] The preprocessing module 112 is configured to perform at least one of the following operations on the normalized artifact data: syntactic analysis, dependency extraction, deobfuscation, and metadata enrichment. Syntactic analysis involves parsing the normalized artifact data to identify program constructs and interface declarations. Dependency extraction involves identifying relationships between software files, modules, and external components referenced within the legacy software artifacts. Deobfuscation involves transforming obfuscated identifiers or encoded segments into readable representations. Metadata enrichment involves adding contextual attributes to the artifact data, including version information and interface parameters, thereby generating structured information suitable for subsequent processing.Through the operations of syntactic analysis, dependency extraction, deobfuscation and metadata enrichment, the preprocessing module 112 technically enables the conversion of heterogeneous legacy artifacts into a consistent and machine-interpretable form, thereby reducing information losses caused by platform-specific formats and improving the reliability of the semantic intermediate representation.

[0049] In one embodiment of the present disclosure document, the preprocessing module 112 performs language-independent tokenization and normalization, enabling the modernization of heterogeneous programming languages ​​within a unified pipeline, generating common abstract tokens for equivalent constructs of different languages, thereby allowing subsequent modules to operate independently of the original programming language of the legacy software artifacts.

[0050] The module for generating the semantic intermediate representation 114 is configured to create a unified semantic representation that combines static code semantics with behavioral information from runtime logs. This semantic intermediate representation includes at least control flow structures, data flow relationships, API contracts, security constraints, and performance attributes. The fusion of static code semantics with behavioral information enables correlation between the design-time structure and observed runtime behavior, integrating latent execution paths and interface usages not explicitly visible in the source code into the semantic intermediate representation. representation

[0051] This technical approach improves the accuracy of subsequent modernization transformations by providing a holistic, machine-readable model of legacy software artifacts.

[0052] The semantic intermediate representation also provides a common abstraction layer that is independent of the original technology stack, thus enabling uniform processing of artifacts from different programming languages, frameworks, or execution environments.

[0053] In one embodiment of the present disclosure, the semantic intermediate representation generated by module 114 for generating the semantic intermediate representation comprises a graph-based model that includes entity nodes for program elements and relationship edges for data dependencies, control flows, and interface bindings, thereby enabling technology-independent analysis of legacy software artifacts. The graph-based model allows traversal and inference across intercomponent relationships, enabling the identification of critical modules, the effects of propagation paths, and integration boundaries, which technically facilitates the safe decomposition and modernization of monolithic legacy applications.The graph-based semantic intermediate representation also enables incremental updates when new runtime protocols or artifact versions are received, so that only affected nodes and edges are recalculated, thereby reducing computational effort and improving the scalability of the system.

[0054] In one embodiment of the present disclosure, module 114 is configured to generate the semantic intermediate representation by embedding security policies and compliance requirements, thereby ensuring that the transformed, modernized software components comply with the necessary security and regulatory rules during the transformation. The embedding of security policies and compliance requirements at the representation level technically enforces a rule-aware transformation, in which any modernization action that violates predefined constraints is prevented or flagged before code generation, thereby increasing the trustworthiness of the generated modernization artifacts.

[0055] In one embodiment of the present disclosure, the processing unit 108 also includes a traceability module 116 configured to maintain bidirectional mappings between legacy software artifacts, nodes of the semantic intermediate representation and modernized software components, thereby enabling the verification and reversal of the transformation.

[0056] Decisions. The traceability module 116 technically associates each element of the generated modernized software with its original legacy artifact and the corresponding semantic representation node, making transformation operations transparent and verifiable. Such a bidirectional mapping enables the deterministic identification of the source context for each generated component, facilitating impact analysis, regulatory review, and the controlled reversal of individual modernization steps without reprocessing the entire artifact set.

[0057] Maintaining backlinks also enables subsequent changes in the legacy artifacts to be passed on to the corresponding modernized components, thereby supporting incremental modernization and reducing development effort.

[0058] In one embodiment of the present disclosure, the traceability module stores 116 transformation metadata, including applied AI models, decision parameters, and validation results, which are linked to each mapping, thus making the modernization process reproducible and explainable across different execution cycles. This configuration offers the technical advantage that errors or inconsistencies detected in the deployed modernized software can be traced back to precise legacy code fragments or runtime behavior, enabling targeted corrections instead of a complete regeneration and thus improving the reliability and maintainability of the AI-driven modernization workflow.

[0059] The Artificial Intelligence (AI) Transformation Module 118 is configured to generate modernized software components based on the semantic intermediate representation. The AI ​​Transformation Module 118 works on the semantic intermediate representation generated by the Semantic Intermediate Representation Generation Module 114 and transforms the technology-independent representation into target-technology-specific modernization artifacts. The AI ​​Transformation Module 118 performs automated refactoring, code synthesis, architectural restructuring, and interface adaptation while preserving the functional behavior and security requirements embedded in the semantic intermediate representation.By using the structured semantic model as input, the Artificial Intelligence Transformation Module 118 achieves deterministic and repeatable modernization results, independent of the original programming language or platform of the legacy software. This enables automated processes.

[0060] Modernization with reduced manual intervention minimizes human error and ensures consistent transformation quality across heterogeneous legacy systems.

[0061] In one embodiment of the present disclosure, the Kl transformation module 118 comprises a plurality of processing agents configured for different transformation tasks, wherein the agents are coordinated by an orchestration controller configured to determine the execution order based on dependency information contained in the semantic intermediate representation. The processing agents include at least one code restructuring agent, one API migration agent, one security policy enforcement agent, and one performance optimization agent. Each processing agent receives task-specific segments of the semantic intermediate representation and produces partial modernization outputs.The orchestration controller analyzes dependency graphs, control flow relationships, and data flow constraints stored in the semantic intermediate representation and dynamically schedules the agents to execute transformation steps in a logically consistent sequence. The multi-agent architecture enables modular and parallel processing of complex modernization tasks, increases system scalability, and allows for the replacement or extension of individual agents without redesigning the overall system.

[0062] In one embodiment of the present disclosure, the orchestration controller is configured to prevent the execution of a transformation task if the prerequisite dependencies defined in the semantic intermediate representation are not satisfied, thereby avoiding the generation of inconsistent modernization artifacts. The orchestration controller performs a pre-execution check of the required entities and relationships within the semantic intermediate representation and postpones or blocks a processing agent if the dependency conditions are not met, optionally triggering the regeneration or correction of the affected portion of the representation. This ensures the structural and behavioral integrity of the generated artifacts, prevents the propagation of transformation errors, and maintains compliance with embedded safety and architectural requirements.

[0063] The validation module 120 is configured to verify the structural, behavioral, and interface contract equivalence between the modernized software components received by the AI ​​transformation module 118 and the legacy system software artifacts received via the data input module 110, and to transmit the validation results to the AI ​​transformation module 118. For iterative correction. The validation module 120 compares control flow structures, data dependencies, external interface definitions, and the running behavior of the modernized software components with corresponding elements of the legacy artifacts and generates conformance metrics and deviation reports that are returned to the AI ​​transformation module 118 to trigger automated correction loops. This enables closed-loop, self-correcting modernization with verifiable functional preservation instead of a one-time code conversion.

[0064] In one embodiment of the present disclosure, the validation module 120 is configured to perform multidimensional equivalence verification, which includes at least structural equivalence, behavior-based equivalence derived from runtime logs, and interface contract equivalence, thereby ensuring a functionally reliable modernization while preventing semantic discrepancies between the legacy software artifacts and the modernized software components and reducing error propagation in target deployment environments.Structural equivalence verification assesses the consistency of program graphs and dependency relationships, behavioral equivalence verification correlates execution traces extracted from runtime logs with execution traces of the modernized components, and interface contract equivalence verification checks the conformity of API signatures, data schemas, and protocol constraints. This provides measurable proof of functional identity across multiple dimensions and increases the reliability of deployment in production environments.

[0065] In one embodiment of the present disclosure, the validation module 120 is further configured to automatically generate test cases based on the semantic intermediate representation generated by the semantic intermediate representation generation module 114 and to execute the generated test cases on the modernized software components generated by the AI ​​transformation module 118. The validation module 120 derives input vectors, boundary conditions, and expected outputs from the semantic intermediate representation and creates executable test scripts that are applied to the modernized software components, reporting any deviations between the expected and actual behavior back to the AI ​​transformation module 118 for corrective transformation.This eliminates manual test design, ensures coverage consistent with legacy semantics, and enables continuous automated assurance during modernization.

[0066] The output module 122 is configured to receive the validated modernized software components from the validation module 120 and generate executable modernization artifacts, including source code, deployment descriptions, and interface specifications. These artifacts are then provided to the user device 102 via the communication interface 106. The output module 122 converts the validated modernized software components into deployment-ready artifacts by synthesizing compilable source files, machine-readable interface definitions, and platform-compatible deployment descriptions. The generation process is governed by constraints contained in the semantic intermediate representation 114.This enables the direct operational use of the modernization result without manual reengineering and ensures a deterministic transformation from the semantic model to deployable artifacts.

[0067] In one embodiment of the present disclosure, the output module 122 is configured to generate environment-specific deployment artifacts, including container images, microservice descriptions, or continuous integration / continuous delivery scripts, based on the validated modernized software components and the intermediate semantic representation 114, such that the deployment artifacts maintain the structural, behavioral, and interface equivalence of the legacy software artifacts. The output module 122 selects target environment parameters, including the runtime platform type, orchestration framework, and resource specifications, and adapts the generated artifacts accordingly by embedding configuration values, service endpoints, and dependency descriptions derived from the intermediate semantic representation 114.This provides technology-adaptive deployment generation that maintains verified equivalence while enabling migration to heterogeneous cloud or on-premise infrastructures.

[0068] In another embodiment, the output module 122 is configured to generate versioned artifact packages containing traceability metadata that links each generated element to the corresponding nodes of the intermediate semantic representation 114 and the original legacy artifacts received via the data input module 110. This facilitates auditable delivery, rollback capability, and regulatory compliance by preserving the end-to-end provenance of the modernization transformations.

[0069] In one embodiment of the present disclosure, the processing unit 108 further comprises a feedback learning module 124, which is configured to collect runtime metrics. provided modernization artifacts and to update the transformation parameters of the Kl transformation module 118, thereby enabling adaptive correction of modernized software components based on the observed runtime behavior.

[0070] The Feedback Learning Module 124 continuously monitors deployed modernization artifacts to collect performance metrics, error logs, usage patterns, and system resource data. The collected metrics are analyzed to identify deviations from expected behavior, bottlenecks, or suboptimal performance, which are then translated into parameter updates for the AI ​​Transformation Module 118. The AI ​​Transformation Module uses these updates to iteratively refine future transformations, improving functional accuracy, performance, and interface contract compliance. This enables self-adaptive modernization that learns from real-world execution, reduces post-deployment defects, ensures continuous optimization of software components, and closes the deployment-transformation loop for improved reliability in heterogeneous environments.

[0071] In one embodiment, the feedback learning module 124 can implement reinforcement learning or machine learning-based optimization techniques to automatically adjust code refactoring strategies, Apl mapping rules, or performance adjustment parameters based on runtime observations.

[0072] In its optimal operating mode, System 100 functions by first acquiring legacy software artifacts, including source code, configuration files, database schemas, interface definitions, and runtime logs. These artifacts are collected via the user device 102 through the user interface 104 by means of manual uploads, automated retrievals from external repositories, or direct version control integration. The user interface 104 also displays the workflow status, validation results, and generated modernization artifacts. These artifacts are then transferred via the communication network 106 to the processing unit 108, which executes a computer-controlled modernization workflow.The data input module 110 normalizes the artifacts, which are then preprocessed by the preprocessing module 112 through syntactic analysis, dependency analysis, deobfuscation, metadata enrichment, and language-independent tokenization to support heterogeneous programming languages. The semantic intermediate representation generator module 114 transforms preprocessed data into a unified semantic representation that combines static code semantics and runtime behavior information, including control flow, data flow, API contracts, security requirements, and performance attributes. In implementations, this representation is graph-based and can embed security policies and compliance rules. The traceability module 116 maintains bidirectional mappings between legacy artifacts, semantic nodes, and modernized ones.

[0073] Components for traceability and rollback capability. The AI ​​transformation module 118, consisting of specialized processing agents coordinated by an orchestration controller, generates modernized software components according to the dependencies in the semantic representation.

[0074] The orchestration controller ensures that tasks are only executed if the required dependencies are met.

[0075] The validation module 120 verifies the structural, behavioral, and interface equivalence between modernized components and legacy artifacts and optionally generates and executes test cases from the semantic representation. The validation results are fed back to the AI ​​transformation module 118 to enable iterative refinement. The output module 122 receives validated components and generates executable modernization artifacts, including source code, deployment descriptions, and interface specifications. In some implementations, environment-specific artifacts such as container images, microservice descriptions, or CI / CD scripts are generated, maintaining equivalence with legacy artifacts and delivered to the user device 102 via the communication network 106.The feedback learning module 124 collects runtime metrics from deployed artifacts and updates the AI ​​transformation module 118, enabling adaptive corrections and continuous improvements to modernization workflows. Thus, the system provides a fully integrated, end-to-end flow from the acquisition of legacy software to validated, deployable modernized artifacts, while ensuring traceability, security enforcement, compliance, and adaptive learning.

[0076] In the absence of a conflict, the embodiments in the present disclosure and the features in the embodiments may be combined with one another. The foregoing descriptions are merely specific implementations of the present disclosure and are not intended to limit the scope of protection of the present disclosure. Any variation or substitution that can be readily determined by a person familiar with the prior art within the technical scope disclosed in the present disclosure falls within the scope of protection of the present disclosure. Therefore, the scope of protection of the present disclosure is subject to the scope of protection of the claims.

[0077] The foregoing descriptions of specific embodiments of the present technology have been presented for illustrative and descriptive purposes. They are not intended to be exhaustive or to limit the present technology to the forms exactly disclosed, and obviously many modifications and variations are possible in light of the above teaching.

[0078] The embodiments were selected and described to best explain the principles of the current technology and its practical application, in order to enable other skilled persons to make the best possible use of the current technology and various embodiments with different modifications suitable for the respective intended use.

[0079] It is understood that various omissions and substitutions of equivalents may be considered as circumstances suggest or make expedient, but such are intended to cover the application or implementation without deviating from the spirit or scope of the claims of the present technology.

Claims

[1] A system (100) for artificial intelligence (AI)-driven enterprise software modernization, comprising the system (100): a. a user device (102) with a user interface (104) configured to receive legacy software artifacts including source code, configuration files, database schemas, interface definitions and runtime logs; b. a communication network (106) configured to enable data communication between the system's components and with external repositories and deployment environments; c. a processing unit (108) that is operationally connected to the user interface (104) of the user device (102) via the communication network (106), wherein the processing unit (108) is configured to execute an AI-driven software modernization workflow, the processing unit (108) comprising: i. a data input module (110) configured to receive legacy software artifacts via the user interface (104) and generate normalized artifact data; ii. a preprocessing module (112) configured to perform at least one of the syntactic analysis, dependency extraction, deobfuscation and metadata enrichment on the normalized artifact data; iii. a semantic intermediate representation generation module (114) configured to create a unified semantic representation that fuses static code semantics with behavioral information derived from runtime logs, the semantic intermediate representation comprising at least control flow structures, data flow relationships, API contracts, security constraints and performance attributes; iv. an artificial intelligence (AI) transformation module (118) configured to generate modernized software components based on the semantic intermediate representation; v. a validation module (120) configured to perform structural, behavioral and interface contract equivalence between the modernized software components obtained from the AI ​​transformation module (118) and the legacy software artifacts received via the data input module (110), and to transmit validation results to the AI ​​transformation module (118) for iterative correction; vi. an output module (122) configured to receive the validated modernized software components from the validation module (120) and to generate executable modernization artifacts, including source code, deployment descriptions and interface specifications, the artifacts being provided to the user device (102) via the communication interface (106). [2] The system according to the preceding claim, wherein the preprocessing module (112) performs language-independent tokenization and normalization, enabling the modernization of heterogeneous programming languages ​​within a unified pipeline. [3] The system according to claim 1, wherein the semantic intermediate representation created by the semantic intermediate representation generation module (114) comprises a graph-based model containing entity nodes for program elements and relationship edges for data dependencies, control flows and interface bindings, thereby enabling technology-independent analysis of legacy software artifacts. [4] The system according to claim 1, wherein the module for generating semantic intermediate representations (114) is configured to embed security policies and compliance requirements, thereby ensuring that the transformed modernized software components comply with the required security and regulatory rules during the transformation. [5] The system according to claim 1, wherein the processing unit (108) further comprises a traceability module (116) configured to maintain bidirectional mappings between legacy software artifacts, nodes of the semantic intermediate representation and modernized software components, thereby enabling the review and reversal of transformation decisions. [6] The system according to claim 1, wherein the AI ​​transformation module (118) comprises a plurality of processing units configured for different transformation tasks coordinated by an orchestration controller configured to determine the execution order based on dependency information contained in the semantic intermediate representation. [7] The system according to claim 6, wherein the orchestration controller is configured to prevent the execution of a transformation task if the prerequisite dependencies defined in the semantic intermediate representation are not satisfied, thereby avoiding the generation of inconsistent modernization artifacts. [8] The system according to claim 1, wherein the validation module (120) is configured to perform a multidimensional equivalence check comprising at least structural equivalence, behavior-based equivalence derived from runtime logs, and interface contract equivalence, thereby ensuring functionally reliable modernization while preventing semantic discrepancies between the legacy software artifacts and the modernized software components and reducing error propagation in target deployment environments. [9] The system according to claim 1, wherein the validation module (120) is further configured to automatically generate test cases based on the semantic intermediate representation generated by the module for generating the semantic intermediate representation (114) and to execute the generated test cases on the modernized software components generated by the AI ​​transformation module (118). [10] The system according to claim 1, wherein the output module (122) is configured to generate environment-specific deployment artifacts, including container images, microservice descriptions or continuous integration / continuous deployment scripts, based on the validated modernized software components and the semantic intermediate representation (114), such that the deployment artifacts retain the structural, behavioral and interface equivalence of the legacy software artifacts. [11] The system according to claim 1, wherein the processing unit (108) further comprises a feedback learning module (124) configured to collect runtime metrics from provided modernization artifacts and to update the transformation parameters of the AI ​​transformation module (118), thereby enabling adaptive correction of the modernized software components based on the observed runtime behavior.

Images