A method, system, and computer-readable storage medium for synchronizing the independent life and state of a portable digital entity.

Abstract

With the development of digital technology, various digital entities (such as virtual characters, intelligent agents, digital avatars, and robot task states) need to migrate between different devices and continue operating on the target device. However, existing technologies suffer from drawbacks such as a disconnect between state migration and independent operation, a lack of autonomous experience generation mechanisms, a lack of adaptive evolution capabilities, a single state synchronization strategy, and a disconnect from human social habits. Therefore, a method is needed that can support digital entities to live independently (autonomously generate experiences and self-evolve) after migrating across devices and intelligently synchronize their states upon return. This application provides a method, system, and computer-readable storage medium for the independent living and state synchronization of transferable digital entities, aiming to enable digital entities to live independently on the target device (autonomously generate experiences and adjust their own parameters) and intelligently merge state changes upon returning to the main device, achieving a realistic and coherent "life trajectory."

Description

Technical Field

[0001] This application relates to the fields of artificial intelligence and distributed systems, and more specifically, to a method, system, and computer-readable storage medium for synchronizing the independent life and state of a portable digital entity. Background Technology

[0002] With the rapid development of digital technology, digital entities such as virtual characters, intelligent agents, robots, and digital avatars are increasingly widely used in cross-device migration scenarios. Users expect these entities to maintain a coherent "life trajectory" after migrating between different devices, just like real living beings. For example, a personal virtual character could be migrated from a mobile terminal to a home device to live independently for a period of time, returning with newly generated experiences and growth changes. However, current technology has significant flaws: the digital entity migration process only achieves a static state transfer. After migration, the entity cannot operate autonomously on the target device without preset instructions, resulting in a lack of "independent living" capabilities. Specifically, after an entity is migrated to a new device, the existing system can only passively respond to external interactions, lacking the ability to autonomously generate natural language descriptions of experiences during periods of no operation, such as being unable to simulate everyday scenarios like "interacting with family today." Furthermore, entity parameter adjustments rely entirely on external input, unable to progressively fine-tune parameters such as personality and behavior based on self-generated experiences, causing stagnation in the growth mechanism. In addition, the state synchronization mechanism uses a simple overwrite or full replacement strategy, failing to intelligently handle incremental changes in data generated during migration, leading to memory gaps and data chaos. More importantly, existing technologies have failed to construct a dynamic "leaving home-returning home" model that aligns with human social habits. The migration process of digital entities merely reflects task continuity and cannot form a real life trajectory with temporal continuity, severely limiting the immersiveness and credibility of emotional companionship applications. These shortcomings keep digital entities at the instrumental level, making it difficult to achieve anthropomorphic existences with autonomous consciousness and evolutionary capabilities.

[0003] To address the aforementioned issues, existing technologies urgently need improvement. Summary of the Invention

[0004] The purpose of this application is to provide a method, system, and computer-readable storage medium for synchronizing the independent life and state of a portable digital entity. This method enables the independent operation and state synchronization of the portable digital entity, and solves the problem in the prior art that digital entities cannot autonomously generate experiences, adjust parameters, and intelligently synchronize state changes after migration, thereby improving the anthropomorphism of the digital entity and the user experience.

[0005] This application provides a method for synchronizing the independent life and state of portable digital entities, the technical solution of which is as follows: Includes the following steps: On the first device, the state data of the transferable digital entity is packaged and encrypted to generate a state unit; The status unit is sent to the second device via a secure channel; The second device receives and decrypts the status unit, restoring the operating environment of the migrated digital entity; The transferable digital entity can operate independently on the second device. Independent operation includes autonomously generating experiences and / or adjusting its own parameters based on those experiences. When the transferable digital entity returns to the first device, the second device will send back the state changes that occurred during its independent operation to the first device; The first device receives state changes and merges them into the master state library of locally stored portable digital entities.

[0006] Furthermore, this application also proposes that the state data of a transferable digital entity includes, but is not limited to, at least one of the entity's historical interaction data, attribute parameters, and configuration information.

[0007] Furthermore, this application also proposes that transferable digital entities include, but are not limited to, virtual characters, intelligent agents, digital clones, robot task states, or vehicle system driving configurations.

[0008] Furthermore, this application also proposes that the autonomously generated experience includes invoking a content generation model to generate descriptive information based on the attributes of the transferable digital entity and its environment.

[0009] Furthermore, this application also proposes that, based on experience, one can adjust one's own parameters, including but not limited to fine-tuning the personality parameters, behavioral parameters, or state parameters of a transferable digital entity, and that the adjustment range meets predetermined limits.

[0010] Furthermore, this application also proposes that independent operation includes, but is not limited to, real-time interaction with a second device user.

[0011] Furthermore, this application also proposes that state changes include, but are not limited to, at least one of the following: interaction records, autonomously generated experiences, parameter adjustments, or relationship changes.

[0012] Furthermore, this application also proposes to include: automatically deleting the state unit and state change data on the second device after the transferable digital entity is returned to the first device.

[0013] Furthermore, this application also proposes supporting the independent living of portable digital entities across multiple devices, with all state changes ultimately aggregated to the first device.

[0014] Furthermore, this application also proposes an independent life and state synchronization system for portable digital entities, comprising: The first device is configured to package and encrypt the state data of the transferable digital entity to generate a state unit, send it to the second device through a secure channel, and receive the state changes returned from the second device and merge and update the local storage. The second device is configured to receive and decrypt the state unit, restore the operating environment of the transferable digital entity, enable the transferable digital entity to run independently on the second device, the independent operation includes autonomously generating experience and / or adjusting its own parameters based on the experience, and recording state changes; and send the state changes back to the first device when the transferable digital entity returns.

[0015] Furthermore, this application also proposes that the second device includes an independent running engine, which is configured to call a content generation model to generate experiences and adjust parameters based on those experiences.

[0016] Furthermore, this application also proposes a cleanup module configured to automatically delete state units and state change data on the second device after the migrated digital entity is returned.

[0017] Furthermore, this application also proposes a computer-readable storage medium having a computer program stored thereon, which executes the above-described method when executed by a processor.

[0018] As can be seen from the above, the present application provides a method, system, and computer-readable storage medium for synchronizing the independent life and state of a portable digital entity. By packaging and encrypting state data on a first device and sending it to a second device, the second device restores the operating environment, enabling the entity to operate independently. This includes autonomously generating experiences and adjusting parameters, and synchronizing state changes upon return. This solves the technical problem and achieves independent operation and state synchronization of portable digital entities. It also solves the problem in the prior art that digital entities cannot autonomously generate experiences, adjust parameters, and intelligently synchronize state changes after migration, thereby improving the anthropomorphism of digital entities and the user experience.

[0019] Comparative analysis with existing technologies Regarding the objects of migration: existing technologies mostly involve static tasks and complete system states. However, the solution in this application can proactively generate digital entities of new experiences.

[0020] Regarding the operation of the target device: existing technologies often passively execute preset instructions; while the solution of this application can achieve independent living, autonomously generate experiences, and self-adjust parameters.

[0021] Regarding the sources of state changes: existing technologies mostly rely on external input or preset logic; while the solution in this application can achieve active generation (automatic generation of experience) + interaction.

[0022] Regarding synchronization: existing technologies often employ full coverage or simple merging; while the solution proposed in this application can achieve intelligent merging, timestamp sorting, and conflict handling.

[0023] In terms of technical effects: existing technologies mostly extend tasks; while the solution proposed in this application can extend life trajectory, and the entity possesses "life experience".

[0024] As can be seen from the comparison, the core innovation of this application lies in giving digital entities the ability to "live independently"—even without human interaction, they can autonomously generate experiences, evolve on their own, and intelligently merge with the main state after returning, thereby simulating the growth trajectory of a real life form. Attached Figure Description

[0025] Several embodiments of this application are described below with reference to the accompanying drawings. It should be noted that the specific structures, modules, steps, parameters, and connections shown in the drawings are preferred embodiments of this application and not limitations on the scope of protection of this application. Those skilled in the art can make various modifications, substitutions, or combinations to the specific details shown in the drawings based on the teachings of this application, and these modified embodiments should still be considered to fall within the scope of protection of this application.

[0026] Figure 1 This application provides a system architecture diagram, which illustrates an exemplary architecture of the independent life and status synchronization system for portable digital entities. Each module can be adjusted according to actual applications and does not limit the scope of protection.

[0027] Figure 2 This application provides a flowchart of behavior during independent living. This diagram illustrates the behavior of a digital entity living independently on a target device, including two modes: interactive and autonomously generated experiences, as well as a parameter fine-tuning mechanism. This diagram is only an example and does not constitute a limitation on the claims.

[0028] Figure 3 This application provides a flowchart for state merging and synchronization. The flowchart illustrates the intelligent merging process of incremental state changes, including conflict detection and handling mechanisms. The flowchart is merely an example and does not constitute a limitation on the claims. Detailed Implementation

[0029] The technical solutions of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. The components of this application described and shown in the accompanying drawings can generally be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of this application provided in the accompanying drawings is not intended to limit the scope of the claimed application, but merely represents selected embodiments of this application. All other embodiments obtained by those skilled in the art based on the embodiments of this application without inventive effort are within the scope of protection of this application. Other technologies that may be mentioned in the embodiments can be implemented using existing technology or other patent applications filed by the applicant on the same day, and will not be repeated here. It should be particularly noted that the specific module divisions, process steps, data flow directions, status names, time values, etc., shown in the accompanying drawings are merely illustrative examples and should not constitute a limitation on the scope of protection of the claims of this application. The scope of protection of the claims is determined solely by their wording and should be interpreted in accordance with the overall content of the specification.

[0030] It should be noted that similar reference numerals and letters in the following figures indicate similar items; therefore, once an item is defined in one figure, it does not need to be further defined and explained in subsequent figures. Furthermore, in the description of this application, terms such as "first," "second," etc., are used only to distinguish descriptions and should not be construed as indicating or implying relative importance.

[0031] In applications involving the migration of digital entities across devices, existing technologies suffer from the drawback of preventing the migrated entities from living independently. Specifically, the lack of a mechanism for autonomously generating experiences means that digital entities on the target device can only respond to external input and cannot proactively generate new experience descriptions without user interaction. Furthermore, adaptive evolution capabilities are not implemented, preventing entities from fine-tuning their parameters based on their experiences. In addition, state synchronization strategies often employ full coverage or simple merging methods, failing to intelligently handle incremental changes, which can easily lead to timestamp conflicts and data corruption, affecting state consistency and system reliability.

[0032] For example, in family-oriented scenarios, after a virtual character migrates from a personal mobile device to a parent's tablet, it is only configured to process user input commands and is not given the ability to automatically generate descriptive experiences during periods of no interaction, such as at night. Furthermore, personality parameters are not allowed to be fine-tuned based on interaction content, such as increasing extroversion due to praise. When the character returns to the main device, new memories are not intelligently merged with existing memories in chronological order, resulting in memory gaps, and the user cannot perceive the character's true growth trajectory during the migration.

[0033] If the aforementioned problems are not addressed, digital entities will be unable to simulate the growth process of real living beings, their state data will be prone to inconsistencies during migration, and their emotional companionship function will be weakened. Furthermore, data conflicts may lead to system malfunctions, reducing the stability of distributed systems. In the long run, the lack of independent living capabilities will limit the depth of digital entities' application in the field of artificial intelligence and hinder technological development.

[0034] In this regard, the following method is proposed in this application: A method for synchronizing the independent life and state of a portable digital entity, comprising the following steps: On the first device, the state data of the transferable digital entity is packaged and encrypted to generate a state unit; The status unit is sent to the second device via a secure channel; The second device receives and decrypts the status unit, restoring the operating environment of the migrated digital entity; The transferable digital entity can operate independently on the second device. Independent operation includes autonomously generating experiences and / or adjusting its own parameters based on those experiences. When the transferable digital entity returns to the first device, the second device will send back the state changes that occurred during its independent operation to the first device; The first device receives state changes and merges them into the master state library of locally stored portable digital entities.

[0035] For ease of understanding, the following explains some key terms in this embodiment: Portable digital entity: refers to a software entity designed to run in different computing environments. It encapsulates its current state, operational logic, and possible forms of representation or roles.

[0036] First device: refers to the computing device where a digital entity typically resides or is initially managed. This device serves as the "main base" of the digital entity.

[0037] Second device: refers to the target computing device where a digital entity is temporarily relocated for independent operation.

[0038] Status data: refers to data that defines the current state, historical information, and characteristics of a digital entity. This data determines the behavior and identity of the digital entity.

[0039] State unit: refers to a set of digital entity state data that has been packaged and encrypted, specifically prepared for secure transmission between devices.

[0040] Secure channel: refers to the communication link established between devices, which uses encryption and authentication mechanisms to ensure the confidentiality, integrity and authenticity of transmitted data.

[0041] Operating environment: refers to the software and hardware context required on a device to enable a digital entity to execute its logic and perform its functions.

[0042] Independent operation: refers to the ability of a digital entity to operate autonomously on a target device without continuous external human intervention or direct control from the original device.

[0043] Autonomously generated experiences: refers to the ability of a digital entity to create new narrative elements, events, or memories based on its internal logic, attributes, and perceived environment, even without direct user interaction.

[0044] Adjusting one's own parameters: refers to the process by which a digital entity modifies its internal attributes (such as personality traits, behavioral tendencies, or operational settings) based on its experiences or interactions.

[0045] State change: refers to the incremental modification or addition of information to the state data of a digital entity while it is operating independently on a second device.

[0046] Master State Repository: Refers to the authoritative and comprehensive repository of digital entity state data, which is usually maintained on the first device.

[0047] This application provides a method for independent living and state synchronization of portable digital entities, which achieves seamless migration, autonomous operation and state synchronization of digital entities between different devices through a series of steps.

[0048] First, on the first device, the state data of the transferable digital entity is packaged and encrypted, generating a state unit. This step is designed to prepare for the secure and efficient transmission of the digital entity's current state. Specifically, the first device collects necessary data related to the digital entity, such as its basic configuration information or a simple identifier. Subsequently, this collected data is compressed and encrypted using a standard encryption algorithm to form a compact and secure state unit, ready for subsequent transmission.

[0049] Next, the status unit is sent to the second device via a secure channel. This step aims to ensure that the status unit of the digital entity is not accessed or tampered with unauthorizedly during transmission from the first device to the second. The status unit can be transmitted via a network connection, which can be a direct point-to-point link or involve an intermediate server. The transmission protocol can use standard network protocols, with additional security layers provided through VPNs or custom secure communication protocols to establish a reliable and protected data path.

[0050] The second device then receives and decrypts the state unit, restoring the operational environment of the migrated digital entity. This step aims to enable the digital entity to seamlessly resume its operation on the target device, as if it had never left the first device. Upon receiving the encrypted state unit, the second device first verifies its authenticity and then decrypts it using the appropriate key. The decrypted state data is then used to initialize or configure the necessary software components and resources on the second device. This may include loading the core logic of the digital entity, allocating memory, and setting up any required interfaces, thereby creating an operational functional environment for the digital entity.

[0051] Furthermore, the transferable digital entity operates independently on a second device, which includes autonomously generating experiences and / or adjusting its own parameters based on those experiences. This step aims to give the digital entity autonomy on the second device, enabling it to evolve and create new content without continuous external input. Regarding autonomous experience generation, the digital entity can be configured with a set of predefined rules or templates. Based on these rules and in conjunction with potential environmental inputs (e.g., time of day, simulated events), it can construct simple descriptive statements or short narratives. For example, it might generate a log entry such as, "Today, I observed a change in the simulated weather." Regarding parameter adjustment, the digital entity can possess internal parameters such as a "curiosity" score or a "sociality" level. When certain events occur or experiences are generated, a simple lookup table or fixed algorithm can be applied to slightly modify these parameters. For example, if an "observation" experience is generated, its "curiosity" score might increase by a fixed, small amount.

[0052] When the portable digital entity returns to the first device, the second device sends back the state changes that occurred during its independent operation. The purpose of this step is to capture and transmit all modifications and new information generated by the digital entity during its independent operation, returning it to its primary location. Any changes to the internal state of the digital entity during its independent operation, such as newly generated experiences or modified parameters, are recorded locally on the second device. These recorded changes are collected upon receiving a return signal or at the end of a predetermined time period. This collection of changes, which may be a simple list of modified values, is then packaged and sent back to the first device.

[0053] Finally, the first device receives the state change and merges it into the master state repository of the portable digital entity, stored locally. This step aims to integrate the digital entity's new experiences and evolution into its authoritative records, ensuring the continuity and up-to-dateness of its "life trajectory." The first device receives state change packets from the second device. It then processes these changes by comparing them with existing data in the master state repository. A basic merging strategy might involve simply appending new entries to the log in chronological order, or overwriting older parameter values ​​with newer ones. This ensures that the digital entity's master record reflects its recent activities and development.

[0054] The following example will provide a more detailed explanation of the above technical solution: For example, suppose user A owns a portable digital entity called a "digital pet," which typically runs on user A's first device (e.g., a smartphone). User A wants to temporarily "board" the digital pet on user B's second device (e.g., a tablet) so that it can live independently at user B's location for a period of time.

[0055] First, before the digital pet is migrated, User A's primary device performs a process of packaging and encrypting its status data. Specifically, the primary device collects all current status data of the digital pet, which may include its current satiety level, mood value, and basic behavioral pattern configurations. This data is then packaged into a single status unit and encrypted using a preset encryption algorithm to ensure data security during transmission.

[0056] Next, this encrypted state unit is sent to user B's second device through a secure channel. The secure channel can be established using network protocol encryption, such as TLS / SSL, to ensure that the data is not eavesdropped on or tampered with during transmission.

[0057] When user B's second device receives the status unit, it will decrypt it and restore the digital pet's operating environment based on the decrypted status data. This means that the second device will load the digital pet's core program and initialize its internal state based on received parameters such as satiety and mood, enabling it to run normally on the second device.

[0058] Subsequently, the digital pet began operating independently on User B's second device. During this time, the digital pet was able to autonomously generate experiences. For example, even without User B's direct interaction with the digital pet, it might generate an experience record based on its internal logic and simulated time passage, such as "Today I was sunbathing on my tablet and felt warm." Simultaneously, the digital pet would adjust its own parameters based on these experiences. For instance, if it generated the experience of "feeling warm," its mood value might increase slightly. This independent operation allowed the digital pet to exhibit "life" even without direct commands.

[0059] After a period of time, when user A decides to "take back" the digital pet, user B's second device will send all the state changes that the digital pet generated during its independent operation back to user A's first device. These state changes may include newly generated experience records, minor adjustments to mood values, etc.

[0060] Finally, after receiving these state changes, User A's first device merges them into the digital pet's main state database stored locally. The merging process simply appends new experience records to the history in chronological order and updates parameters such as mood values. Thus, the digital pet returns to User A's first device with the new "memories" and "growth" gained from User B, and its "life trajectory" continues seamlessly.

[0061] Based on the examples above, the method proposed in this application demonstrates a significant technological contribution to digital entity management.

[0062] Traditional digital entity migration solutions, such as simple virtual machine migration or task migration, typically focus only on moving an entity from one environment to another and having it passively perform pre-defined tasks. For example, in the digital pet example above, if existing technology is used, the digital pet on user B's second device may only respond to user B's direct commands or run according to a pre-set fixed script, but it cannot autonomously generate experiences like "sunbathing" without user interaction, nor can it fine-tune its mood parameters based on these experiences. This results in the digital entity lacking true "independent living" capabilities on the target device, with a simplistic behavioral pattern that cannot simulate the growth and evolution of real living beings.

[0063] To address this issue, this application effectively solves the aforementioned problems by introducing a mechanism that allows digital entities to operate independently on a second device and includes the ability to autonomously generate experiences and / or adjust their own parameters based on those experiences. In the example above, the digital pet can autonomously generate an experience of "sunbathing" on user B's second device and adjust its mood parameters based on that experience. This empowers the digital entity to proactively create new content even without human interaction and to fine-tune its parameters based on these experiences, simulating the gradual evolutionary process of a real living being. This capability transforms the digital entity from a passive executor into a "living being" capable of actively perceiving, thinking, and evolving, greatly enhancing its sense of "life" and realism.

[0064] Furthermore, this application addresses the problem of a single state synchronization strategy in existing technologies by sending back the state changes generated during independent operation to the first device when the digital entity returns, and merging them into the locally stored master state library. Existing technologies often employ full synchronization or simple overwrite, which can easily lead to data corruption or loss. The solution proposed in this application captures all incremental changes and ensures the coherence and consistency of state updates through an intelligent merging strategy, avoiding data conflicts. This allows all the "growth" and "memories" of the digital entity during its "away" period to be completely and accurately brought back and integrated into its master state, thereby achieving a true and coherent continuation of its "life trajectory."

[0065] In summary, this application significantly enhances the autonomy, realism, and vitality of digital entities by endowing them with the ability to live independently and combining this with an intelligent state synchronization mechanism. This opens up new possibilities for the application of digital entities in multi-device environments and has significant implications for technological advancement.

[0066] When traditionally existing state data of transferable digital entities is packaged and encrypted to generate state units, the specific content is not clearly defined. This may lead to incomplete entity recovery after migration, which cannot effectively support autonomously generated experiences and self-evolution, affecting the authenticity and continuity of independent life.

[0067] In this regard, this application further proposes that the state data of the transferable digital entity includes, but is not limited to, at least one of the entity's historical interaction data, attribute parameters, and configuration information.

[0068] Specifically, the historical interaction data refers to all records generated by a transferable digital entity during its interactions with users, the environment, or other entities, such as dialogue records, operation logs, decision paths, and emotional feedback. This data constitutes the "memory" of the digital entity, directly reflecting its past behavior and experiences. It can be implemented by storing data in a structured database or log file, recording key information such as interaction timestamps, interaction objects, interaction content, and entity responses; or by using vector embedding or knowledge graphs to abstract and compress complex interaction information for efficient storage and retrieval while preserving semantic information. The attribute parameters refer to numerical or categorical variables describing the intrinsic characteristics of a transferable digital entity, such as personality traits, behavioral tendencies, skill levels, and emotional states. These parameters determine the digital entity's reaction patterns and behavioral styles in different contexts. They can be represented by a predefined list of parameters and corresponding numerical ranges, such as using values ​​from 0 to 100 to quantify personality dimensions or using enumeration types to represent skill levels; or by using implicit parameters based on machine learning models, learned through training data and dynamically adjusted at runtime based on input to achieve more complex adaptive behavior. The configuration information refers to the environment settings, initialization conditions, dependencies, or specific rules required for the operation of the portable digital entity. Examples include the runtime environment's language settings, permission list, loaded modules, preset initial states, and interface parameters with external systems. This information ensures that the digital entity can correctly start and run on a new device. It can be implemented by storing settings in configuration file formats such as JSON or XML, containing key-value pairs; or it can be parsed and loaded as part of a binary data block or serialized object when the entity starts, allowing for rapid reconstruction of the runtime environment.

[0069] This application's solution ensures that the state data of a transferable digital entity, including but not limited to at least one of historical interaction data, attribute parameters, or configuration information, is comprehensive and critical when the state data of the transferable digital entity is packaged and encrypted to generate state units on the first device. Specifically, historical interaction data allows the digital entity to carry its past "memories" and "experiences," providing a basis and context for autonomously generating new experiences on the second device. For example, a virtual character can generate new dialogues or events that match its personality and background based on its past conversation records. Attribute parameters provide a basis for the digital entity to adjust itself on the second device based on new experiences. For example, an agent can fine-tune its decision preferences or learning rate based on its successes or failures during independent operation, thereby achieving self-evolution. Configuration information ensures that the digital entity can smoothly restore its operating environment on the second device, ensuring it can start and execute various functions normally, avoiding operational failures caused by environment incompatibility. When these complete state units containing critical information are sent to the second device through a secure channel, the second device can receive and decrypt the state units and restore the operating environment of the transferable digital entity based on this data. During the recovery process, historical interaction data is loaded to reconstruct the entity's memory, attribute parameters are initialized to set the entity's behavioral tendencies, and configuration information is used to configure the various environmental parameters required for operation. It is precisely because of the existence of this crucial data that the transferable digital entity can truly achieve independent operation on the second device, including autonomously generating experiences and / or adjusting its own parameters based on those experiences. For example, without external instructions, the digital entity can utilize its historical interaction data and attribute parameters, combined with current environmental information, to autonomously create new contextual descriptions or dialogue content through a content generation model. Simultaneously, its attribute parameters can be fine-tuned based on these newly generated experiences or interactions with the second device's user, thereby simulating real growth and evolution. When the transferable digital entity completes its independent operation on the second device and returns to the first device, the second device sends back the state changes generated during independent operation (e.g., new interaction records, autonomously generated experiences, parameter adjustments, etc.) to the first device. Upon receiving these state changes, the first device can merge them into the locally stored master state library of the transferable digital entity. Because the status data contains detailed historical interaction data and attribute parameters, this merging is no longer a simple overwrite, but can intelligently integrate incremental changes with the original data. For example, it can add new interaction records by timestamp sorting or update attribute parameters according to the adjustment amount, thereby ensuring that the "life trajectory" of digital entities is coherent and real, avoiding the problems of data chaos and information loss.This mechanism allows digital entities to not only continue operating after being migrated across devices, but also to return to the main device like a living entity, bringing new experiences and growth, greatly enhancing the sense of life of the digital entity and the user experience.

[0070] As a specific implementation method, let's take a virtual pet as an example. When a user wants to migrate their virtual pet from their phone to a smart speaker to live independently, the first device (the phone) collects all the virtual pet's status data. Historical interaction data can include all conversations, playtime, and feeding records between the pet and the user, stored in time-series format, and may include the user's nickname for the pet and the pet's response patterns. Attribute parameters can include the pet's personality values ​​(such as liveliness, intimacy, curiosity, etc.), skill level (such as singing, dancing, etc.), and current emotional state (such as happy, calm, sleepy, etc.). Configuration information can include the version of the speech recognition model the virtual pet relies on, the parameters of the speech synthesis model, and the specific permission settings required for it to run on the smart speaker (such as whether it can play music, whether it can control smart home devices, etc.). This data is packaged and encrypted to form state units, which are then sent to the smart speaker. After receiving and decrypting the data, the smart speaker restores the virtual pet's operating environment based on this data. For example, it loads the pet's personality parameters, making it exhibit corresponding liveliness when interacting with the smart speaker user; it uses historical interaction data to allow the pet to remember commands taught by the user or interesting stories told during conversations; at the same time, configuration information ensures that the pet can correctly use the smart speaker's microphone and speaker for interaction. After the pet has lived independently on the smart speaker for a period of time, its new interaction records with the smart speaker user, personality fine-tuning caused by autonomously generated "play" experiences, and skill level improvements due to learning new commands, etc., will be sent back to the phone when the pet returns, and intelligently merged with the original main state library on the phone, so that the virtual pet can continue to grow on the phone with its "new life" on the smart speaker.

[0071] The above technical solution clarifies that the state data of transferable digital entities should include, but is not limited to, at least one of historical interaction data, attribute parameters, or configuration information. This solves the problem of incomplete entity recovery after migration caused by unclear definition of state data content in traditional solutions. Specifically, historical interaction data ensures that digital entities can carry their complete "memories" and "experiences," providing rich context for autonomously generating new experiences that match their background on the second device, greatly enhancing the realism of independent living. The inclusion of attribute parameters allows digital entities to self-adjust and evolve based on experiences generated on the second device, such as fine-tuning personality or behavioral patterns, thereby overcoming the defects of growth stagnation and giving them a growth trajectory closer to that of a real living organism. Configuration information ensures that digital entities can seamlessly and correctly restore their operating environment on the target device, avoiding operational obstacles caused by environmental incompatibility. Therefore, by providing comprehensive and critical state data, this solution ensures that digital entities can be fully restored after cross-device migration, effectively supporting autonomous experience generation and self-evolution, thereby achieving true independent living and coherent state synchronization, greatly enhancing the lifelikeness of digital entities and user experience.

[0072] In some embodiments of this application, the transferable digital entity may include, but is not limited to, a virtual character, an intelligent agent, a robot, or a digital clone.

[0073] A portable digital entity is a digital construct with persistent state and autonomous behavior, designed to maintain continuity of identity and operation across different computing environments and to be transferable. This entity can manifest as a software agent, a data structure representing a specific concept, or a combination of both. A virtual character is a digital entity existing in the digital world or virtual environment, typically possessing a specific appearance, personality, and behavioral patterns, designed to simulate humans or animals and engage in emotional interaction or provide entertainment experiences. For example, it can be a non-player character (NPC) in a game or a virtual companion in a social application. An intelligent agent is a digital entity capable of perceiving its environment, making decisions, and performing actions, typically possessing some learning and reasoning abilities, designed to complete specific tasks or goals. For example, it can be a conversational agent in an automated customer service system or an AI assistant for complex data analysis. A digital avatar is a digital entity representing a real individual or concept, designed to simulate, extend, or replace its corresponding real-world existence in digital space, typically possessing attributes and behavioral characteristics similar to the real individual. For example, it can be a personalized digital avatar of a user or a virtual representative of a brand in the metaverse. A robot's complete task status can also be considered a transferable digital entity, including: current task progress, a list of completed subtasks, environmental perception data, decision queues, and anomaly records. In intelligent vehicles, a user's personalized driving configurations can also be considered transferable digital entities, including: seat position, rearview mirror angle, steering wheel pressure, music preferences, navigation history, and driving habit data (such as following distance and acceleration curves).

[0074] As a specific implementation, when the transferable digital entity is a virtual character, it can autonomously generate experience descriptions (e.g., "Today I explored the virtual world with new friends") based on a preset personality model and its environment while operating independently on a second device, and fine-tune personality parameters (e.g., increasing the "extroversion" parameter) based on interactive feedback. When the transferable digital entity is an intelligent agent, it can focus on performing specific tasks (e.g., automatically completing user-mandated schedules) while operating independently, and optimize decision-making strategies based on task execution results. When the transferable digital entity is a robot, it can focus on adjusting operating parameters to adapt to environmental changes (e.g., adjusting movement speed based on the ground friction coefficient). When the transferable digital entity is a digital avatar, it can focus on synchronizing behavioral data (e.g., gait, facial expressions) with a real individual and simulating its presentation in digital space.

[0075] The following uses a virtual character as an example to further illustrate the technical solution of this application. A user wishes to migrate their virtual character from a first device to a second device. The virtual character's state data (including historical interaction data, attribute parameters, configuration information, etc.) is packaged, encrypted, and sent to the second device. On the second device, the virtual character can operate independently: it can interact with the user on the second device in real time; when there is no user interaction, it autonomously generates new experiences based on its preset personality and environment, such as "explored the virtual world with new friends today." Simultaneously, the virtual character will fine-tune its personality parameters based on these experiences; for example, if it receives positive feedback during interactions, its "extroversion" parameter may slightly increase. When the virtual character returns to the first device, all state changes generated during its independent operation on the second device (including new interaction records, autonomously generated experiences, and parameter adjustments) are sent back to the first device and intelligently merged into its main state library. In this way, the virtual character can carry its "new life" experiences on the second device and continue to grow and evolve on the first device.

[0076] Those skilled in the art will understand that the specific implementation methods of the aforementioned virtual characters are also applicable to other types of transferable digital entities such as intelligent agents, robot task states, or digital avatars, requiring only adjustments to the behavioral strategies during independent operation based on the characteristics of each type. For example, intelligent agents may focus on task execution and decision optimization, robots may focus on adjusting operating parameters, and digital avatars may focus on behavioral synchronization. These adjustments are all within the scope of protection of this application.

[0077] Through the aforementioned technical solution, this application enables the processes of packaging state data of transferable digital entities, generating experiences and adjusting parameters during independent operation, as well as synchronizing state changes, to be optimized and customized according to the specific attributes and functional requirements of the entity. This not only enhances the versatility and applicability of the method, allowing it to be seamlessly applied to diverse scenarios such as virtual characters, intelligent agents, robots, or digital avatars, but also ensures the realism and effectiveness of the digital entity "living independently" on a second device, thereby enabling the digital entity to have a more coherent and personalized "life trajectory."

[0078] In some of the solutions described above in this application, autonomously generated experiences are proposed to enable digital entities to live independently. However, in this process, there is a lack of specific mechanisms to ensure that the generated experiences are based on the entity's attributes and its environment, which may result in experiences that are not authentic or relevant. To address this, this application further proposes that autonomously generated experiences include invoking a content generation model to generate descriptive information based on the attributes and environment of the transferable digital entity.

[0079] Autonomously generated experiences refer to the process by which transferable digital entities, without human intervention or external instructions, actively create, construct, and record the events, situations, or interactions they experience based on their internal logic and external environment. This is a core element in enabling digital entities to live independently and possess growth and evolutionary trajectories similar to real-life organisms. Content generation models are artificial intelligence models designed to automatically generate content in the form of text, images, and audio based on given input or context. In this approach, the model's role is to output logically consistent and contextually appropriate descriptive text based on specific conditions of the digital entity, thereby concretizing the events experienced by the digital entity. This model can employ a large-scale language model based on the Transformer architecture, capable of understanding complex contexts and generating high-quality, coherent text descriptions; or it can be a lightweight, domain-specific generative model, such as a text generator based on recurrent neural networks or generative adversarial networks, which can work effectively even in resource-constrained environments. Generating descriptive information based on the attributes and environment of the transferable digital entity means that when generating the experience of the digital entity, the inherent characteristics (attributes) of the digital entity and its current external conditions (environment) are used as key inputs to ensure the personalization, relevance, and authenticity of the generated content. This ensures that the generated experience matches the "identity" and "context" of the digital entity, avoiding the generation of generic descriptions that do not conform to the entity's characteristics or the current scenario. The attributes of the digital entity may include its personality parameters, historical interaction data, skill tree, preference settings, etc.; the environment may include the current device type, time, whether there is online user interaction, surrounding virtual or physical objects, etc. After receiving this attribute and environmental information, the content generation model uses it as constraints or context for generating text, thereby outputting customized descriptions.

[0080] When a transferable digital entity runs independently on a second device, its mechanism for autonomously generating experiences is implemented by invoking a content generation model. This model does not randomly generate content; instead, it takes the transferable digital entity's attributes (e.g., its personality, historical interaction data, preferences, etc.) and its specific environment (e.g., current device type, presence of user interaction, time period, etc.) as key inputs. Based on these inputs, the model performs intelligent analysis and reasoning to generate descriptive information highly relevant to the digital entity's characteristics and current context. This approach ensures that the generated experiences are not only fluent and readable, but more importantly, they closely align with the digital entity's "identity" and "life" trajectory, avoiding generic or unrealistic descriptions. Through this mechanism, the digital entity can continuously accumulate personalized "life experiences" during independent operation, making its independent life on the second device more realistic and immersive, thus effectively solving the problem of traditional digital entities lacking the ability to autonomously generate authentic and relevant experiences after migration.

[0081] As a specific implementation method, let's take a virtual character as an example. When a virtual character runs independently on a second device, the process of its autonomously generated experiences can be implemented as follows: The independent running engine in the second device periodically (e.g., every morning or under specific triggering conditions) calls a pre-deployed content generation model. During the call, the engine provides the content generation model with the virtual character's current attributes (e.g., its personality parameters, recent interaction records, preference settings, etc.) and its environmental information (e.g., whether the user on the second device is online, device type, virtual scene settings, etc.) as input. For example, if the virtual character is set to "lively and cheerful," and it interacts with the user on the second device by "playing games together," while the environmental information shows "it is afternoon, and the weather is sunny," the content generation model will integrate this information to generate a descriptive message, such as: "This afternoon, I played a fun puzzle game with my little owner. I won several rounds and felt very happy!" or "Today, I took a walk alone in the virtual garden and saw a blooming rose, which made me feel particularly cheerful." This descriptive message is then recorded as the virtual character's new experience and may be used for subsequent parameter adjustments.

[0082] Through the aforementioned technical solution, transferable digital entities, during independent operation, can intelligently generate personalized and highly relevant descriptive information as their experiences based on their unique attributes and specific environment. This effectively solves the problem that the experiences autonomously generated by digital entities in traditional solutions may be unrealistic or irrelevant. This mechanism makes the experiences accumulated by digital entities closer to their "identity" and "life" trajectory, greatly enhancing the realism and immersion of their independent lives. Simultaneously, because the content of the experiences is closely related to the entity's characteristics and environment, it also provides a more accurate and meaningful basis for subsequent parameter adjustments, thereby promoting the continuous evolution and growth of digital entities and giving them a richer and more coherent "life trajectory."

[0083] In some of the solutions mentioned above in this application, the adaptive evolution of transferable digital entities is simulated by adjusting their own parameters based on experience. However, in this process, the parameter adjustment may be too large or unstable, leading to sudden changes in entity behavior, unrealistic behavior, or conflict with the original state, affecting the coherence of state merging and the gradual nature of entity growth.

[0084] In this regard, this application further proposes to adjust its own parameters based on experience, including but not limited to fine-tuning the personality parameters, behavioral parameters or state parameters of the transferable digital entity, and the adjustment range meets the predetermined limit.

[0085] Specifically, "adjusting parameters based on experience" refers to enabling transferable digital entities to dynamically adjust their internal state based on the experience and information gained during independent operation, simulating the process of learning and growth. This can be achieved through a pre-defined rule engine that triggers corresponding parameter adjustment logic based on specific experiences; for example, if the experience includes "being praised," it may trigger a fine-tuning of the "extroversion" parameter. Alternatively, it can be achieved through machine learning models, such as reinforcement learning or adaptive learning algorithms, which take experiences as input and output parameter adjustment suggestions. "Fine-tuning the personality parameters, behavioral parameters, or state parameters of the transferable digital entity" aims to ensure that the scope of adjustment covers the key dimensions that may change in the digital entity's independent life. At the same time, "fine-tuning" emphasizes the gradual nature of the adjustment to avoid abrupt changes. Among them, personality parameters refer to numerical values ​​describing the personality characteristics of the digital entity, such as extroversion, introversion, emotional stability, openness, etc.; behavioral parameters refer to numerical values ​​affecting the digital entity's action patterns and decision-making logic, such as risk-taking tendency, willingness to cooperate, reaction speed, etc.; and state parameters refer to numerical values ​​describing the current internal state of the digital entity, such as mood value, fatigue level, hunger, knowledge reserve, etc. Fine-tuning these parameters can be achieved by modifying the corresponding values ​​stored in the digital entity data structure, or by updating the underlying model weights or rule sets that affect these parameters. "Adjustment magnitude meets predetermined limits" controls the range and speed of parameter adjustments, preventing drastic fluctuations, ensuring the stability and gradual evolution of digital entity behavior, and maintaining the consistency of its identity. This can be achieved by setting a maximum allowable adjustment amount (e.g., no more than ±0.01 per adjustment), checking and limiting it during parameter updates; or by defining an adjustment function that calculates the adjustment amount based on the type and intensity of the experience, but whose output is always constrained by a preset upper and lower limit; or by combining it with time window restrictions, such as ensuring that the total adjustment amount of a parameter within a specific time period (e.g., within 24 hours) does not exceed a certain threshold.

[0086] The proposed solution uses experiences autonomously generated or acquired through interaction by a transferable digital entity during independent operation on a second device as input to drive the adjustment of its internal parameters. When a digital entity generates or perceives a new experience, its internal parameter adjustment mechanism selectively makes subtle adjustments to the digital entity's personality, behavioral, or state parameters based on the nature and content of that experience. This adjustment is not unlimited but strictly adheres to preset adjustment limits, ensuring that each parameter change remains within a controllable and relatively small range. It is precisely because of this gradual and constrained adjustment mechanism that the evolution of the digital entity during independent operation remains stable and consistent, avoiding drastic personality changes or behavioral anomalies caused by dramatic parameter fluctuations. When the digital entity returns to the first device, these finely adjusted parameter changes are intelligently merged into the main state library as part of the state change, allowing the digital entity's "life trajectory" to continue smoothly after migration between different devices, maintaining the integrity and authenticity of its identity.

[0087] The following example illustrates this. Suppose a virtual character lives independently on a second device. When this virtual character has a pleasant conversation with the user of the second device and receives positive feedback (such as "You're great!"), the system recognizes this positive interaction. Based on this experience, the system may decide to fine-tune the virtual character's "confidence" personality parameter. For example, if the preset adjustment range is ±0.01, the system will fine-tune the "confidence" parameter from the current 0.700 to 0.705. Conversely, if the system autonomously generates an experience of "feeling somewhat lonely due to prolonged lack of interaction" during the virtual character's independent operation, the system may fine-tune the virtual character's "emotional value" state parameter, for example, from 0.800 to 0.795, also meeting the preset adjustment range limit. In this way, every growth and change of the virtual character during independent operation is subtle and logical, rather than abrupt or unnatural.

[0088] Through the above technical solution, this application effectively avoids drastic fluctuations in the parameters of digital entities, thereby preventing abrupt changes in their behavior or personality and maintaining the stability and consistency of the digital entity's identity. This ensures that the evolution process of the digital entity is gradual and realistic, making its "growth" trajectory more in line with natural laws and enhancing the user's immersion and emotional connection. Furthermore, when synchronizing the state back to the first device, the gradual nature of parameter adjustments effectively avoids conflicts with existing data in the main state database, ensuring the smoothness and accuracy of data merging. Combined with the above method, the autonomous generation experience and parameter adjustments of the digital entity during independent operation can form a closed loop, and the adjustments within this loop are controlled and stable, thereby improving the robustness and reliability of the entire independent life and state synchronization method.

[0089] In some of the embodiments described above in this application, independent operation is proposed to enable digital entities to autonomously generate experiences and adjust their own parameters on a second device. However, in this process, the digital entities lack the ability to interact with the users of the second device in real time, resulting in their isolated behavior, inability to respond to external input, limitation of realism and application scope, and difficulty in simulating social interactions in real life.

[0090] In this regard, this application further proposes that independent operation also includes real-time interaction with a second device user.

[0091] Independent operation refers to a transferable digital entity operating on a second device independently of the direct control of the first device, autonomously executing pre-set or dynamically generated tasks and making decisions and behaviors based on its environment and its own state. Its core lies in the digital entity possessing a certain degree of autonomy on the target device, enabling it to operate without relying on the master device. For example, independent operation can include a digital entity autonomously generating experiences, that is, generating new event or situation descriptions based on its attributes and environment through internal logic or models without external instructions; or it can include adjusting its own parameters based on experiences, that is, the digital entity fine-tuning its internal personality, behavior, or state parameters based on its experiences or interactions on the second device to simulate growth and adaptation. Real-time interaction with the user of the second device refers to the transferable digital entity's ability to instantly receive input from the user (e.g., voice, text, gestures) and respond and interact instantly based on this input (e.g., generating dialogues, performing actions, providing information). This interaction is bidirectional, dynamic, and instantaneous. For example, real-time interaction can be achieved through a natural language processing module, which can parse the user's text or voice input and generate corresponding responses by combining the current state of the digital entity with a knowledge base; or real-time interaction can be achieved through a graphical user interface or a virtual reality interface, allowing users to interact with digital entities visually and physically through clicking, dragging, or motion sensing.

[0092] This application's solution addresses the problem of isolated behavior and lack of interaction on the target device by integrating the ability to interact in real-time with the user of the second device into the independent operating mechanism of the transferable digital entity. Specifically, when the transferable digital entity resumes its operating environment on the second device and begins to live independently, in addition to autonomously generating experiences and adjusting its own parameters based on those experiences, it can also actively or passively establish a real-time interactive channel with the user of the second device. This real-time interaction allows the digital entity to go beyond simply outputting content or making internal adjustments; it can receive user input and dynamically adjust its behavior, generate new responses, and even influence its subsequent experience generation and parameter adjustments. For example, a user's question or instruction to the digital entity triggers its internal decision-making logic, generating corresponding answers or actions. These interactive processes themselves constitute the digital entity's "experience" on the second device and may further serve as the basis for adjusting its parameters. This mechanism makes the digital entity's "independent life" on the second device richer and more realistic, simulating not only internal growth but also external social interaction, thereby greatly enhancing the realism and application scope of the digital entity and enabling it to better integrate into the user's daily life, meeting needs such as emotional companionship.

[0093] As a specific implementation, when a transferable digital entity (such as a virtual character) is migrated to a second device (such as a parent's smartphone) and runs independently, the virtual character can automatically generate experiences like "making dumplings with grandma today" based on its preset personality and environment. It can also engage in real-time voice or text conversations with the parents. For example, when the parents send a text message to the virtual character, "How was your day?", the virtual character immediately parses the message and, combining its self-generated experiences of the day with its current mood, replies, "I made dumplings with grandma today, and I had a great time!" If the parents further ask, "Were the dumplings delicious?", the virtual character, based on its internal taste preference parameters and memory of the "making dumplings" experience, generates an answer like, "They were delicious! Grandma's dumplings are the best in the world!" These real-time conversations are recorded as part of the virtual character's state changes during its independent operation on the second device. When the virtual character returns to the first device, these changes are merged with historical interaction data in the main state database, giving the virtual character a coherent and interactive "life trajectory."

[0094] Through the aforementioned technical solution, the migrated digital entity, while operating independently on a second device, is no longer limited to autonomously generating experiences and adjusting its own parameters. Instead, it can engage in real-time, dynamic interaction with the user of the second device. This significantly enhances the realism and immersion of the digital entity, enabling it to respond to external input and simulate genuine social interactions, thus avoiding the problems of behavioral isolation and disconnection from human social habits. This real-time interaction not only enriches the sources of the digital entity's "experiences" on the second device, allowing for more diverse state changes, such as interaction records, but also provides the digital entity with more basis for adjusting its own parameters, promoting its more comprehensive self-evolution. Ultimately, this allows the digital entity to possess a more complete and coherent "life trajectory" after cross-device migration, greatly enhancing the user experience and the application value of the digital entity.

[0095] In some embodiments described above in this application, state changes are proposed to record changes in digital entities during independent operation. However, in their implementation, the specific content of state changes is not clearly defined, which may lead to the omission of key data such as interaction records, autonomously generated experiences, parameter adjustments, or relationship changes during synchronization, thereby affecting the completeness and accuracy of state merging. Therefore, this application further proposes that state changes include, but are not limited to, at least one of interaction records, autonomously generated experiences, parameter adjustments, or relationship changes.

[0096] Interaction logs refer to detailed data generated during real-time interactions between a transferable digital entity and a user or other entity on a second device while the entity is operating independently on that device. Specifically, these logs can include dialogue text, voice input, user commands, entity responses, interaction timestamps, and information about the interacting entities. As one possible implementation, the system can use structured logs to store key information from each interaction in a predefined data format (e.g., JSON objects or database table records) for easy subsequent querying and analysis. Another implementation approach is for the system to capture and store the raw interaction data stream, such as complete dialogue recordings or screen recordings, and perform summarization or feature extraction during synchronization.

[0097] Autonomously generated experiences refer to events, situations, or narratives that a transferable digital entity actively creates or simulates based on its own attributes and environment without direct external input or user interaction. This reflects the digital entity's ability to "live independently." Specifically, these experiences can manifest as a descriptive text, a record of a virtual event, or the evolution of an internal state. As one possible implementation, the system can invoke a content generation model, such as a lightweight language model, to automatically generate a description of what the digital entity "saw and heard" or "thought and felt," based on the digital entity's personality parameters, the current environmental context, and a preset generation strategy. Another implementation is that the system can generate structured experience data based on a preset rule engine and event triggering mechanism, combined with random elements and predefined templates, such as "completed a task today" or "interacted with a virtual pet."

[0098] Parameter adjustment amount refers to the quantitative record of minor adjustments made to the internal attribute parameters (such as personality parameters, behavioral parameters, and state parameters) of a transferable digital entity during independent operation, based on its interactions or self-generated experiences. These adjustments reflect the self-evolution and growth of the digital entity. Specifically, parameter adjustment amount can be recorded as the absolute change in the parameter (e.g., from 0.5 to 0.51), or as an increment or decrement (e.g., +0.01). As one possible implementation, the system can record the difference in each parameter adjustment, along with a timestamp of the adjustment, an identifier of the event or experience that triggered the adjustment, and the parameter value before the adjustment, for traceability and verification. Another implementation is that the system can version-manage the entire parameter set of the digital entity, generating a new parameter version after each adjustment and determining the parameter adjustment amount by comparing different versions during synchronization.

[0099] Relationship changes refer to the patterns of connection or interaction established, altered, or terminated between a transferable digital entity and other entities (such as second device users, other digital entities) or their environment during independent operation. These changes reflect the evolution of the digital entity's social and environmental adaptability. Specifically, relationship changes can include increases, decreases, or shifts in intimacy, trust, cooperative relationships, antagonistic relationships, etc. As one possible implementation, the system can maintain a relationship graph or matrix, recording the type, strength, and attributes of relationships between digital entities and other entities, and recording the updated values ​​and times of these attributes when relationships change. Another implementation is that the system can track and record the frequency, duration, and sentiment of interactions with specific entities, and calculate changes in relationship metrics based on this data, such as "intimacy with user A increased by 10%".

[0100] This application's solution ensures that all key evolutions and interactions generated by a transferable digital entity during its independent operation on a second device are fully and accurately captured by specifying the details of state changes. When a transferable digital entity operates independently on the second device, it not only passively performs tasks but also autonomously generates experiences and / or adjusts its parameters based on those experiences. During this process, the system records real-time interactions between the digital entity and the second device user, as well as content autonomously generated when there is no user interaction, forming autonomously generated experiences. Simultaneously, the digital entity's fine-tuning of its personality, behavioral, or state parameters based on these experiences is precisely recorded as parameter adjustment amounts. Furthermore, any established or altered relationships between the digital entity and the second device user or other environmental factors are also recorded as relationship changes. By using these specific types of state changes as the smallest unit of synchronization, this application ensures that when the transferable digital entity returns to the first device, the second device can send back these semantically rich and detailed state changes generated during independent operation. After the first device receives the data, it can merge it into the master state library of the portable digital entity stored locally. This avoids the problem of incomplete synchronization or data loss caused by the ambiguity of the state changes, enabling the digital entity to migrate and live independently between different devices seamlessly, and maintaining the continuity and authenticity of its "life trajectory".

[0101] The following is a concrete example. Suppose a user "sends" a virtual character from their own phone (first device) to their parents' phone (second device) to live independently for a period of time. During this period, the virtual character operates independently on the parents' phone, and any changes in its state will be recorded according to the scheme of this application. For example, the virtual character has multiple conversations with the parents; the content, time, and responses of these conversations will be recorded as interaction logs. On a night without user interaction, the virtual character, based on its preset personality and environment, autonomously generates an experience: "I made dumplings with Grandma today and felt very happy." This descriptive text is the autonomously generated experience. Because the virtual character received praise from the parents while making dumplings, the "extroversion" personality parameter of the virtual character slightly increased by 0.01; this increment is recorded as the parameter adjustment amount. At the same time, due to frequent interactions with the parents, the "intimacy" relationship index between the virtual character and the parents increased by 20% from the initial value; this change is recorded as a relationship change. When the virtual character returns to the user's first device, the second device will send back these detailed interaction records, self-generated experiences, parameter adjustments, and relationship changes to the first device, ensuring that the virtual character returns with all the "new memories" and "growth" during its independent life at its parents' home, and is intelligently merged with its original state.

[0102] Through the above technical solution, this application effectively solves the problem of vague definitions of state changes in traditional solutions, which may lead to the omission of key data during synchronization. By proposing to include interaction records, autonomously generated experiences, parameter adjustments, and relationship changes as components of state changes, this application ensures that all key information generated by the transferable digital entity during its independent operation on the second device, including its interactions with the outside world, its own creative activities, the evolution of its internal attributes, and changes in its relationships with other entities, can be comprehensively and accurately captured and recorded. This greatly improves the integrity and accuracy of state synchronization and avoids data loss or inconsistency. Based on this, after receiving and merging these detailed state changes, the first device can construct a richer, more coherent, and realistic "life trajectory" of the transferable digital entity, thereby significantly enhancing the sense of life of the digital entity and the user's emotional immersion experience.

[0103] In some embodiments described above in this application, a method for synchronizing the state of a portable digital entity is proposed, which involves independently running and recording state changes on a second device, and then merging the states upon return. However, during its implementation, state units and state change data may remain on the second device, leading to a risk of privacy breaches, as this sensitive data is not cleaned up in a timely manner and may be accessed or misused without authorization.

[0104] In response, this application further proposes to automatically delete the state unit and state change data on the second device after the transferable digital entity is returned to the first device.

[0105] Specifically, the statement "after the portable digital entity returns to the first device" suggests a preferred timing for the deletion operation. This could mean that the second device detects that the portable digital entity has successfully sent its state changes generated during independent operation to the first device and received confirmation from the first device, or that the first device sends an instruction to the second device indicating that state merging has been completed and cleanup is possible. Alternatively, the second device could trigger the deletion operation after detecting a disconnection from the first device and having completed all necessary data transmission. "Automatic deletion" means that the deletion process requires no manual intervention and is executed automatically by system programs or preset logic. This can be achieved by deploying a background service or daemon on the second device, which automatically performs the cleanup task upon receiving a deletion trigger signal. Alternatively, cleanup instructions can be embedded in the state synchronization protocol, and the deletion function can be automatically invoked by the protocol stack when synchronization is complete. "State units and state change data on the second device" clarifies the object of deletion. A state unit refers to the initial state data packet transmitted from the first device to the second device for restoring the portable digital entity's operating environment. State change data refers to all incremental data generated by a portable digital entity during its independent operation on a second device, due to activities such as autonomously generating experiences, adjusting its own parameters, or interacting with the user. This data may be stored in the local storage media of the second device in the form of files, database records, memory cache, or other forms.

[0106] This application's solution ensures data security and privacy by immediately triggering an automatic cleanup mechanism on the second device after the portable digital entity completes its independent operation on the second device and successfully synchronizes all state changes back to the first device. Specifically, when the portable digital entity, following the aforementioned method, packages and encrypts state data on the first device to generate state units, sends them to the second device via a secure channel, and runs independently on the second device recording state changes, the second device sends back the state changes generated during its independent operation once the entity returns to the first device. After the first device receives and merges these state changes, the temporary and sensitive data on the second device becomes unnecessary. At this point, the system initiates a preset automatic deletion program to thoroughly erase the original state units stored on the second device, as well as all state change data generated during independent operation. This series of operations ensures that while the portable digital entity migrates and operates independently between different devices, its sensitive data does not reside on temporary devices for extended periods, effectively avoiding the risk of data leakage. This mechanism is closely integrated with the overall process of allowing portable digital entities to operate independently on a second device and synchronize their status, forming a closed-loop security management system that ensures that while digital entities enjoy the convenience of "independent living," their data security and user privacy are fully protected.

[0107] The following example illustrates this. Suppose a user migrates a virtual character from their phone (first device) to a friend's tablet (second device), allowing the virtual character to live independently on the friend's tablet for a period of time. During this time, the virtual character interacts with the friend on the tablet, generating new experiences and fine-tuning its personality parameters based on these experiences. When the user decides to "bring back" the virtual character to their phone, the friend's tablet sends all the new experiences, parameter adjustments, and other state change data generated by the virtual character during its independent operation back to the user's phone. The user's phone receives and successfully merges these state changes into the virtual character's main state database. Once the merging is complete, a pre-set cleanup module on the friend's tablet automatically starts. This cleanup module identifies and deletes the initial state unit file of the virtual character previously received from the user's phone, as well as all log files, database records, or cached data generated during its independent operation on the tablet, ensuring that no trace of the virtual character's sensitive information remains on the friend's tablet.

[0108] Through the above technical solution, this application effectively addresses the privacy risk caused by sensitive data remaining on the second device after a portable digital entity has independently migrated across devices. This solution significantly enhances the security of the entire system by automatically cleaning up state units and state change data on the second device immediately after the digital entity returns to the first device and completes state synchronization. This not only protects user privacy and prevents unauthorized access or misuse of sensitive information but also increases user trust in the cross-device migration service for digital entities. Furthermore, this automated cleanup mechanism simplifies data management processes, ensures the cleanliness of data storage, and maintains the integrity and efficiency of the system.

[0109] In some of the solutions described above in this application, an independent living method for portable digital entities is proposed to realize the operation and state synchronization of entities on a second device. However, in this process, when entities need to migrate between multiple devices in turn, state changes may be scattered across different devices, lacking a unified aggregation mechanism, which can easily lead to data inconsistency and chaos.

[0110] In this regard, this application further proposes to support the said portable digital entity to live independently in turn across multiple devices, with all state changes ultimately aggregated to the first device.

[0111] The phrase "supporting the independent operation of the portable digital entity across multiple devices" refers to the ability of a portable digital entity, after completing independent operation on one device, to be migrated to another different device (e.g., a third device, a fourth device, etc.) to continue independent operation, rather than being limited to round trips between the first and second devices. This "round-trip" mechanism allows the digital entity to accumulate experience and state changes in different computing environments. For example, a device list can be maintained on the first device, recording the sequence of devices the digital entity has accessed or is about to access. When the digital entity returns from one device to the first device, the first device can repackage it according to a preset sequence or user instructions and send it to the next device in the list. Alternatively, a "migration path" or "device access history" can be included within the digital entity or its accompanying state unit. When the digital entity completes its operation on one device and is ready to migrate, this information can be used to determine the next target device, or the first device can schedule it based on this information.

[0112] "All state changes are ultimately aggregated to the first device" means that regardless of how many different devices a portable digital entity runs independently on, all state changes generated during its independent operation on each device (such as interaction logs, autonomously generated experiences, parameter adjustments, etc.) must be sent back to the first device for unified reception and merging. As the maintainer of the digital entity's master state database, the first device ensures the integrity and consistency of all historical and latest states. For example, each device that hosts the independent operation of the digital entity (such as the second device, third device, etc.) sends its state changes generated during independent operation directly back to the first device when the digital entity returns. The first device is responsible for receiving incremental state changes from all these devices and merging them into the locally stored master state database.

[0113] This application's solution addresses the issues of data dispersion and inconsistency during round-robin migration by supporting the independent operation of portable digital entities across multiple devices while ensuring that all state changes are ultimately aggregated on the first device. Specifically, in the basic method, the portable digital entity is packaged and encrypted on the first device to generate a state unit, which is then sent to the second device via a secure channel. The second device receives and decrypts the state unit, restoring the digital entity's operating environment, allowing it to operate independently and generate state changes. When the digital entity returns to the first device, the second device sends the state changes back to the first device, which then merges and updates the master state database. Building upon this, this application further expands the scope of the digital entity's "independent operation." After the digital entity completes independent operation and generates state changes on the second device, it does not necessarily have to immediately return to the first device. Instead, it can be migrated to other devices such as the third or fourth device to continue operating independently. For example, after the second device sends the state changes back to the first device, the first device can, according to a preset migration strategy or user instructions, repackage the digital entity (which may now contain some updated state from the second device, or the first device may repackage the updated master state after receiving state changes from the second device) and send it to the third device. The third device also receives, decrypts, and restores the operating environment, enabling the digital entity to run independently on it and generate new state changes. Regardless of which device the digital entity runs independently on (the second, third, fourth, etc.), the state changes it generates on that device are recorded. When the digital entity returns from any device, that device sends the state changes generated during its independent operation back to the first device. The first device, as the master control device and the sole maintainer of the master state database for the digital entity, is responsible for receiving incremental state changes from all these devices. The first device intelligently merges these state changes into the locally stored master state database of the digital entity, ensuring the integrity, consistency, and temporality of the master state database through mechanisms such as timestamp sorting, conflict detection, and handling. This mechanism ensures that even if the digital entity frequently migrates between multiple devices, all its "life experiences" and state evolutions can be centrally managed and uniformly recorded on the first device, avoiding data dispersion, loss, or inconsistency. The first device is not only the starting point and end point of the digital entity's "departure" and "return," but also the "memory center" of all its independent life trajectories. In this way, digital entities can have richer and more coherent "life trajectories," and their state management is more robust and reliable.

[0114] The following is a concrete example. Assume a user has a virtual character (a transferable digital entity) whose master state database is stored on the user's mobile phone (first device). The user wants this virtual character to experience "independent living" on different family and friends' devices. First, the user "sends" the virtual character from the mobile phone (first device) to their parents' tablet (second device). The mobile phone (first device) packages and encrypts the virtual character's state data, generates a state unit, and sends it to the parents' tablet (second device) through a secure channel. The parents' tablet (second device) receives and decrypts the state unit, restoring the virtual character's operating environment. The virtual character lives independently on the parents' tablet for a week, interacting with their parents multiple times and autonomously generating experiences such as "making dumplings with grandma," resulting in minor adjustments to its personality parameters. After a week, the virtual character does not directly return to the user's mobile phone (first device), but is instead arranged by the user to "visit" the grandparents' smart speaker (third device). At this point, the parents' tablet (the second device) sends all state changes (including interaction logs, self-generated experiences, parameter adjustments, etc.) that occurred during the virtual character's independent operation on the tablet back to the user's phone (the first device). The user's phone (the first device) receives and merges these changes into the virtual character's main state library stored locally. Subsequently, the user's phone (the first device) packages and encrypts the updated virtual character state data again, generating a new state unit, and sends it to the grandparents' smart speaker (the third device) through a secure channel. The smart speaker (the third device) receives and decrypts the state unit, restoring the virtual character's operating environment. The virtual character lived independently on the smart speaker for three days, during which it interacted with the grandparents via voice and self-generated experiences such as "playing chess with grandpa," resulting in minor adjustments to its behavioral parameters. Three days later, the virtual character returns to the user's phone (the first device) from the grandparents' smart speaker (the third device). The smart speaker (the third device) sends all state changes that occurred during the virtual character's independent operation on the smart speaker back to the user's phone (the first device). The user's mobile phone (the first device) receives these state changes and merges them into the locally stored master state library of the virtual character. In this way, whether the virtual character lives independently on the parents' tablet (the second device) or the grandparents' smart speaker (the third device), all its experiences and state changes are ultimately and uniformly summarized on the user's mobile phone (the first device). The user's mobile phone (the first device) always maintains the most complete and coherent "life trajectory" of the virtual character.

[0115] Through the above technical solution, this application effectively solves the problem that when digital entities migrate between multiple devices, their state changes may be scattered across different devices, lacking a unified aggregation mechanism, which can easily lead to data inconsistency and chaos. Specifically, it supports portable digital entities to live independently across multiple devices, enabling them to transcend the limitations of a single device and accumulate diverse experiences and state evolutions in a broader computing environment, greatly enriching the "life trajectory" of digital entities and the realism of their independent lives. Simultaneously, all state changes are ultimately aggregated to the first device, ensuring that no matter where the digital entity operates independently, all its incremental data can be centrally and completely collected and managed and merged on the main device. This not only guarantees the integrity and consistency of the digital entity's master state database, avoiding the risks of data dispersion, loss, or conflict, but also simplifies the complexity of state synchronization, allowing digital entities to seamlessly continue to grow and evolve in multi-device environments, providing users with a more coherent and immersive digital entity companionship experience.

[0116] Traditional existing digital entity migration solutions suffer from problems during cross-device migration, such as disconnect between state migration and independent operation, lack of autonomous experience generation mechanism, lack of adaptive evolution capability, single state synchronization strategy, and disconnect from human social habits. As a result, digital entities cannot truly live independently on the target device and bring back new experiences.

[0117] To address this issue, this application proposes an independent life and state synchronization system for portable digital entities. Through a collaborative architecture of a first device and a second device, the digital entity can autonomously generate experiences, self-evolve, and synchronize its intelligent state after migration. Specifically, the first device is responsible for packaging and encrypting the state data of the portable digital entity to generate state units, and sending them to the second device via a secure channel; simultaneously, it receives state changes returned from the second device and merges and updates its local storage. The second device is responsible for receiving and decrypting the state units, restoring the operating environment of the portable digital entity, enabling the portable digital entity to operate independently on the second device. This independent operation includes autonomously generating experiences and / or adjusting its own parameters based on those experiences, and recording state changes; upon the portable digital entity's return, it sends the state changes back to the first device.

[0118] The core innovation of this embodiment lies in combining the independent operational capabilities of the second device (including autonomous experience generation and parameter adjustment based on experience) with the intelligent state merging mechanism of the first device. This solves the problem of digital entities being unable to autonomously generate experiences, evolve themselves, and synchronize their states after migrating across devices. Specifically, the second device enables digital entities to autonomously generate natural language descriptions of their experiences by invoking a content generation model without user interaction. For example, it can simulate daily activities and generate narratives such as "I made dumplings with my grandma today." Simultaneously, the digital entity can make minor adjustments to its personality and behavioral parameters based on these experiences (within predetermined limits), achieving gradual evolution. The first device, through timestamp appending and conflict detection mechanisms, intelligently merges incremental state changes into the main state library, ensuring memory continuity.

[0119] This application's solution achieves seamless migration and independent operation of digital entities through a collaborative architecture of a first device and a second device. First, the first device packages and encrypts state data to ensure the security and integrity of the migration process. The second device receives and decrypts the state units, restoring the digital entity's operating environment so it can continue operating on the new device. During independent operation, the digital entity can not only interact with the target device user in real time to generate new memories, but also autonomously generate experiences even without interaction. These experiences trigger minor adjustments to parameters, simulating the evolution of a real personality. All state changes are captured by the incremental recording module and returned to the first device, where they are integrated into the main state library through the intelligent merging strategy of the state merging module, avoiding data chaos caused by full-scale overwrite.

[0120] Through the aforementioned technical solution, digital entities can truly achieve "independent living" on the target device, autonomously generating new experiences and evolving on their own, while ensuring the continuity and integrity of state synchronization upon return. This not only enhances the sense of life and realism of digital entities but also simulates the "leaving home-returning home" life trajectory, satisfying the need for emotional companionship. Compared to basic solutions, this application has significant advantages in supporting proactive experience generation, achieving progressive evolution, and intelligently merging incremental states, enabling digital entities to possess a genuine "life trajectory."

[0121] The following is a concrete example: Suppose a user migrates a virtual character from their phone to their parents' tablet. The first device packages and encrypts the character's state data (including historical interaction records, attribute parameters, and configuration information) to generate a state unit, which is then sent to the second device via a secure channel. The second device receives and decrypts the state unit, restoring the character's operating environment. On the parents' device, the character not only generates new memories from daily conversations with their parents but also autonomously generates daily experiences every morning (e.g., "made dumplings with Grandma today") and fine-tunes personality parameters based on these experiences (e.g., extraversion increases by 0.01 due to praise). When the character returns a week later, the second device sends all state changes (including interaction records, autonomously generated experiences, and parameter adjustments) back to the first device. The first device then merges and updates these changes to local storage using timestamp sorting and conflict detection mechanisms, allowing the character to continue growing with new experiences and forming a complete life trajectory.

[0122] In some of the solutions described above in this application, a second device is proposed to enable the independent operation of transferable digital entities, including autonomously generating experiences and adjusting parameters based on those experiences, in order to achieve independent life for the digital entities. However, in this process, the lack of a dedicated engine to efficiently invoke the content generation model to generate experiences and accurately adjust parameters based on those experiences may lead to inconsistent generated experiences or inaccurate parameter adjustments, thereby affecting the authenticity and evolutionary effect of the independent operation of the digital entity.

[0123] In this regard, this application further proposes that the second device includes an independent running engine, which is configured to call a content generation model to generate experiences and adjust parameters according to the experiences.

[0124] The independent execution engine is a software or hardware module within the second device specifically responsible for managing and executing the independent execution logic of transferable digital entities. Its role is to ensure that digital entities can autonomously generate experiences, adjust their own parameters, and interact with the environment on the second device without continuous user intervention. As one implementation, the independent execution engine can be a standalone software service or process deployed on top of the second device's operating system, communicating with the content generation model and parameter adjustment module via an application programming interface (API). Alternatively, the independent execution engine can be a specific processing unit integrated into the second device's main control chip, efficiently executing relevant logic through firmware or a dedicated instruction set. The content generation model is an algorithm or neural network model capable of automatically generating text, images, or other forms of content based on input conditions (such as the digital entity's attributes, environment, and historical data). Its role is to provide transferable digital entities with the ability to autonomously generate "experiences," enabling them to produce new state changes even without external interaction. For example, a content generation model can be based on a pre-trained lightweight language model, performing inference on a local device to generate narrative text based on the personality parameters of a digital entity and a description of its current environment. Alternatively, it can be based on a rule engine combined with template filling, dynamically generating descriptive statements based on preset event types and entity attributes. Generated experiences refer to the independent running engine creating new, narrative, or event-based state records for transferable digital entities by invoking the content generation model. Its role is to simulate the "life" process of the digital entity during independent operation, enabling it to possess continuous, autonomously generated memories and growth trajectories. For example, the independent running engine can periodically (e.g., daily or every few hours) trigger the content generation model to generate descriptive text based on the digital entity's current attributes (such as mood, interests) and the virtual or physical environment of the second device (e.g., "at parents' house," "in a factory workshop"). Alternatively, the independent running engine can also invoke the content generation model when a specific event is triggered (e.g., detecting a long period of no user interaction) to generate an "inner monologue" or "thought process" reflecting changes in the entity's internal state. Adjusting parameters based on experience refers to the independent engine adaptively modifying the attribute parameters (such as personality, behavioral preferences, and state values) of a digital entity based on its newly generated experiences or interactive content. Its purpose is to enable the digital entity to evolve and grow based on its "life" experience, thereby enhancing its realism and sense of life.For example, an independent running engine may include a parameter adjustment module that analyzes newly generated experience text, extracts key information (such as positive / negative emotions, specific events), and makes minor adjustments to the personality parameters (such as extraversion, conscientiousness) of digital entities based on preset rules or small neural network models; or, the independent running engine may also adjust the behavioral parameters (such as preference for specific tasks, response speed) of digital entities based on specific behaviors or results reflected in the experience.

[0125] This application introduces an independent operating engine, providing an efficient and precise independent operating mechanism for transferable digital entities on a second device. This independent operating engine, as a core component of the second device, is specifically responsible for managing the autonomous activities of the digital entities. Specifically, the independent operating engine begins functioning once the transferable digital entity restores its operating environment on the second device. It is configured to periodically or event-wise invoke a content generation model, which generates narrative "experiences" based on the digital entity's current attributes, historical data, and environmental information of the second device. For example, if the digital entity is a virtual character, the content generation model might generate a scenario describing its interaction with the user or autonomous activities on the second device. Furthermore, the independent operating engine is configured to adjust the digital entity's own parameters based on these newly generated experiences. This means that the digital entity is no longer passively executing preset tasks but can self-learn and evolve based on its "life" experiences. For example, if the generated experience describes positive interactions or successful events, the independent operating engine might fine-tune the digital entity's personality parameters, making it more extroverted or confident; conversely, if the experience includes negative events, it may lead to fine-tuning of relevant parameters to reflect its "emotions" or "learning." This mechanism ensures that digital entities can continuously accumulate experience and improve themselves during independent operation, making their "life trajectory" more realistic and coherent. By introducing an independent operation engine, this application further addresses the problem of digital entities lacking autonomous experience generation and adaptive evolution capabilities during independent operation on the target device, building upon the second device system. The independent operation engine integrates and optimizes content generation and parameter adjustment functions, enabling the second device to efficiently support the "independent life" of digital entities, rather than simply performing state transitions and passive execution. This specialized engine design allows digital entities to truly "come alive," autonomously generating new state changes and adjusting themselves accordingly, thereby greatly enhancing the sense of life and interactive experience of the digital entities.

[0126] In one specific implementation, the second device can be a smart home hub, while the migrated digital entity is a virtual family member. Once the virtual family member is migrated to the smart home hub, its independent operating engine is activated. This independent operating engine can be a Python service deployed on the smart home hub's operating system. This service periodically (e.g., every 6 hours) calls a locally deployed lightweight language model as the content generation model. The language model receives the virtual family member's current personality parameters (such as "lively" or "curious") and environmental information from the smart home hub (such as "a cartoon is playing on the TV in the living room"), and then generates descriptive text, such as: "Today, Xiaoming (the virtual family member's name) watched a cartoon in the living room and found it very interesting, even learning a few new lines." Subsequently, the parameter adjustment module in the independent operating engine analyzes this generated experience. For example, it might identify positive information such as "very interesting" and "learned a few new lines," and according to preset rules, increase the virtual family member's "curiosity" parameter by 0.005 and the "language learning ability" parameter by 0.002. These small adjustments accumulate, allowing the personalities and abilities of virtual family members to evolve gradually as they operate independently. The entire process requires no user intervention, allowing virtual family members to "live" and "grow" autonomously.

[0127] Through the aforementioned technical solution, the second device, by introducing an independent operating engine, provides a highly efficient and precise independent operating mechanism for transferable digital entities. This engine is specifically responsible for calling upon the content generation model to generate experiences and adjusting the parameters of the digital entity based on these experiences, thereby solving the problem in traditional solutions where digital entities lack the ability to autonomously generate experiences and adaptively evolve during independent operation. Specifically, the introduction of the independent operating engine enables digital entities to continuously generate new and coherent "life experiences" and adjust and grow based on these experiences, greatly enhancing the realism and vitality of the digital entities. This not only improves the emotional connection between users and digital entities but also allows digital entities to truly "live independently" after cross-device migration, possessing a richer and more dynamic "life trajectory," rather than merely passively executing preset tasks.

[0128] In some of the embodiments described above in this application, an independent life and state synchronization system for portable digital entities is proposed to realize the state migration and operation recovery of digital entities. However, in its implementation process, when the portable digital entity returns to the first device, the state unit and state change data on the second device are not automatically deleted, which poses risks of privacy leakage and data security.

[0129] In this regard, this application further proposes that the system also includes a cleanup module configured to automatically delete the state units and state change data on the second device after the migrated digital entity is returned.

[0130] The cleanup module is a functional unit whose primary responsibility is to perform data deletion operations to ensure that specific data is completely removed under specific conditions. This module can be a standalone software service or process running on the second device and listening for specific events (such as the return of a digital entity), or it can be part of the second device's operating system or runtime environment, performing data cleanup tasks through an application programming interface (API) or system calls. The cleanup module is configured to automatically delete data upon the return of a migrated digital entity, meaning that the data cleanup operation is performed immediately after the digital entity completes its independent operation on the second device and returns to the first device, without manual intervention. The cleanup module can subscribe to an event notification mechanism; when the first device confirms receipt of the state change and completion of the merging, it sends a "entity returned" signal to the second device, triggering the cleanup module. Alternatively, the second device can periodically check whether a digital entity has returned (e.g., by querying the status of the first device or checking the local entity running status), and initiate the cleanup process once a return is detected. The state unit is a packaged and encrypted form of the initial state data of a migrated digital entity when it migrates from the first device to the second device, containing all the necessary information about the digital entity before it begins independent operation. State change data is all incremental data generated by a transferable digital entity while it is running independently on a second device, including but not limited to at least one of the following: interaction logs, autonomously generated experiences, parameter adjustments, or relationship changes.

[0131] This application's solution effectively addresses privacy and security issues caused by data residue by introducing a cleanup module that automatically deletes specific data on the second device after the migrated digital entity returns. Specifically, when a migrated digital entity needs to be migrated from the first device to the second device, the first device packages and encrypts its state data to form a state unit, which is then sent to the second device via a secure channel. The second device receives and decrypts the state unit, restoring the migrated digital entity's operating environment so it can run independently on the second device, including autonomously generating experiences and / or adjusting its parameters based on those experiences, while recording all state changes generated during this period. When the migrated digital entity completes its independent operation on the second device and returns to the first device, the second device sends the state changes generated during independent operation back to the first device, which receives and merges them into its locally stored master state database. Furthermore, the cleanup module is tightly integrated with the second device. Its working principle is that the cleanup module is triggered after the migrated digital entity returns to the first device and completes state synchronization. Once triggered, the cleanup module automatically identifies and deletes the state units and state change data associated with the migrated digital entity on the second device. This automated cleanup mechanism ensures that sensitive data of a digital entity does not linger on the second device after the entity leaves, effectively preventing unauthorized access or data leakage and protecting user privacy and data security. In this way, the cleanup module forms a closed loop with the state synchronization process of the first and second devices, enabling not only independent operation and state synchronization of digital entities across devices but also guaranteeing data security and privacy throughout the entire lifecycle.

[0132] In one specific implementation, when a user decides to migrate a virtual character from their mobile phone (first device) to their parent's tablet (second device), the user's phone first packages and encrypts the virtual character's current state data (such as personality parameters, historical interaction records, etc.) to generate a state unit, and sends it to the parent's tablet via an encrypted channel. After receiving and decrypting the state unit, the parent's tablet restores the virtual character's operating environment locally, allowing the virtual character to "live" independently on it. During this period, the virtual character may interact with the parents, or autonomously generate experiences when there is no interaction (e.g., "made dumplings with Grandma today"), and fine-tune its parameters based on these experiences. All this new data generated on the tablet, including interaction records and parameter adjustments, is recorded as state change data. When the user decides to take the virtual character back from the parent's tablet to their own phone, the parent's tablet sends this state change data back to the user's phone. The user's phone receives and merges it into the virtual character's main state library. After this, the cleanup module on the parent's tablet is activated. This cleanup module can be a pre-installed application component on the tablet. It is configured to automatically perform a cleanup operation after detecting that the virtual character has successfully returned to the primary device and completed data synchronization. Specifically, the cleanup module locates and completely deletes the previously received state units of the virtual character, as well as all state change data generated during independent operation. For example, the cleanup module can call the file system API to delete specific directories or files storing this data, or clear related database records. In this way, it ensures that the virtual character's sensitive information does not leave any residue on the parent's tablet, thus effectively protecting the user's privacy.

[0133] Through the aforementioned technical solution, after the portable digital entity completes its independent operation on the second device and returns to the first device, the cleanup module on the second device can automatically delete the state units and state change data associated with the digital entity. This effectively prevents the digital entity from leaving sensitive data residues on the second device, thereby significantly reducing the risk of data leakage and unauthorized access. Given that portable digital entities may contain users' personal preferences, interaction history, and other private information, this automated cleanup mechanism greatly enhances the privacy protection capabilities and data security of the entire system. Simultaneously, this cleanup operation is automatic, requiring no manual user intervention, ensuring the timeliness and thoroughness of the operation, avoiding the risk of data leakage due to human negligence, and ensuring that the digital entity enjoys the convenience of independent operation across devices while its data security and user privacy are fully protected.

[0134] In some of the solutions described above in this application, methods for independent living and state synchronization of portable digital entities were proposed to support cross-device migration, independent operation, and intelligent state synchronization of digital entities. However, in this process, a storable and computer-executable medium is lacking to actually deploy and execute these methods, resulting in the inability to persistently save the methods, distribute them to different devices for automatic execution, thereby limiting the practicality and scalability of the methods. To address this, this application further proposes a computer-readable storage medium storing a computer program that, when executed by a processor, implements the aforementioned methods.

[0135] Computer-readable storage media refers to any physical or non-physical medium capable of storing data and computer programs, allowing a computer system to read and access them. The concept encompasses various forms, aiming to provide persistent storage for computer programs. As one implementation, this medium can be non-volatile memory, such as hard disk drives (HDDs), solid-state drives (SSDs), flash memory (such as USB flash drives, SD cards), or optical discs (such as CD-ROMs, DVDs, Blu-ray discs). Alternatively, the medium can be volatile memory, such as random access memory (RAM), providing temporary storage during program loading and runtime. A computer program is a collection of instructions designed to be executed by a computer to perform a specific task or achieve a specific function. These instructions are typically written in a high-level programming language and then compiled or interpreted into machine-executable code. As one implementation, a computer program can exist as an executable file (such as .exe, .bin), containing all the logic and instructions for implementing methods for the independent living and state synchronization of portable digital entities. In another implementation, computer programs can also be script files (such as Python scripts and JavaScript files) or bytecode files (such as Java bytecode), executed at runtime through an interpreter or virtual machine. The processor is the core component in a computer system responsible for executing instructions and performing arithmetic and logical operations; it is the actual executor of the computer program. Its function is to parse and execute the instructions in the computer program, thereby driving the operation of the entire system. As one implementation, the processor can be a central processing unit (CPU), such as Intel Core series, AMD Ryzen series, or ARM architecture processors, which possess powerful general-purpose computing capabilities. Alternatively, the processor can be a dedicated processor, such as a graphics processing unit (GPU) providing parallel processing capabilities for specific computing tasks, a digital signal processor (DSP) for processing digital signals, or a microcontroller (MCU) integrated into an embedded device. When a program is executed by the processor, the above method is implemented by executing the sequence of instructions encoded in the computer program, under the control of the processor, according to a predetermined logic and order, thereby completing all the steps of the method for independent living and state synchronization of portable digital entities. The role of this technical feature is to transform abstract method logic into a practically operable computational process, enabling the method to run automatically and efficiently. As one implementation, the processor can load a computer program from the storage medium and process the data according to the program instructions, such as performing steps like packaging and encrypting state data, secure transmission, restoring the operating environment, generating and adjusting the experience and parameters during independent operation, recording state changes, and finally merging the states.Another approach is to have the program run concurrently on the processor in a multi-threaded or multi-process manner through the operating system's scheduling, thereby improving processing efficiency and response speed and ensuring that the independent life and state synchronization process of digital entities on different devices can proceed smoothly.

[0136] This application's solution transforms an abstract method into a deployable and runnable entity by solidifying and storing the complex logic of enabling a portable digital entity to live independently and synchronize its state on a computer-readable storage medium, which is then executed by a processor. Specifically, when a computer program is loaded into the processor's execution environment, the processor executes each step of the aforementioned method according to a pre-defined sequence of instructions. This includes packaging and encrypting the state data of the portable digital entity on a first device to generate state units; subsequently, these state units are sent to a second device via a secure channel. On the second device, the processor also executes program instructions, receives and decrypts the state units, and restores the portable digital entity's operating environment. The program then drives the portable digital entity to run independently on the second device, including autonomously generating experiences and / or adjusting its parameters based on those experiences. During this independent operation, all resulting state changes are recorded by the program. When the portable digital entity needs to return to the first device, the program on the second device instructs the processor to send the state changes generated during independent operation back to the first device. Finally, the program on the first device receives these state changes and guides the processor to intelligently merge them into the locally stored master state library of the portable digital entity. This design transforms the aforementioned methods from mere theoretical steps into automated, reliable deployment and execution across various computing devices via software, significantly enhancing their practicality and scalability. In this way, this application not only solves the problems of persistent storage and automated operation of methods but also enables digital entities to truly possess a cross-device, independent "life trajectory," ensuring the consistency and integrity of their state.

[0137] The following is a concrete example. In one specific implementation, the computer-readable storage medium can be a solid-state drive (SSD) pre-installed with an operating system. A specific partition on this SSD is used to store a computer program that implements a method for enabling the independent living and state synchronization of migrated digital entities. The computer program can be an application written in a compiled language such as C++ or Java, and its compiled executable file (e.g., an ELF format executable on Linux systems, and a PE format executable on Windows systems) is stored in the specific partition on the SSD. The processor can be a multi-core central processing unit (CPU) integrated on a smartphone or server motherboard, such as an ARM Cortex-A series processor or an Intel Xeon series processor. When the user initiates the digital entity migration function on the first device (e.g., the user's smartphone), the operating system loads and starts the computer program stored on the SSD. This program first instructs the CPU to perform a packet encryption operation on the state data, and then, through a network interface (e.g., a Wi-Fi module), invokes a secure transmission protocol to send the encrypted state units to a second device (e.g., a parent's smartphone or a cloud server). On the second device, a similar computer program is loaded and executed by its CPU, receiving and decrypting state units and constructing the runtime environment for the digital entity in memory. This program then continues to run on the CPU, driving the digital entity to perform independent activities, such as invoking a local lightweight content generation model (also stored as part of the program on the SSD) to generate experiences and fine-tuning the digital entity's parameters based on these experiences. Data changes generated by all these activities are written by the program to a temporary storage area on the second device's SSD. When the digital entity returns, the program on the second device is reactivated, instructing the CPU to read this temporarily stored data and send it back to the first device via the network interface. Upon receiving this data, the program on the first device instructs the CPU to execute intelligent merging logic, integrating the new state changes into the digital entity's main state library.

[0138] Through the above technical solution, this application provides a way to solidify the method for independent living and state synchronization of portable digital entities into an executable program, thereby solving the problems of the method's inability to be persistently saved, automatically run on different devices, and limiting its practicality and scalability. Specifically, the introduction of computer-readable storage media enables the complex logic for realizing the independent living and state synchronization of digital entities to be reliably stored and transmitted, no longer merely a theoretical concept. The computer program, as the specific encoding of this logic, ensures the accuracy and automated execution of the method steps. When the program is executed by the processor, the entire method flow runs efficiently and seamlessly without manual intervention, greatly improving the convenience and efficiency of operation. This combination not only enables digital entities to truly achieve independent living after cross-device migration, autonomously generating experiences and self-evolving, but also ensures intelligent state synchronization when returning to the main device, thus giving digital entities a coherent "life trajectory." In addition, by software-izing the method, the solution of this application is easy to deploy on different hardware platforms and operating systems, significantly enhancing its versatility and scalability, laying the foundation for providing independent living capabilities for digital entities in a wider range of application scenarios.

[0139] Other application scenarios The following simplified embodiments illustrate the application of the present invention in other fields. Specific implementations of these embodiments can be found in the examples described in the detailed embodiments above, and will not be repeated here.

[0140] Simplified Example 1: Robot Task Parameter Transfer and Adaptation After completing part of a task at one workstation, an industrial robot needs to move to another workstation to continue working. The main equipment packages the robot's current task parameters, working status, etc., and sends them to the target equipment. The robot operates independently on the target equipment, during which: Automatically adjust motion parameters (such as speed and force) according to the new environment.

[0141] Interact with collaborative devices to generate new task records.

[0142] Upon return, the incremental status (adjusted parameters, new task records) is synchronized back to the master device and merged with the original task history to optimize future operations.

[0143] Simplified Implementation Example 2: Digital Clone Cross-Device Companionship The digital avatar created by the user can be migrated between home TVs, mobile phones, tablets, and other devices. The avatar operates independently on different devices, interacts with family members, and automatically generates a time log (such as "played chess with Grandpa today"). When returning to the main device, all the time spent together is summarized to form a complete interaction profile.

[0144] Simplified Example 3: Driving Mode Shifting in Vehicle Systems Drivers package their driving preferences (seat position, music playlist, navigation habits) and transfer them to the rented vehicle. During the driver's use, the vehicle's driver assistance parameters are fine-tuned based on their operating habits. Upon return of the vehicle, the incremental adjustments are transmitted back to the user's main account for future reference.

[0145] The above descriptions are merely embodiments of this application and are not intended to limit the scope of protection of this application. It should be noted that the term "user" in this application is a preferred embodiment of the interactive object, but not a limitation on the scope of protection. Those skilled in the art should understand that the interactive object can be any entity capable of interacting with the interactive system, such as a human user, other systems, devices, or applications. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of protection of this application.

[0146] This solution is applicable not only to local devices but can also be deployed on cloud servers. Those skilled in the art should understand that the technical solution of this invention is not limited to a specific deployment environment, and any implementation based on the technical concept of this application should be considered to fall within the protection scope of this invention.

Claims

1. A method for synchronizing the independent life and state of a portable digital entity, characterized in that, Includes the following steps: On a first device, the state data of the portable digital entity is packaged and encrypted to generate a state unit; The status unit is sent to the second device through a secure channel; The second device receives and decrypts the status unit, restoring the operating environment of the migrated digital entity; The transferable digital entity operates independently on the second device, and the independent operation includes autonomously generating experiences and / or adjusting its own parameters based on those experiences. When the portable digital entity returns to the first device, the second device will send back the state changes that occurred during independent operation to the first device; The first device receives the state change and merges it into the master state library of the portable digital entity stored locally.

2. The method according to claim 1, characterized in that, The state data of the transferable digital entity includes, but is not limited to, at least one of the entity's historical interaction data, attribute parameters, and configuration information.

3. The method according to claim 1, characterized in that, The transferable digital entities include, but are not limited to, virtual characters, intelligent agents, digital clones, robot task states, or vehicle system driving configurations.

4. The method according to claim 1, characterized in that, The autonomously generated experience includes calling a content generation model to generate descriptive information based on the attributes and environment of the transferable digital entity.

5. The method according to claim 1, characterized in that, The adjustment of its own parameters based on experience includes, but is not limited to, fine-tuning the personality parameters, behavioral parameters, or state parameters of the transferable digital entity, and the adjustment range meets a predetermined limit.

6. The method according to claim 1, characterized in that, The independent operation also includes, but is not limited to, real-time interaction with a second device user.

7. The method according to claim 1, characterized in that, The state changes include, but are not limited to, at least one of the following: interaction records, self-generated experiences, parameter adjustments, or relationship changes.

8. The method according to claim 1, characterized in that, Also includes: After the transferable digital entity returns to the first device, the state unit and state change data on the second device are automatically deleted.

9. The method according to claim 1, characterized in that, The portable digital entity can live independently across multiple devices, with all state changes ultimately aggregated to the first device.

10. A system for synchronizing the independent life and status of a portable digital entity, characterized in that, include: The first device is configured to package and encrypt the state data of the transferable digital entity to generate a state unit, send it to the second device through a secure channel, and receive the state changes returned from the second device and merge and update the local storage. The second device is configured to receive and decrypt the state unit, restore the operating environment of the portable digital entity, enable the portable digital entity to run independently on the second device, the independent operation including autonomously generating experiences and / or adjusting its own parameters based on the experiences, and recording state changes; and send the state changes back to the first device when the portable digital entity returns.

11. The system according to claim 10, characterized in that, The second device includes an independent running engine configured to invoke a content generation model to generate experiences and adjust parameters based on those experiences.

12. The system according to claim 10, characterized in that, It also includes a cleanup module configured to automatically delete state units and state change data on the second device after the migrated digital entity returns.

13. A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the method of any one of claims 1 to 9.

Images