DCT

1:25-cv-01731

S3G Technology LLC v. Talbots LLC

Log In
Key Events
Amended Complaint

I. Executive Summary and Procedural Information

  • Parties & Counsel:
  • Case Identification: 1:25-cv-01731, W.D. Tex., 11/18/2025
  • Venue Allegations: Plaintiff alleges venue is proper because Defendant maintains a regular and established place of business in the Western District of Texas and has committed acts of infringement within the district.
  • Core Dispute: Plaintiff alleges that Defendant’s mobile e-commerce applications and associated backend server systems infringe four patents related to the efficient modification of software on remote devices.
  • Technical Context: The technology concerns methods for updating the functionality of software applications on distributed devices, such as smartphones, without requiring the reinstallation of the entire application, a key consideration for managing software across large user bases.
  • Key Procedural History: The complaint notes that terms from the asserted patent family were previously construed in litigation involving the plaintiff (S3G Tech. LLC v. Unikey Techs., Inc.). The complaint also references a history of licensing the patent portfolio to third parties and cites prosecution history where a U.S. Patent Examiner found claimed limitations to be novel and non-obvious over the prior art.

Case Timeline

Date Event
2009-07-23 Earliest Priority Date for Asserted Patents
2016-04-05 U.S. Patent No. 9,304,758 Issues
2018-04-10 U.S. Patent No. 9,940,124 Issues
2019-08-20 U.S. Patent No. 10,387,140 Issues
2023-05-30 U.S. Patent No. 11,662,995 Issues
2024-10-25 Accused Android Application Last Updated
2024-10-28 Accused iOS Application Last Updated
2025-11-18 Complaint Filing Date

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

U.S. Patent No. 9,940,124 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"

  • Patent Identification: U.S. Patent No. 9,940,124, titled "Modification of Terminal and Service Provider Machines Using an Update Server Machine", issued on April 10, 2018 (the "’124 Patent").

The Invention Explained

  • Problem Addressed: The patent addresses the difficulty and inefficiency of distributing large, fully recompiled software application updates to a multitude of geographically dispersed devices, particularly over wireless networks with limited bandwidth and slow transfer rates (Compl. ¶¶ 15-16; ’124 Patent, col. 2:29-56).
  • The Patented Solution: The invention proposes a three-entity architecture: a terminal machine (e.g., a smartphone), a service provider machine (e.g., a backend server), and an update server machine. Instead of sending a full application update, the update server sends a small "dialogue module" to the terminal machine. This module modifies a specific part of the application defined as "code"—information that must be translated before execution (e.g., bytecode or interpreted data)—without altering the core "computer-executable instructions" that run directly on the processor. This allows for lightweight updates to application features and user interface flows (Compl. ¶¶ 17-18; ’124 Patent, col. 4:30-40). The complaint includes a figure from the patent showing this three-entity system architecture (Compl. ¶ 17, FIG. 1).
  • Technical Importance: This method aims to reduce network bandwidth consumption and update time, thereby improving the efficiency of modifying applications deployed across a large network of remote devices (Compl. ¶ 26; ’124 Patent, col. 6:61-63).

Key Claims at a Glance

  • The complaint asserts at least independent claim 1 (Compl. ¶ 34).
  • Claim 1 is a method claim comprising the essential elements of:
    • Displaying a first prompt via a terminal application comprising "first computer-executable instructions" and "first code."
    • Accepting a first data entry at the terminal machine.
    • Communicating information from the terminal machine to a service provider machine running a provider application that comprises "second computer-executable instructions" and "second code."
    • Storing at least a portion of the information in memory for analysis.
    • Receiving, at the terminal machine, a "terminal dialogue module" that updates a portion of the "first code" to produce "first updated code."
    • The "first updated code" adapts the terminal application to display a second prompt for a modified dialogue sequence.
    • At least one of the "first code," "second code," or "first updated code" comprises "intermediate code."
  • The complaint does not explicitly reserve the right to assert dependent claims for this patent.

U.S. Patent No. 10,387,140 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"

  • Patent Identification: U.S. Patent No. 10,387,140, titled "Modification of Terminal and Service Provider Machines Using an Update Server Machine", issued on August 20, 2019 (the "’140 Patent").

The Invention Explained

  • Problem Addressed: Similar to the ’124 Patent, the invention addresses the challenges of efficiently updating software on numerous remote devices over bandwidth-constrained networks (’140 Patent, col. 2:35-67).
  • The Patented Solution: The ’140 Patent describes the same fundamental three-machine architecture for modifying remote software. The solution involves sending a small package of "code" (referred to as "third code" in claim 1) from an update server to a terminal machine to modify a portion of the terminal application's existing code, thereby altering its behavior without requiring a full application replacement (’140 Patent, Fig. 1; col. 4:31-38).
  • Technical Importance: The solution provides a method for efficient, lightweight software modification that conserves network resources and improves the speed of deploying updates to distributed systems (Compl. ¶¶ 24, 26; ’140 Patent, col. 6:58-63).

Key Claims at a Glance

  • The complaint asserts at least independent claim 1 (Compl. ¶ 53).
  • Claim 1 is a method claim with elements similar to claim 1 of the ’124 Patent, but adds several specific conditions, including:
    • Providing a first prompt via a terminal application with "first computer-executable instructions" and "first code."
    • Receiving a first data entry.
    • Communicating information to a provider application with "second computer-executable instructions" and "second code."
    • Receiving, at the terminal machine, "third code" that modifies the "first code" to produce "first updated code," adapting the application for a modified dialogue.
    • The receipt of the "third code" is performed in response to the terminal machine satisfying a "trigger condition."
    • The "third code" is received from an "update server machine" that is "separate and distinct" from the terminal and service provider machines.
    • The terminal and service provider machines include "different types of processors."
  • The complaint does not explicitly reserve the right to assert dependent claims for this patent.

U.S. Patent No. 9,304,758 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"

  • Patent Identification: U.S. Patent No. 9,304,758, titled "Modification of Terminal and Service Provider Machines Using an Update Server Machine", issued on April 5, 2016 (the "’758 Patent").
  • Technology Synopsis: The patent describes a method to solve the problem of distributing large software updates by enabling targeted modifications. It claims a method where a terminal machine receives a "terminal dialogue module" that replaces a portion of an application's "first code" (such as Java Byte code) to produce "first updated code," which adapts the application to display new prompts or functionality without replacing the underlying executable instructions (Compl. ¶¶ 14-17, 82).
  • Asserted Claims: At least Claim 1 (Compl. ¶ 77).
  • Accused Features: The complaint alleges that when the Talbots app receives data (e.g., JSON) from the Defendant's server to update the Wish List, this data functions as the claimed "terminal dialogue module." This module is alleged to replace a portion of the app's bytecode ("first code") to display a new prompt or updated interface (Compl. ¶ 82).

U.S. Patent No. 11,662,995 - "Network Efficient Location-Based Dialogue Sequence Using Virtual Processor"

  • Patent Identification: U.S. Patent No. 11,662,995, titled "Network Efficient Location-Based Dialogue Sequence Using Virtual Processor", issued on May 30, 2023 (the "’995 Patent").
  • Technology Synopsis: This patent addresses a system for conducting a dialogue sequence between at least two different user devices, facilitated by one or more provider applications. The provider application receives "second code" from a first user device which supplements its "first code," adapting the application to manage the dialogue between the first and second user devices (Compl. ¶¶ 96, 99).
  • Asserted Claims: At least Claim 1 (Compl. ¶ 95).
  • Accused Features: The complaint accuses the system where a user interacts with the Talbots website ("first user device") and the Talbots app ("second user device"). It alleges that when a user saves a Wish List item on the website, the corresponding data sent to the Defendant's server is the "second code" that updates the server application to facilitate the synchronized dialogue with the mobile app (Compl. ¶¶ 97-99).

III. The Accused Instrumentality

Product Identification

  • The accused instrumentalities are "The Talbots" mobile applications for Android and iOS (the "Defendant app") and the associated backend systems, including servers, software, and computing devices that support the apps (Compl. ¶ 8).

Functionality and Market Context

  • The Defendant app provides an e-commerce platform for customers to browse, save items to a "Wish List," and purchase products. The complaint's infringement theory centers on the Wish List functionality. When a user adds an item to their Wish List, the app communicates with Defendant's servers. In response, the servers allegedly transmit data back to the app (e.g., in JSON format), which the complaint characterizes as a "dialogue module" that updates the app's state and user interface, such as by displaying the new item and enabling further interactions (Compl. ¶¶ 36, 38, 40).
  • The complaint alleges that Defendant derives a significant portion of its revenue from the promotion and sale of products through these mobile applications (Compl. ¶ 8).

IV. Analysis of Infringement Allegations

U.S. Patent No. 9,940,124 Infringement Allegations

Claim Element (from Independent Claim 1) Alleged Infringing Functionality Complaint Citation Patent Citation
a method comprising: displaying a first prompt on a terminal display of a terminal machine...by running a terminal application comprising first computer-executable instructions and first code that conduct the terminal machine's portion of the dialogue The Talbots app ("terminal application") running on a user's smartphone ("terminal machine") displays a Wish List. The Android Runtime (ART) is alleged to be the "first computer-executable instructions," and the app's bytecode is alleged to be the "first code" (Compl. ¶ 36). ¶36 col. 7:56-61
accepting a first data entry at the terminal machine, wherein the first data entry is associated with the first prompt The user interacts with the app to save a new item to their Wish List (Compl. ¶ 37). ¶37 col. 12:7-9
communicating information associated with the first data entry from the terminal machine to the service provider machine...the service provider machine...uses a provider application comprising second computer-executable instructions and second code The app sends the new Wish List item data to Defendant's server ("service provider machine"). The server runs a .Net application ("provider application"), where the Common Language Runtime (CLR) is the "second computer-executable instructions" and the .Net program is the "second code" (Compl. ¶ 38). ¶38 col. 7:62-67
storing at least a portion of the information associated with the first data entry in memory for analysis Defendant's server stores the Wish List item information so it can be analyzed and later displayed to the user (Compl. ¶ 39). ¶39 col. 12:35-39
receiving, at the terminal machine, a terminal dialogue module that updates at least a portion of the first code to produce first updated code, wherein the first updated code adapts the terminal application to display a second prompt for the terminal machine's portion of a modified dialogue sequence The app receives data (e.g., JSON) from the server, which is alleged to be the "terminal dialogue module." This module allegedly updates the app's bytecode ("first code") to "produce first updated code," which in turn adapts the app to display a new prompt, such as the ability to access the new item (Compl. ¶ 40). ¶40 col. 8:63-9:3
wherein at least one of the first code, the second code, and the first updated code comprise intermediate code The app's bytecode is alleged to be "intermediate code" (Compl. ¶ 40). ¶40 col. 9:50-53

U.S. Patent No. 10,387,140 Infringement Allegations

Claim Element (from Independent Claim 1) Alleged Infringing Functionality Complaint Citation Patent Citation
a method...including...providing a first prompt...by running a terminal application comprising first computer-executable instructions and first code...receiving entry of first data...communicating information...to a provider application...comprising second computer-executable instructions and second code The allegations mirror those for the ’124 Patent: the Talbots app on a smartphone (comprising ART and bytecode) displays a Wish List, accepts user input, and communicates with the backend server (running a .Net application) (Compl. ¶¶ 55-57). ¶¶55-57 col. 7:56-67
receiving, at the terminal machine, third code that modifies at least a portion of the first code to produce first updated code, the first updated code adapting the terminal application to conduct a modified dialog sequence with the service provider machine The app receives data (e.g., JSON) from the server, which is alleged to be the "third code." This code allegedly modifies the app's bytecode ("first code") to produce "first updated code," which adapts the app for a new dialogue, such as accessing the new Wish List item (Compl. ¶ 59). ¶59 col. 9:43-49
wherein receiving the third code is performed in response to the terminal machine satisfying a trigger condition The alleged "trigger condition" is a user action, such as connecting to the network or accessing the Defendant's app (Compl. ¶ 60). ¶60 col. 9:31-34
wherein the third code is received from an update server machine that is separate and distinct from the terminal machine...and the service provider machine The complaint alleges the "third code" is received from an "update server machine (e.g., an Android, iOS or other smart phone or other computing device accessing the Accused System)" (Compl. ¶ 61). ¶61 col. 8:39-43
wherein the terminal machine and the service provider machine include different types of processors, whereby the first computer-executable instructions are not able to be executed on the service provider machine and the second computer-executable instructions are not able to be executed on the terminal machine It is alleged that mobile handsets use ARM-based processors (e.g., Snapdragon) while servers use x86 processors, and their respective executable instructions are not cross-compatible due to differing architectures (e.g., RISC vs. CISC) (Compl. ¶ 62). ¶62 col. 10:48-59
wherein the first and second computer-executable instructions are fully compiled The complaint asserts that because the instructions can be executed directly on their respective processors, one of ordinary skill would understand them to be fully compiled (Compl. ¶ 63). ¶63 col. 10:60-64

Identified Points of Contention

  • Scope Questions: The infringement theory hinges on construing standard data formats (e.g., JSON) as "code" and "dialogue modules," and construing normal data processing as "modifying" or "updating" the application's underlying code. A central question will be whether the term "code", as distinct from "computer-executable instructions", can be read to encompass data payloads, or if it is limited to a more structural form of interpretable instructions like bytecode.
  • Technical Questions: For the ’140 Patent, a critical question arises from the complaint's allegation that the "update server machine" could be another user's smartphone (Compl. ¶ 61). The patent's architecture depicts three distinct entities (terminal, service provider, update server). The complaint's theory may raise the question of whether the accused system actually contains the separate and distinct "update server machine" required by the claim, or if it operates as a two-entity client-server system where the server fulfills both the "service provider" and "update" roles.

V. Key Claim Terms for Construction

  • The Term: "code"

  • Context and Importance: This term's definition is fundamental to the dispute. The patents distinguish "code" from "computer-executable instructions." Plaintiff's case requires a construction broad enough to encompass data structures like JSON, while Defendant may argue for a narrower definition limited to program instructions in an intermediate format like bytecode. Practitioners may focus on this term because the allegation that a JSON data payload constitutes "code" is a primary axis of the infringement dispute.

  • Intrinsic Evidence for Interpretation:

    • Evidence for a Broader Interpretation: The specification defines "code" as "at least some information that must be translated by the software application before it can be implemented on the machine processor" (’140 Patent, col. 4:31-35). This language focuses on the need for translation/interpretation, which could support including data formats that must be parsed and interpreted by the application runtime.
    • Evidence for a Narrower Interpretation: The specification provides "Java Byte Code" as an example of "intermediary code" (’140 Patent, col. 9:51). This could support an argument that "code" is limited to forms of pre-compiled, platform-independent instructions, and does not extend to pure data formats.

  • The Term: "updates [or modifies] at least a portion of the first code to produce first updated code"

  • Context and Importance: This phrase describes the core action of the invention. The dispute will likely center on whether receiving a data payload (JSON) and using it to alter an application's state or display constitutes "updating" or "modifying" the "first code" (allegedly bytecode) itself.

  • Intrinsic Evidence for Interpretation:

    • Evidence for a Broader Interpretation: The specification describes the process as one where a "dialogue module replaces existing terminal code" or "may supplement other code previously saved" (’140 Patent, col. 9:43-49). Plaintiff may argue that overwriting an in-memory data structure (part of the "code") with new data from a JSON payload fits this description.
    • Evidence for a Narrower Interpretation: The claim language distinguishes this step from merely "accepting a first data entry." This suggests "updating code" is a more fundamental change than simply processing new data. A defendant may argue that the application's "first code" (the bytecode) remains unchanged on the device's storage, and the application is merely processing data, not being structurally modified.

VI. Other Allegations

  • Indirect Infringement: The complaint alleges inducement by Defendant marketing and promoting its app to users, knowing that its use would infringe the asserted patents (Compl. ¶¶ 46, 70). It further alleges contributory infringement on the basis that the accused system is not a staple article of commerce and is especially adapted for infringing the patents (Compl. ¶¶ 47, 71).
  • Willful Infringement: Willfulness is alleged based on Defendant's knowledge of the patents "at least since the filing of the original complaint," suggesting a theory of post-suit willful infringement (Compl. ¶¶ 33, 52, 76, 94).

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

  • A core issue will be one of definitional scope: can the term "code", described in the patent as information requiring translation, be construed to cover passive data formats like JSON, and can the routine processing of such data be considered an "update" or "modification" of that "code"? The case may turn on whether the court views this as a novel software modification technique or as standard client-server data exchange.
  • A key architectural question, particularly for patents like the ’140 Patent, will be one of structural mapping: does the Defendant's two-party client-server system, where a server sends data to an app, map onto the distinct three-party "terminal," "service provider," and "update server" architecture required by the claims, or is there a fundamental mismatch?