When translating a content entity using the **AI Translate** functionality, the translation process also processes entities referenced through an **Entity Reference** field. This can result in an already translated and manually edited referenced entity being translated again as part of the same batch process. As a result, the manually modified translation of the referenced entity can be overwritten. ## Steps to Reproduce ### 1. Create Two Content Types Create the following two content types: - **Test A** - **Test B** ### 2. Configure an Entity Reference Add an **Entity Reference** field to **Test B** that references a **Test A** node. Example: ```text Test B └── Entity Reference └── Test A ``` ### 3. Create Content Create a **Test A** node: ```text Test A Title: Sample Content ``` Create a **Test B** node and reference the Test A node: ```text Test B Title: Sample Parent Content Referenced entity: └── Sample Content (Test A) ``` ### 4. Translate Test A Use **AI Translate** to translate the Test A node into another language. For example: ```text English → Arabic ``` After the translation is created, manually edit the Arabic translation of Test A. Example: ```text AI-generated Arabic translation ↓ User manually modifies the translation ↓ Final manually edited Arabic translation ``` The manual changes should remain intact. ### 5. Translate Test B Using AI Translate Now translate the Test B node using **AI Translate**. Because Test B contains an **Entity Reference** to Test A, the translation process also identifies/processes the referenced Test A entity. ### 6. Observe the Referenced Entity The translation batch processes Test A again even though its Arabic translation already exists and may have been manually modified. As a result, the previously manually edited translation of Test A can be overwritten by the newly generated AI translation. ## Actual Result When Test B is translated using **AI Translate**, the referenced Test A entity is also processed/re-translated in the same batch. If Test A already has an existing translation that was manually edited, those manual changes can be overwritten. Example: ```text Test A ├── Original English content └── Arabic translation └── Manually edited by user ↓ Test B translated using AI Translate ↓ Test A is processed again because it is referenced by Test B ↓ Existing Arabic translation of Test A is overwritten ``` This behavior can cause previously reviewed or manually maintained translations to be reverted unexpectedly. ## Expected Result When an entity referenced through an **Entity Reference** field already has an available translation, the translation process should **not automatically re-translate or overwrite that existing translation** as a side effect of translating the parent entity. The existing translation, including any manual changes, should remain unchanged unless an explicit action is taken to retranslate that entity. ## Impact This behavior can result in: - Manual translation changes being lost. - Previously reviewed translations being overwritten. - Unexpected content changes in languages that were already translated. - Translation consistency issues across related entities. - Difficulty identifying which entity was responsible for the translation update. **The issue is fixed by setting “Translate referenced entities” to No for the relevant AI Translate field configuration.** From your screenshot, the important setting is: AI Translate → Translate referenced entities → **No** Previously, it was effectively: **Translate referenced entities → Use default → Current default for node is Yes** {width=451 height=298}