DCT

1:25-cv-11517

Natsoft Corp v. Hexaware Tech Ltd

Log In

I. Executive Summary and Procedural Information

  • Parties & Counsel:
  • Case Identification: 1:25-cv-11517, N.D. Ill., 09/23/2025
  • Venue Allegations: Plaintiffs allege venue is proper because Defendants maintain a regular and established place of business in the district and have committed acts of patent infringement there.
  • Core Dispute: Plaintiff alleges that Defendant’s software modernization platforms (RapidX, Amaze, and Tensai/ATOP) infringe nine patents related to automated application code testing, generation, and modernization.
  • Technical Context: The technology concerns automated systems for modernizing legacy software (e.g., COBOL) by extracting business logic, generating new code, and iteratively testing the results, a significant market for industries reliant on older mainframe systems.
  • Key Procedural History: The complaint alleges that Plaintiffs provided pre-suit notice of infringement of all patents-in-suit to Defendants on February 24, 2025, and later provided exemplary claim charts for two of the patents on May 30, 2025. This correspondence is cited as the basis for willful infringement allegations.

Case Timeline

Date Event
2011-08-30 Earliest Priority Date (’106, ’928, ’948, ’673, ’916, ’046, ’243 Patents)
2014-01-28 U.S. Patent No. 8,640,106 Issued
2015-03-03 U.S. Patent No. 8,972,928 Issued
2015-03-03 U.S. Patent No. 8,972,948 Issued
2015-06-23 U.S. Patent No. 9,063,673 Issued
2017-10-03 U.S. Patent No. 9,778,916 Issued
2017-12-15 Earliest Priority Date (’934, ’941 Patents)
2018-01-02 U.S. Patent No. 9,858,046 Issued
2020-05-26 U.S. Patent No. 10,664,243 Issued
2021-06-08 U.S. Patent No. 11,029,934 Issued
2024-03-01 Date of Defendant's marketing document referencing Accused Products
2024-07-09 U.S. Patent No. 12,032,941 Issued
2025-02-24 Plaintiffs provide pre-suit notice of infringement to Defendants
2025-03-01 Date of Defendant's marketing document referencing Accused Products
2025-05-30 Plaintiffs provide exemplary claim charts to Defendants
2025-07-10 Defendants respond to Plaintiffs' claim charts
2025-09-23 Complaint Filed

II. Technology and Patent(s)-in-Suit Analysis

U.S. Patent No. 8,640,106 - System and Method for Testing Application Code (Issued Jan. 28, 2014)

The Invention Explained

  • Problem Addressed: The patent addresses the challenge of testing software, particularly in the context of automated code generation, where testing is a crucial but often costly and complex part of the development cycle (Compl. ¶52).
  • The Patented Solution: The invention provides a method for a computing entity to automatically test application code as it is being converted from input requirements. The system receives application requirements, tests the resulting code in phases, generates test cases, stimulates the code with those test cases, compares the observed behavior to the prescribed behavior, and generates feedback based on the comparison (’106 Patent, Abstract). This creates a feedback loop for an automated code conversion process (’106 Patent, col. 5:61-6:14).
  • Technical Importance: This approach aims to automate a significant portion of the software modernization and development lifecycle, reducing the manual effort and cost associated with validating complex legacy systems (’106 Patent, col. 1:49-53).

Key Claims at a Glance

  • The complaint asserts infringement of at least independent claim 1 (Compl. ¶167).
  • Claim 1 Elements:
    • A method for a computing entity to test and provide feedback of an automated process for converting input requirements into application code.
    • Receiving application requirements, wherein a requirements unit generates and verifies the requirements.
    • For each of a plurality of phases of code conversion:
    • Receiving a plurality of implementation results for a current phase.
    • Testing the implementation results, which includes:
      • Generating at least one test case based on the application requirements.
      • Stimulating the current implementation result with the test case to produce a response.
      • Comparing the observed behavior of the response with prescribed behavior.
      • Generating feedback based on the comparison.

U.S. Patent No. 8,972,928 - System and Method for Generating Application Code (Issued Mar. 3, 2015)

The Invention Explained

  • Problem Addressed: The patent identifies the inefficiency and potential for error in conventional software development, which involves largely separate manual steps for requirements, architecture, design, and coding (’928 Patent, col. 2:3-6).
  • The Patented Solution: The invention describes a method for iteratively generating application code. A computing entity generates initial application requirements from inputs, then iteratively generates application code based on those requirements, parameters, and feedback. The generated code is then iteratively tested to produce further feedback, which is used in subsequent generation cycles until the final code is produced (’928 Patent, Abstract; col. 6:21-42). This integrates generation and testing into a single, iterative loop.
  • Technical Importance: This iterative, feedback-driven process is designed to fully automate the software development cycle, moving from high-level requirements to final code with integrated validation at each step (’928 Patent, col. 8:10-24).

Key Claims at a Glance

  • The complaint asserts infringement of at least independent claim 10 (Compl. ¶179).
  • Claim 10 Elements:
    • A method for execution by a computing entity.
    • Generating, by the computing entity, application requirements from inputted requirements and parameters.
    • Iteratively generating, by the computing entity, application code based on the application requirements, parameters, and feedback until final application code is generated.
    • Iteratively testing, by the computing entity, the application code based on the application requirements and the parameters to produce the feedback.

Multi-Patent Capsule: U.S. Patent No. 10,664,243

  • Patent Identification: U.S. Patent No. 10,664,243, "System and Method for Iterative Generating and Testing of Application Code," Issued May 26, 2020.
  • Technology Synopsis: This patent describes an automated, multi-phase method for generating application code. The process moves through distinct design phases (architecture, high-level, low-level, and code development), generating specific "artifacts" at each stage based on inputs from the prior stage and various requirement documents (’243 Patent, col. 19:6-54). Testing is integrated into this phased, iterative loop to provide feedback (’243 Patent, Abstract).
  • Asserted Claims: At least independent claim 1 (Compl. ¶239).
  • Accused Features: The complaint alleges that Defendants' Accused Products perform iterative code generation and testing across different design phases, mirroring the claimed method (Compl. ¶¶106, 109-111, 113, 120-121).

Multi-Patent Capsule: U.S. Patent No. 11,029,934

  • Patent Identification: U.S. Patent No. 11,029,934, "Method and System for Updating Legacy Software," Issued June 8, 2021.
  • Technology Synopsis: This patent focuses on analyzing existing legacy code to modernize it. The method involves analyzing operational code to identify different programming languages, grouping identifiers based on relational aspects to determine potential features, and testing those features to produce feedback on their meaningfulness before reprogramming the code into a desired language (’934 Patent, Abstract).
  • Asserted Claims: At least independent claim 1 (Compl. ¶251).
  • Accused Features: The complaint alleges Defendants' RapidX product performs "deep code analysis, using reverse engineering to decode undocumented legacy systems" and "extracting business rules, dependencies, and workflows," which aligns with the patent's focus on analyzing and understanding legacy code to enable modernization (Compl. ¶¶110, 113).

The complaint also asserts U.S. Patent Nos. 8972948; 9063673; 9778916; 9858046; and 12032941, which relate to generating application requirements, implementing code from requirements, and updating legacy software through iterative processes (Compl. ¶¶189-236, 261-263).

III. The Accused Instrumentality

Product Identification

  • Defendants' "RapidX," "Amaze," and "Tensai"/ATOP "platforms" (collectively, the "Accused Products") (Compl. ¶1).

Functionality and Market Context

  • The Accused Products are described as a suite of tools for "legacy modernization" that use Generative AI ("GenAI") to automate the process (Compl. ¶¶89-91).
  • RapidX is alleged to use GenAI to analyze legacy applications by decoding source code, mapping dependencies, and extracting business logic. It is also alleged to perform "automated code refactoring" and use "QA Agents" to "[g]enerate test cases, automate regression testing, and validate functionality" (Compl. ¶¶106, 110, 111, 113). The complaint includes a screenshot from a Hexaware document describing RapidX as using "generative AI to analyze legacy applications by decoding source code and mapping complex system dependencies" (Compl. p. 20).
  • Amaze is described as an "automated code conversion tool" that automates code conversion and data migration tasks and performs "validation and optimization" (Compl. ¶¶90, 126-128). A screenshot from a Hexaware blog post describes "Automating SAS to PySpark Code Conversion with Amaze®" and notes the solution includes "Automated Code Conversion" and "Quality Assurance" (Compl. p. 32).
  • Tensai/ATOP is described as an "Autonomous Test Orchestration Platform" that automatically generates test cases based on user acceptance criteria (Compl. ¶¶146, 149).
  • The complaint alleges these products are marketed together as "Hexaware's Flagship Platforms for Legacy Modernization" and are used in concert to provide modernization services (Compl. ¶¶88, 94). A screenshot from Hexaware's website shows these three products marketed together under this banner (Compl. p. 21).

IV. Analysis of Infringement Allegations

8,640,106 Patent Infringement Allegations

Claim Element (from Independent Claim 1) Alleged Infringing Functionality Complaint Citation Patent Citation
performing a method for a computing entity to test and provide feedback of an automated process for converting input requirements into application code The Accused Products collectively provide a platform for testing and providing feedback during the automated modernization of legacy code from client requirements (Compl. ¶¶109, 120, 135, 143). ¶167 col. 5:61-64
receiving application requirements, wherein a requirements unit generates the application requirements from the input requirements and verifies the application requirements RapidX allegedly "reverse-engineers legacy applications, extracting business rules, dependencies, and workflows to create actionable, business-friendly blueprints," which function as the application requirements (Compl. ¶113). ¶167 col. 6:21-26
for each of the plurality of phases, receiving a plurality of implementation results corresponding to a current phase The Accused Products are alleged to operate in phases (e.g., solution design, implementation planning, code analysis, code generation) and produce intermediate results at each stage (Compl. ¶¶109, 110, 114). ¶167 col. 8:58-61
generating...at least one test case based on one or more of the application requirements RapidX is alleged to have "QA Agents" that "[g]enerate test cases, automate regression testing, and validate functionality for reliability" (Compl. ¶111). Tensai/ATOP is alleged to "generate[] test cases automatically" (Compl. ¶149). ¶167 col. 14:40-45
stimulating the current implementation result based on the at least one test case to produce a current application system response The testing functionality of the Accused Products, such as automated regression testing by RapidX's QA Agents, necessarily involves stimulating the generated code with test cases to observe its behavior (Compl. ¶111). ¶167 col. 14:1-3
comparing observed behavior...with prescribed behavior...and generating the feedback based on the comparing RapidX's "QA Agents" are alleged to "validate functionality for reliability," which requires comparing observed and expected outcomes to generate feedback (Compl. ¶111). Amaze is alleged to perform "validation and optimization," implying a comparison and feedback loop (Compl. ¶127). ¶167 col. 14:4-14
  • Identified Points of Contention:
    • Scope Questions: What constitutes a "requirements unit" as claimed? A key question may be whether the process of "reverse-engineering" legacy code to extract business rules, as allegedly performed by RapidX, constitutes "generating" and "verifying" "application requirements" from "input requirements" in the manner claimed by the patent.
    • Technical Questions: Does the complaint provide sufficient evidence that the separate Accused Products (RapidX, Amaze, Tensai) operate together in a multi-phase process as required by the claim, or do they function as standalone tools? The infringement theory appears to rely on the products being used "collectively" (Compl. ¶167).

8,972,928 Patent Infringement Allegations

Claim Element (from Independent Claim 10) Alleged Infringing Functionality Complaint Citation Patent Citation
generating, by the computing entity, application requirements from inputted requirements and parameters RapidX allegedly generates "actionable, business-friendly blueprints" by reverse-engineering legacy applications, and its "Product Agents" create a "prioritized roadmap with estimations, themes, epics, and stories" (Compl. ¶¶111, 113, 119). ¶179 col. 7:63-67
iteratively generating, by the computing entity, application code based on the application requirements, the parameters, and feedback until final application code is generated The complaint alleges the Accused Products perform "iterative generation of computer code based on feedback from testing the code" (Compl. ¶121). Amaze is alleged to perform iterative code generation based on testing results (Compl. ¶135). ¶179 col. 8:1-5
iteratively testing, by the computing entity, the application code based on the application requirements and the parameters to produce the feedback The complaint alleges that RapidX, Amaze, and Tensai/ATOP provide for automated testing of generated code to produce feedback (Compl. ¶¶109, 120, 128, 135, 143, 149). This feedback is then allegedly used in further code generation iterations (Compl. ¶¶121, 151, 152). ¶179 col. 8:6-9
  • Identified Points of Contention:
    • Scope Questions: Does the term "iteratively generating... until final application code is generated" read on a process that uses GenAI for code conversion? A central dispute may be whether the "proprietary automation" and "GenAI" processes described in Defendant's marketing materials (Compl. ¶¶90-91) perform the specific, feedback-driven iterative loop required by the claim, or if they perform a more direct, one-shot translation.
    • Technical Questions: What specific "feedback" is generated by the testing process and how does it inform subsequent code generation iterations? The complaint alleges this feedback loop exists (Compl. ¶¶121, 135) but provides limited technical detail on the mechanism of the feedback itself.

V. Key Claim Terms for Construction

For the ’106 Patent:

  • The Term: "level of abstraction"
  • Context and Importance: The claim requires converting test cases into a "level of abstraction corresponding to the current phase" of code generation. The definition of this term will be critical to determining if the testing allegedly performed by the Accused Products (e.g., by RapidX's "QA Agents") meets this limitation. Practitioners may focus on this term because the nature of testing changes significantly between architecture, design, and code phases, and the patent links the test case abstraction to these phases.
  • Intrinsic Evidence for Interpretation:
    • Evidence for a Broader Interpretation: The specification states that the iterative process may go through "several phases, which may be arbitrarily ordered," including an "architecture level design phase, a high level design (HLD) phase, a low level design (LLD) phase, and an application code level phase" (’106 Patent, col. 7:59-64). This could support a broad definition covering various types of development artifacts.
    • Evidence for a Narrower Interpretation: The specification provides specific examples, such as converting test cases into tests "suitable to exercise a high-level design model" versus tests "suitable to exercise the application code" (’106 Patent, col. 14:60-66). This could support a narrower definition tied to specific types of design models or artifacts.

For the ’928 Patent:

  • The Term: "iteratively generating... application code based on... feedback"
  • Context and Importance: This term is the core of the claimed invention. The infringement case depends on whether the alleged use of "GenAI" and "proprietary automation" by the Accused Products constitutes the specific feedback-driven iterative process of the claim. Practitioners may focus on this term because the patent was filed before the widespread commercial use of large language models for code generation, raising the question of whether this new technology operates in the manner envisioned and claimed by the patent.
  • Intrinsic Evidence for Interpretation:
    • Evidence for a Broader Interpretation: The specification describes the process broadly, stating that when feedback indicates the code is not functioning as expected, the implementation unit "reverts the iterative process to a previous step that received favorable testing unit feedback, selects one or more new implementation tools, and continues generating the developing application code" (’928 Patent, col. 8:10-16). This suggests any process that uses testing results to modify a generative step could be covered.
    • Evidence for a Narrower Interpretation: The patent's flowcharts and detailed descriptions often depict a structured, multi-step reversion process (e.g., ’928 Patent, FIG. 14, steps 134-136). This could support a narrower interpretation requiring a specific type of corrective loop, potentially distinct from how a GenAI model might refine output based on new prompts or error signals.

VI. Other Allegations

  • Indirect Infringement: The complaint alleges inducement based on Defendants' marketing, which allegedly encourages and instructs customers and users on how to use the Accused Products in an infringing manner to modernize legacy code (Compl. ¶¶170, 182). The complaint states that any direct infringement by others occurs with Defendants' "specific intent and encouragement" (Compl. ¶168).
  • Willful Infringement: Willfulness is alleged based on Defendants' purported knowledge of the patents-in-suit as of Plaintiffs' notice letter dated February 24, 2025 (Compl. ¶¶153, 169, 181). The complaint alleges that despite this notice and subsequent correspondence, Defendants continued their infringing activities and denied infringement without providing supporting evidence (Compl. ¶¶154-155).

VII. Analyst’s Conclusion: Key Questions for the Case

  • A central issue will be one of technological scope: can the claims, which describe structured, iterative loops for code generation and testing based on discrete feedback, be construed to cover the functioning of modern Generative AI platforms as allegedly used in the Accused Products? The dispute may turn on whether a GenAI's process for refining code qualifies as the specific "iterative" and "feedback"-driven method disclosed in the patents.
  • A key evidentiary question will be one of system integration: does Plaintiff's infringement theory, which relies on the "collective" use of the RapidX, Amaze, and Tensai platforms, reflect how these products actually operate? The case may require detailed evidence showing that these distinct products function together as a single, integrated system to perform all steps of the asserted method claims.
  • A third core issue will be claim construction: how will the court define foundational terms like "generating application requirements from inputted requirements" and "level of abstraction"? The outcome may depend on whether Defendant's alleged act of "reverse-engineering" legacy code to create "blueprints" is equivalent to the claimed method of generating requirements, and whether its automated testing operates at the specific "levels of abstraction" required.