diff --git a/x-pack/test/api_integration/deployment_agnostic/apis/observability/ai_assistant/conversations/conversations.spec.ts b/x-pack/test/api_integration/deployment_agnostic/apis/observability/ai_assistant/conversations/conversations.spec.ts
index e6d21a19b4688..6b38ed3c47523 100644
--- a/x-pack/test/api_integration/deployment_agnostic/apis/observability/ai_assistant/conversations/conversations.spec.ts
+++ b/x-pack/test/api_integration/deployment_agnostic/apis/observability/ai_assistant/conversations/conversations.spec.ts
@@ -11,6 +11,7 @@ import {
   type ConversationCreateRequest,
   type ConversationUpdateRequest,
   MessageRole,
+  Conversation,
 } from '@kbn/observability-ai-assistant-plugin/common/types';
 import type { SupertestReturnType } from '../../../../services/observability_ai_assistant_api';
 import type { DeploymentAgnosticFtrProviderContext } from '../../../../ftr_provider_context';
@@ -408,8 +409,8 @@ export default function ApiTest({ getService }: DeploymentAgnosticFtrProviderCon
     });
 
     describe('conversation duplication', () => {
-      let publicConversationId: string;
-      let privateConversationId: string;
+      let publicConversation: Conversation;
+      let privateConversation: Conversation;
 
       before(async () => {
         const publicCreateResp = await observabilityAIAssistantAPIClient.editor({
@@ -428,7 +429,7 @@ export default function ApiTest({ getService }: DeploymentAgnosticFtrProviderCon
           },
         });
         expect(publicCreateResp.status).to.be(200);
-        publicConversationId = publicCreateResp.body.conversation.id;
+        publicConversation = publicCreateResp.body;
 
         const privateCreateResp = await observabilityAIAssistantAPIClient.editor({
           endpoint: 'POST /internal/observability_ai_assistant/conversation',
@@ -446,80 +447,122 @@ export default function ApiTest({ getService }: DeploymentAgnosticFtrProviderCon
           },
         });
         expect(privateCreateResp.status).to.be(200);
-        privateConversationId = privateCreateResp.body.conversation.id;
+        privateConversation = privateCreateResp.body;
       });
 
       after(async () => {
-        for (const id of [publicConversationId, privateConversationId]) {
+        for (const conversation of [publicConversation, privateConversation]) {
           const { status } = await observabilityAIAssistantAPIClient.editor({
             endpoint: 'DELETE /internal/observability_ai_assistant/conversation/{conversationId}',
-            params: { path: { conversationId: id } },
+            params: { path: { conversationId: conversation.conversation.id } },
           });
           expect(status).to.be(200);
         }
       });
 
-      it('allows the owner to duplicate their own private conversation', async () => {
-        const duplicateResponse = await observabilityAIAssistantAPIClient.editor({
-          endpoint:
-            'POST /internal/observability_ai_assistant/conversation/{conversationId}/duplicate',
-          params: {
-            path: { conversationId: privateConversationId },
-          },
+      describe('allows the owner to duplicate their own private conversation', () => {
+        let duplicatedConversation: Conversation;
+        before(async () => {
+          const duplicateResponse = await observabilityAIAssistantAPIClient.editor({
+            endpoint:
+              'POST /internal/observability_ai_assistant/conversation/{conversationId}/duplicate',
+            params: {
+              path: { conversationId: privateConversation.conversation.id },
+            },
+          });
+          expect(duplicateResponse.status).to.be(200);
+
+          duplicatedConversation = duplicateResponse.body;
         });
-        expect(duplicateResponse.status).to.be(200);
 
-        const duplicatedId = duplicateResponse.body.conversation.id;
-        expect(duplicatedId).not.to.eql(privateConversationId);
-        expect(duplicateResponse.body.user?.name).to.eql('elastic_editor');
+        after(async () => {
+          // cleanup
+          const { status } = await observabilityAIAssistantAPIClient.editor({
+            endpoint: 'DELETE /internal/observability_ai_assistant/conversation/{conversationId}',
+            params: { path: { conversationId: duplicatedConversation.conversation.id } },
+          });
+          expect(status).to.be(200);
+        });
 
-        const { status } = await observabilityAIAssistantAPIClient.editor({
-          endpoint: 'DELETE /internal/observability_ai_assistant/conversation/{conversationId}',
-          params: { path: { conversationId: duplicatedId } },
+        it('it should not be the same id', () => {
+          expect(duplicatedConversation.conversation.id).not.to.eql(
+            privateConversation.conversation.id
+          );
+        });
+
+        it('it should be the same user', () => {
+          expect(duplicatedConversation.user?.name).to.eql(publicConversation.user?.name);
         });
-        expect(status).to.be(200);
       });
 
-      it('allows the owner to duplicate their own public conversation', async () => {
-        const duplicateResponse = await observabilityAIAssistantAPIClient.editor({
-          endpoint:
-            'POST /internal/observability_ai_assistant/conversation/{conversationId}/duplicate',
-          params: {
-            path: { conversationId: publicConversationId },
-          },
+      describe('allows the owner to duplicate their own public conversation', () => {
+        let duplicatedConversation: Conversation;
+        before(async () => {
+          const duplicateResponse = await observabilityAIAssistantAPIClient.editor({
+            endpoint:
+              'POST /internal/observability_ai_assistant/conversation/{conversationId}/duplicate',
+            params: {
+              path: { conversationId: publicConversation.conversation.id },
+            },
+          });
+          expect(duplicateResponse.status).to.be(200);
+
+          duplicatedConversation = duplicateResponse.body;
+        });
+
+        after(async () => {
+          // cleanup
+          const { status } = await observabilityAIAssistantAPIClient.editor({
+            endpoint: 'DELETE /internal/observability_ai_assistant/conversation/{conversationId}',
+            params: { path: { conversationId: duplicatedConversation.conversation.id } },
+          });
+          expect(status).to.be(200);
         });
-        expect(duplicateResponse.status).to.be(200);
 
-        const duplicatedId = duplicateResponse.body.conversation.id;
-        expect(duplicatedId).not.to.eql(publicConversationId);
-        expect(duplicateResponse.body.user?.name).to.eql('elastic_editor');
+        it('it should not be the same id', () => {
+          expect(duplicatedConversation.conversation.id).not.to.eql(
+            publicConversation.conversation.id
+          );
+        });
 
-        const { status } = await observabilityAIAssistantAPIClient.editor({
-          endpoint: 'DELETE /internal/observability_ai_assistant/conversation/{conversationId}',
-          params: { path: { conversationId: duplicatedId } },
+        it('it should be the same user', () => {
+          expect(duplicatedConversation.user?.name).to.eql(publicConversation.user?.name);
         });
-        expect(status).to.be(200);
       });
 
-      it('allows another user to duplicate a public conversation, making them the new owner', async () => {
-        const duplicateResponse = await observabilityAIAssistantAPIClient.admin({
-          endpoint:
-            'POST /internal/observability_ai_assistant/conversation/{conversationId}/duplicate',
-          params: {
-            path: { conversationId: publicConversationId },
-          },
+      describe('allows another user to duplicate a public conversation, making them the new owner', () => {
+        let duplicatedConversation: Conversation;
+        before(async () => {
+          const duplicateResponse = await observabilityAIAssistantAPIClient.admin({
+            endpoint:
+              'POST /internal/observability_ai_assistant/conversation/{conversationId}/duplicate',
+            params: {
+              path: { conversationId: publicConversation.conversation.id },
+            },
+          });
+          expect(duplicateResponse.status).to.be(200);
+
+          duplicatedConversation = duplicateResponse.body;
         });
-        expect(duplicateResponse.status).to.be(200);
 
-        const duplicatedId = duplicateResponse.body.conversation.id;
-        expect(duplicatedId).not.to.eql(publicConversationId);
-        expect(duplicateResponse.body.user?.name).to.eql('elastic_admin');
+        after(async () => {
+          // cleanup
+          const { status } = await observabilityAIAssistantAPIClient.admin({
+            endpoint: 'DELETE /internal/observability_ai_assistant/conversation/{conversationId}',
+            params: { path: { conversationId: duplicatedConversation.conversation.id } },
+          });
+          expect(status).to.be(200);
+        });
 
-        const { status } = await observabilityAIAssistantAPIClient.admin({
-          endpoint: 'DELETE /internal/observability_ai_assistant/conversation/{conversationId}',
-          params: { path: { conversationId: duplicatedId } },
+        it('it should not be the same id', () => {
+          expect(duplicatedConversation.conversation.id).not.to.eql(
+            publicConversation.conversation.id
+          );
+        });
+
+        it('it should not be the same user', () => {
+          expect(duplicatedConversation.user?.name).to.not.eql(publicConversation.user?.name);
         });
-        expect(status).to.be(200);
       });
 
       it('does not allow another user to duplicate a private conversation', async () => {
@@ -527,7 +570,7 @@ export default function ApiTest({ getService }: DeploymentAgnosticFtrProviderCon
           endpoint:
             'POST /internal/observability_ai_assistant/conversation/{conversationId}/duplicate',
           params: {
-            path: { conversationId: privateConversationId },
+            path: { conversationId: privateConversation.conversation.id },
           },
         });
         expect(duplicateResponse.status).to.be(404);