diff --git a/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_agent_form.vue b/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_agent_form.vue
index 51e98e1716e099093165c361d27e11ae9969d707..0a6a957b56514aa2a01f25e9a6039b0c83d0f809 100644
--- a/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_agent_form.vue
+++ b/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_agent_form.vue
@@ -77,7 +77,11 @@ export default {
       toolFilter: '',
       formValues: {
         ...this.initialValues,
-        visibilityLevel: this.initialValues.public
+        visibilityLevel: (
+          this.initialValues && this.initialValues.public !== undefined
+            ? this.initialValues.public
+            : false
+        )
           ? VISIBILITY_LEVEL_PUBLIC
           : VISIBILITY_LEVEL_PRIVATE,
       },
@@ -97,6 +101,11 @@ export default {
     submitButtonText() {
       return this.isEditMode ? s__('AICatalog|Save changes') : s__('AICatalog|Create agent');
     },
+    getInitialPublicValue() {
+      return this.initialValues && this.initialValues.public !== undefined
+        ? this.initialValues.public
+        : false;
+    },
     fields() {
       const projectIdField = this.isEditMode
         ? {}
@@ -314,7 +323,7 @@ export default {
           <visibility-level-radio-group
             :id="id"
             :is-edit-mode="isEditMode"
-            :initial-value="initialValues.public"
+            :initial-value="getInitialPublicValue"
             :validation-state="validation.state"
             :value="value"
             :texts="$options.visibilityLevelTexts"
diff --git a/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_flow_form.vue b/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_flow_form.vue
index b1080be7a85bd98e911118a1fb5c89db499dd002..3550c0531492cd1ace7052d0cfdb24d5b8590017 100644
--- a/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_flow_form.vue
+++ b/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_flow_form.vue
@@ -67,9 +67,8 @@ export default {
     return {
       formValues: {
         ...this.initialValues,
-        visibilityLevel: this.initialValues.public
-          ? VISIBILITY_LEVEL_PUBLIC
-          : VISIBILITY_LEVEL_PRIVATE,
+        visibilityLevel:
+          this.initialValues?.public ?? false ? VISIBILITY_LEVEL_PUBLIC : VISIBILITY_LEVEL_PRIVATE,
       },
       formErrors: [],
     };
@@ -87,6 +86,11 @@ export default {
     submitButtonText() {
       return this.isEditMode ? s__('AICatalog|Save changes') : s__('AICatalog|Create flow');
     },
+    getInitialPublicValue() {
+      return this.initialValues && this.initialValues.public !== undefined
+        ? this.initialValues.public
+        : false;
+    },
     fields() {
       const projectIdField = this.isEditMode
         ? {}
@@ -217,7 +221,7 @@ export default {
           <visibility-level-radio-group
             :id="id"
             :is-edit-mode="isEditMode"
-            :initial-value="initialValues.public"
+            :initial-value="getInitialPublicValue"
             :validation-state="validation.state"
             :value="value"
             :texts="$options.visibilityLevelTexts"
diff --git a/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_item_drawer.vue b/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_item_drawer.vue
index 9c66f831b86773dea921ef88d280c0e750fba641..2ac1b1953fc97e46bb295e3480478a8a93788670 100644
--- a/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_item_drawer.vue
+++ b/ee/app/assets/javascripts/ai/catalog/components/ai_catalog_item_drawer.vue
@@ -1,9 +1,12 @@
 <script>
 import { GlButton, GlDrawer, GlLoadingIcon, GlTooltipDirective } from '@gitlab/ui';
+import { s__ } from '~/locale';
 import { getIdFromGraphQLId } from '~/graphql_shared/utils';
 import { DRAWER_Z_INDEX } from '~/lib/utils/constants';
 import { getContentWrapperHeight } from '~/lib/utils/dom_utils';
 import { AI_CATALOG_TYPE_AGENT, AI_CATALOG_TYPE_FLOW } from '../constants';
+import { AI_CATALOG_AGENTS_NEW_ROUTE, AI_CATALOG_FLOWS_NEW_ROUTE } from '../router/constants';
+import setItemToDuplicateMutation from '../graphql/mutations/set_item_to_duplicate.mutation.graphql';
 import AiCatalogAgentDetails from './ai_catalog_agent_details.vue';
 import AiCatalogFlowDetails from './ai_catalog_flow_details.vue';
 
@@ -56,6 +59,40 @@ export default {
     detailsComponent() {
       return DETAILS_COMPONENT_MAP[this.activeItem.itemType];
     },
+    duplicateRoute() {
+      switch (this.activeItem.itemType) {
+        case AI_CATALOG_TYPE_AGENT:
+          return AI_CATALOG_AGENTS_NEW_ROUTE;
+
+        case AI_CATALOG_TYPE_FLOW:
+          return AI_CATALOG_FLOWS_NEW_ROUTE;
+
+        default:
+          return null;
+      }
+    },
+  },
+  methods: {
+    async handleDuplicate() {
+      try {
+        await this.$apollo.mutate({
+          mutation: setItemToDuplicateMutation,
+          variables: {
+            item: {
+              id: this.activeItemId,
+              type: this.activeItem.itemType,
+              data: this.activeItem,
+            },
+          },
+        });
+
+        this.$router.push({ name: this.duplicateRoute });
+      } catch (error) {
+        // Handle error if needed
+        // eslint-disable-next-line no-console
+        console.error(s__('AICatalog|Failed to set item to duplicate:'), error);
+      }
+    },
   },
   DRAWER_Z_INDEX,
 };
@@ -74,16 +111,30 @@ export default {
         <h2 class="gl-m-0">
           {{ activeItem.name }}
         </h2>
-        <gl-button
-          v-if="canAdmin"
-          v-gl-tooltip
-          :to="{ name: editRoute, params: { id: activeItemId } }"
-          :title="s__('AICatalog|Edit')"
-          category="tertiary"
-          icon="pencil"
-          size="small"
-          :aria-label="s__('AICatalog|Edit')"
-        />
+        <div class="gl-flex gl-gap-x-2">
+          <gl-button
+            v-if="duplicateRoute"
+            v-gl-tooltip
+            category="tertiary"
+            icon="duplicate"
+            size="small"
+            :title="s__('AICatalog|Duplicate')"
+            :aria-label="s__('AICatalog|Duplicate')"
+            data-testid="ai-catalog-item-drawer-duplicate-button"
+            @click="handleDuplicate"
+          />
+          <gl-button
+            v-if="canAdmin && editRoute"
+            v-gl-tooltip
+            :to="{ name: editRoute, params: { id: activeItemId } }"
+            :title="s__('AICatalog|Edit')"
+            category="tertiary"
+            icon="pencil"
+            size="small"
+            :aria-label="s__('AICatalog|Edit')"
+            data-testid="ai-catalog-item-drawer-edit-button"
+          />
+        </div>
       </div>
     </template>
     <template #default>
diff --git a/ee/app/assets/javascripts/ai/catalog/graphql/mutations/set_item_to_duplicate.mutation.graphql b/ee/app/assets/javascripts/ai/catalog/graphql/mutations/set_item_to_duplicate.mutation.graphql
new file mode 100644
index 0000000000000000000000000000000000000000..1f52fbc320b70df681688ca44d12d5b4f132fa1f
--- /dev/null
+++ b/ee/app/assets/javascripts/ai/catalog/graphql/mutations/set_item_to_duplicate.mutation.graphql
@@ -0,0 +1,3 @@
+mutation SetItemToDuplicate($item: ItemToDuplicateInput!) {
+  setItemToDuplicate(item: $item) @client
+}
diff --git a/ee/app/assets/javascripts/ai/catalog/graphql/queries/item_to_duplicate.query.graphql b/ee/app/assets/javascripts/ai/catalog/graphql/queries/item_to_duplicate.query.graphql
new file mode 100644
index 0000000000000000000000000000000000000000..078306d9e74aec282fb021141a43af2489fd6b29
--- /dev/null
+++ b/ee/app/assets/javascripts/ai/catalog/graphql/queries/item_to_duplicate.query.graphql
@@ -0,0 +1,7 @@
+query ItemToDuplicate {
+  itemToDuplicate @client {
+    id
+    type
+    data
+  }
+}
diff --git a/ee/app/assets/javascripts/ai/catalog/graphql/typedefs.graphql b/ee/app/assets/javascripts/ai/catalog/graphql/typedefs.graphql
new file mode 100644
index 0000000000000000000000000000000000000000..e283fe3436c621a231f5e19338e245a94b7c391a
--- /dev/null
+++ b/ee/app/assets/javascripts/ai/catalog/graphql/typedefs.graphql
@@ -0,0 +1,21 @@
+type Query {
+  itemToDuplicate: ItemToDuplicate
+}
+
+type Mutation {
+  setItemToDuplicate(item: ItemToDuplicateInput!): ItemToDuplicate
+}
+
+type ItemToDuplicate {
+  id: String
+  type: String
+  data: JSON
+}
+
+input ItemToDuplicateInput {
+  id: String
+  type: String
+  data: JSON
+}
+
+scalar JSON
diff --git a/ee/app/assets/javascripts/ai/catalog/index.js b/ee/app/assets/javascripts/ai/catalog/index.js
index 80f369e71f943c600eb0d19446414781e0541e6a..c0f728a364377ca1da018c7249139cc39238aac6 100644
--- a/ee/app/assets/javascripts/ai/catalog/index.js
+++ b/ee/app/assets/javascripts/ai/catalog/index.js
@@ -4,6 +4,8 @@ import { GlToast } from '@gitlab/ui';
 import createDefaultClient from '~/lib/graphql';
 import { injectVueAppBreadcrumbs } from '~/lib/utils/breadcrumbs';
 import AiCatalogBreadcrumbs from './router/ai_catalog_breadcrumbs.vue';
+import typeDefs from './graphql/typedefs.graphql';
+import itemToDuplicateQuery from './graphql/queries/item_to_duplicate.query.graphql';
 
 import AiCatalogApp from './ai_catalog_app.vue';
 import { createRouter } from './router';
@@ -22,8 +24,36 @@ export const initAiCatalog = (selector = '#js-ai-catalog') => {
   Vue.use(GlToast);
 
   const router = createRouter(aiCatalogIndexPath);
+
+  const resolvers = {
+    Mutation: {
+      setItemToDuplicate(_, { item }, { cache }) {
+        cache.writeQuery({
+          query: itemToDuplicateQuery,
+          data: { itemToDuplicate: item },
+        });
+        return item;
+      },
+    },
+  };
+
   const apolloProvider = new VueApollo({
-    defaultClient: createDefaultClient(),
+    defaultClient: createDefaultClient(resolvers, {
+      typeDefs,
+      cacheConfig: {
+        typePolicies: {
+          Query: {
+            fields: {
+              itemToDuplicate: {
+                read(currentState) {
+                  return currentState || null;
+                },
+              },
+            },
+          },
+        },
+      },
+    }),
   });
 
   injectVueAppBreadcrumbs(router, AiCatalogBreadcrumbs);
diff --git a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents.vue b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents.vue
index 7d01908eda9f7a1d764adc61976bba97cc051623..47640305473fe448bfe7ae45c87bf8766e4d541e 100644
--- a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents.vue
+++ b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents.vue
@@ -13,12 +13,14 @@ import { TYPENAME_AI_CATALOG_ITEM } from 'ee/graphql_shared/constants';
 import aiCatalogAgentsQuery from '../graphql/queries/ai_catalog_agents.query.graphql';
 import aiCatalogAgentQuery from '../graphql/queries/ai_catalog_agent.query.graphql';
 import deleteAiCatalogAgentMutation from '../graphql/mutations/delete_ai_catalog_agent.mutation.graphql';
+import setItemToDuplicateMutation from '../graphql/mutations/set_item_to_duplicate.mutation.graphql';
 import AiCatalogListHeader from '../components/ai_catalog_list_header.vue';
 import AiCatalogList from '../components/ai_catalog_list.vue';
 import AiCatalogItemDrawer from '../components/ai_catalog_item_drawer.vue';
 import {
   AI_CATALOG_AGENTS_EDIT_ROUTE,
   AI_CATALOG_AGENTS_RUN_ROUTE,
+  AI_CATALOG_AGENTS_NEW_ROUTE,
   AI_CATALOG_SHOW_QUERY_PARAM,
 } from '../router/constants';
 
@@ -97,6 +99,11 @@ export default {
             },
             icon: 'rocket-launch',
           },
+          {
+            text: s__('AICatalog|Duplicate'),
+            action: () => this.handleDuplicate(itemId),
+            icon: 'duplicate',
+          },
           {
             text: s__('AICatalog|Edit'),
             to: {
@@ -169,6 +176,34 @@ export default {
         last: null,
       });
     },
+    async handleDuplicate(itemId) {
+      try {
+        // Find the agent data from the list
+        const agent = this.aiCatalogAgents.find(
+          (n) => this.formatId(n.id).toString() === String(itemId),
+        );
+
+        if (!agent) {
+          throw new Error(s__('AICatalog|Agent not found'));
+        }
+
+        await this.$apollo.mutate({
+          mutation: setItemToDuplicateMutation,
+          variables: {
+            item: {
+              id: itemId,
+              type: 'AGENT',
+              data: agent,
+            },
+          },
+        });
+
+        this.$router.push({ name: AI_CATALOG_AGENTS_NEW_ROUTE });
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error(s__('AICatalog|Failed to set item to duplicate:'), error);
+      }
+    },
     handlePrevPage() {
       this.$apollo.queries.aiCatalogAgents.refetch({
         ...this.$apollo.queries.aiCatalogAgents.variables,
diff --git a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents_duplicate.vue b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents_duplicate.vue
new file mode 100644
index 0000000000000000000000000000000000000000..78a610740acc03167a61db3014d7bbd4587d9ec4
--- /dev/null
+++ b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents_duplicate.vue
@@ -0,0 +1,120 @@
+<script>
+import { s__ } from '~/locale';
+import { getIdFromGraphQLId, convertToGraphQLId } from '~/graphql_shared/utils';
+import PageHeading from '~/vue_shared/components/page_heading.vue';
+import * as Sentry from '~/sentry/sentry_browser_wrapper';
+import { TYPENAME_AI_CATALOG_ITEM } from 'ee/graphql_shared/constants';
+import createAiCatalogAgent from '../graphql/mutations/create_ai_catalog_agent.mutation.graphql';
+import aiCatalogAgentQuery from '../graphql/queries/ai_catalog_agent.query.graphql';
+import { AI_CATALOG_AGENTS_ROUTE, AI_CATALOG_SHOW_QUERY_PARAM } from '../router/constants';
+import AiCatalogAgentForm from '../components/ai_catalog_agent_form.vue';
+
+export default {
+  name: 'AiCatalogAgentsDuplicate',
+  components: {
+    AiCatalogAgentForm,
+    PageHeading,
+  },
+  data() {
+    return {
+      errorMessages: [],
+      isSubmitting: false,
+      originalAgent: {},
+    };
+  },
+  computed: {
+    agentId() {
+      return this.$route.params.id;
+    },
+    initialValues() {
+      if (!this.originalAgent || !this.originalAgent.id) {
+        return {};
+      }
+
+      return {
+        projectId: this.originalAgent.project?.id,
+        name: `${this.originalAgent.name} ${s__('AICatalog|(Copy)')}`,
+        description: this.originalAgent.description,
+        systemPrompt: this.originalAgent.latestVersion?.systemPrompt || '',
+        userPrompt: this.originalAgent.latestVersion?.userPrompt || '',
+        public: this.originalAgent.public,
+        tools: this.originalAgent.latestVersion?.tools?.nodes.map((t) => t.id) || [],
+      };
+    },
+  },
+  apollo: {
+    originalAgent: {
+      query: aiCatalogAgentQuery,
+      variables() {
+        return { id: convertToGraphQLId(TYPENAME_AI_CATALOG_ITEM, this.agentId) };
+      },
+      update(data) {
+        return data?.aiCatalogItem || {};
+      },
+      error(error) {
+        Sentry.captureException(error);
+      },
+    },
+  },
+  methods: {
+    async handleSubmit(input) {
+      this.isSubmitting = true;
+      this.resetErrorMessages();
+      try {
+        const { data } = await this.$apollo.mutate({
+          mutation: createAiCatalogAgent,
+          variables: {
+            input,
+          },
+        });
+
+        if (data) {
+          const { errors } = data.aiCatalogAgentCreate;
+          if (errors.length > 0) {
+            this.errorMessages = errors;
+            return;
+          }
+
+          const newAgentId = getIdFromGraphQLId(data.aiCatalogAgentCreate.item.id);
+          this.$toast.show(s__('AICatalog|Agent created successfully.'));
+          this.$router.push({
+            name: AI_CATALOG_AGENTS_ROUTE,
+            query: { [AI_CATALOG_SHOW_QUERY_PARAM]: newAgentId },
+          });
+        }
+      } catch (error) {
+        this.errorMessages = [s__('AICatalog|The agent could not be added. Try again.')];
+        Sentry.captureException(error);
+      } finally {
+        this.isSubmitting = false;
+      }
+    },
+    resetErrorMessages() {
+      this.errorMessages = [];
+    },
+  },
+};
+</script>
+
+<template>
+  <div>
+    <page-heading :heading="s__('AICatalog|Duplicate agent')">
+      <template #description>
+        <div class="gl-border-b gl-pb-3">
+          {{
+            s__('AICatalog|Create a copy of this agent with all its settings and configuration.')
+          }}
+        </div>
+      </template>
+    </page-heading>
+
+    <ai-catalog-agent-form
+      mode="create"
+      :is-loading="isSubmitting"
+      :error-messages="errorMessages"
+      :initial-values="initialValues"
+      @dismiss-errors="resetErrorMessages"
+      @submit="handleSubmit"
+    />
+  </div>
+</template>
diff --git a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents_new.vue b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents_new.vue
index bc99d19b81e6dec28242d6db2b87c3b813f86605..4170d4689906794ea73576e01f6e9c7dae57d8b7 100644
--- a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents_new.vue
+++ b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_agents_new.vue
@@ -4,6 +4,8 @@ import { getIdFromGraphQLId } from '~/graphql_shared/utils';
 import PageHeading from '~/vue_shared/components/page_heading.vue';
 import * as Sentry from '~/sentry/sentry_browser_wrapper';
 import createAiCatalogAgent from '../graphql/mutations/create_ai_catalog_agent.mutation.graphql';
+import setItemToDuplicateMutation from '../graphql/mutations/set_item_to_duplicate.mutation.graphql';
+import itemToDuplicateQuery from '../graphql/queries/item_to_duplicate.query.graphql';
 import { AI_CATALOG_AGENTS_ROUTE, AI_CATALOG_SHOW_QUERY_PARAM } from '../router/constants';
 import AiCatalogAgentForm from '../components/ai_catalog_agent_form.vue';
 
@@ -17,8 +19,67 @@ export default {
     return {
       errorMessages: [],
       isSubmitting: false,
+      itemToDuplicate: null,
     };
   },
+  apollo: {
+    itemToDuplicate: {
+      query: itemToDuplicateQuery,
+      update(data) {
+        return data?.itemToDuplicate || null;
+      },
+    },
+  },
+  computed: {
+    initialValues() {
+      // First check if we have cached data from duplicate action
+      if (this.itemToDuplicate && this.itemToDuplicate.type === 'AGENT') {
+        const itemData = this.itemToDuplicate.data;
+        const values = {
+          projectId: itemData.project?.id || null,
+          name: `${itemData.name} ${s__('AICatalog|(Copy)')}`,
+          description: itemData.description || '',
+          systemPrompt: itemData.latestVersion?.systemPrompt || '',
+          userPrompt: itemData.latestVersion?.userPrompt || '',
+          public: Boolean(itemData.public ?? false),
+          tools: itemData.latestVersion?.tools?.nodes.map((t) => t.id) || [],
+        };
+
+        // Clear the cached data after using it
+        this.clearDuplicateData();
+        return values;
+      }
+
+      // Fallback to query params (for backward compatibility)
+      const { query } = this.$route;
+      if (!query.name) {
+        return {
+          projectId: null,
+          name: '',
+          description: '',
+          systemPrompt: '',
+          userPrompt: '',
+          public: false,
+          tools: [],
+        };
+      }
+
+      const values = {
+        projectId: query.projectId || null,
+        name: query.name || '',
+        description: query.description || '',
+        systemPrompt: query.systemPrompt || '',
+        userPrompt: query.userPrompt || '',
+        public: query.public === 'true',
+        tools: query.tools ? JSON.parse(query.tools) : [],
+      };
+
+      // Clear query params from the URL
+      this.$router.replace({ query: {} });
+
+      return values;
+    },
+  },
   methods: {
     async handleSubmit(input) {
       this.isSubmitting = true;
@@ -55,6 +116,12 @@ export default {
     resetErrorMessages() {
       this.errorMessages = [];
     },
+    clearDuplicateData() {
+      this.$apollo.mutate({
+        mutation: setItemToDuplicateMutation,
+        variables: { item: null },
+      });
+    },
   },
 };
 </script>
@@ -77,6 +144,7 @@ export default {
       mode="create"
       :is-loading="isSubmitting"
       :error-messages="errorMessages"
+      :initial-values="initialValues"
       @dismiss-errors="resetErrorMessages"
       @submit="handleSubmit"
     />
diff --git a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows.vue b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows.vue
index cf1e97d2bda6270b99d5230e455be4511985eff8..ac22cc819fe90f588af360d7637cbb3e8a0651b7 100644
--- a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows.vue
+++ b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows.vue
@@ -13,12 +13,17 @@ import aiCatalogFlowsQuery from '../graphql/queries/ai_catalog_flows.query.graph
 import aiCatalogFlowQuery from '../graphql/queries/ai_catalog_flow.query.graphql';
 import deleteAiCatalogFlowMutation from '../graphql/mutations/delete_ai_catalog_flow.mutation.graphql';
 import createAiCatalogItemConsumer from '../graphql/mutations/create_ai_catalog_item_consumer.mutation.graphql';
+import setItemToDuplicateMutation from '../graphql/mutations/set_item_to_duplicate.mutation.graphql';
 import AiCatalogListHeader from '../components/ai_catalog_list_header.vue';
 import AiCatalogList from '../components/ai_catalog_list.vue';
 import AiCatalogItemDrawer from '../components/ai_catalog_item_drawer.vue';
 import AiCatalogItemConsumerModal from '../components/ai_catalog_item_consumer_modal.vue';
 import ErrorsAlert from '../components/errors_alert.vue';
-import { AI_CATALOG_SHOW_QUERY_PARAM, AI_CATALOG_FLOWS_EDIT_ROUTE } from '../router/constants';
+import {
+  AI_CATALOG_SHOW_QUERY_PARAM,
+  AI_CATALOG_FLOWS_EDIT_ROUTE,
+  AI_CATALOG_FLOWS_NEW_ROUTE,
+} from '../router/constants';
 
 export default {
   name: 'AiCatalogFlows',
@@ -94,6 +99,11 @@ export default {
             action: () => this.handleAiCatalogFlowToBeAdded(itemId),
             icon: 'plus',
           },
+          {
+            text: s__('AICatalog|Duplicate'),
+            action: () => this.handleDuplicate(itemId),
+            icon: 'duplicate',
+          },
           {
             text: s__('AICatalog|Edit'),
             to: {
@@ -233,6 +243,34 @@ export default {
         last: null,
       });
     },
+    async handleDuplicate(itemId) {
+      try {
+        // Find the flow data from the list
+        const flow = this.aiCatalogFlows.find(
+          (n) => this.formatId(n.id).toString() === String(itemId),
+        );
+
+        if (!flow) {
+          throw new Error(s__('AICatalog|Flow not found'));
+        }
+
+        await this.$apollo.mutate({
+          mutation: setItemToDuplicateMutation,
+          variables: {
+            item: {
+              id: itemId,
+              type: 'FLOW',
+              data: flow,
+            },
+          },
+        });
+
+        this.$router.push({ name: AI_CATALOG_FLOWS_NEW_ROUTE });
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error(s__('AICatalog|Failed to set item to duplicate:'), error);
+      }
+    },
     handlePrevPage() {
       this.$apollo.queries.aiCatalogFlows.refetch({
         ...this.$apollo.queries.aiCatalogFlows.variables,
diff --git a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows_duplicate.vue b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows_duplicate.vue
new file mode 100644
index 0000000000000000000000000000000000000000..76a3838228d2afc49f06df231f1c4cfc7124525b
--- /dev/null
+++ b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows_duplicate.vue
@@ -0,0 +1,120 @@
+<script>
+import { s__ } from '~/locale';
+import { getIdFromGraphQLId, convertToGraphQLId } from '~/graphql_shared/utils';
+import PageHeading from '~/vue_shared/components/page_heading.vue';
+import * as Sentry from '~/sentry/sentry_browser_wrapper';
+import { TYPENAME_AI_CATALOG_ITEM } from 'ee/graphql_shared/constants';
+import createAiCatalogFlow from '../graphql/mutations/create_ai_catalog_flow.mutation.graphql';
+import aiCatalogFlowQuery from '../graphql/queries/ai_catalog_flow.query.graphql';
+import { AI_CATALOG_FLOWS_ROUTE, AI_CATALOG_SHOW_QUERY_PARAM } from '../router/constants';
+import AiCatalogFlowForm from '../components/ai_catalog_flow_form.vue';
+
+export default {
+  name: 'AiCatalogFlowsDuplicate',
+  components: {
+    AiCatalogFlowForm,
+    PageHeading,
+  },
+  data() {
+    return {
+      errorMessages: [],
+      isSubmitting: false,
+      originalFlow: {},
+    };
+  },
+  computed: {
+    flowId() {
+      return this.$route.params.id;
+    },
+    initialValues() {
+      if (!this.originalFlow || !this.originalFlow.id) {
+        return {};
+      }
+
+      return {
+        projectId: this.originalFlow.project?.id,
+        name: `${this.originalFlow.name} ${s__('AICatalog|(Copy)')}`,
+        description: this.originalFlow.description,
+        public: this.originalFlow.public,
+        steps:
+          this.originalFlow.latestVersion?.steps?.nodes.map((s) => ({
+            id: s.agent.id,
+            name: s.agent.name,
+          })) || [],
+      };
+    },
+  },
+  apollo: {
+    originalFlow: {
+      query: aiCatalogFlowQuery,
+      variables() {
+        return { id: convertToGraphQLId(TYPENAME_AI_CATALOG_ITEM, this.flowId) };
+      },
+      update(data) {
+        return data?.aiCatalogItem || {};
+      },
+      error(error) {
+        Sentry.captureException(error);
+      },
+    },
+  },
+  methods: {
+    async handleSubmit(input) {
+      this.isSubmitting = true;
+      this.resetErrorMessages();
+      try {
+        const { data } = await this.$apollo.mutate({
+          mutation: createAiCatalogFlow,
+          variables: {
+            input,
+          },
+        });
+
+        if (data) {
+          const { errors } = data.aiCatalogFlowCreate;
+          if (errors.length > 0) {
+            this.errorMessages = errors;
+            return;
+          }
+
+          const newFlowId = getIdFromGraphQLId(data.aiCatalogFlowCreate.item.id);
+          this.$toast.show(s__('AICatalog|Flow created successfully.'));
+          this.$router.push({
+            name: AI_CATALOG_FLOWS_ROUTE,
+            query: { [AI_CATALOG_SHOW_QUERY_PARAM]: newFlowId },
+          });
+        }
+      } catch (error) {
+        this.errorMessages = [s__('AICatalog|The flow could not be added. Try again.')];
+        Sentry.captureException(error);
+      } finally {
+        this.isSubmitting = false;
+      }
+    },
+    resetErrorMessages() {
+      this.errorMessages = [];
+    },
+  },
+};
+</script>
+
+<template>
+  <div>
+    <page-heading :heading="s__('AICatalog|Duplicate flow')">
+      <template #description>
+        <div class="gl-border-b gl-pb-3">
+          {{ s__('AICatalog|Create a copy of this flow with all its settings and configuration.') }}
+        </div>
+      </template>
+    </page-heading>
+
+    <ai-catalog-flow-form
+      mode="create"
+      :is-loading="isSubmitting"
+      :error-messages="errorMessages"
+      :initial-values="initialValues"
+      @dismiss-errors="resetErrorMessages"
+      @submit="handleSubmit"
+    />
+  </div>
+</template>
diff --git a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows_new.vue b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows_new.vue
index bef9beae654fadfa5db6936bad360583ffef6e5e..2a0762fb4d9fea5ae833970a9fcf98190ae3e0f1 100644
--- a/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows_new.vue
+++ b/ee/app/assets/javascripts/ai/catalog/pages/ai_catalog_flows_new.vue
@@ -4,6 +4,8 @@ import { getIdFromGraphQLId } from '~/graphql_shared/utils';
 import PageHeading from '~/vue_shared/components/page_heading.vue';
 import * as Sentry from '~/sentry/sentry_browser_wrapper';
 import createAiCatalogFlow from '../graphql/mutations/create_ai_catalog_flow.mutation.graphql';
+import setItemToDuplicateMutation from '../graphql/mutations/set_item_to_duplicate.mutation.graphql';
+import itemToDuplicateQuery from '../graphql/queries/item_to_duplicate.query.graphql';
 import { AI_CATALOG_FLOWS_ROUTE, AI_CATALOG_SHOW_QUERY_PARAM } from '../router/constants';
 import AiCatalogFlowForm from '../components/ai_catalog_flow_form.vue';
 
@@ -17,8 +19,67 @@ export default {
     return {
       errorMessages: [],
       isSubmitting: false,
+      itemToDuplicate: null,
     };
   },
+  apollo: {
+    itemToDuplicate: {
+      query: itemToDuplicateQuery,
+      update(data) {
+        return data?.itemToDuplicate || null;
+      },
+    },
+  },
+  computed: {
+    initialValues() {
+      // First check if we have cached data from duplicate action
+      if (this.itemToDuplicate && this.itemToDuplicate.type === 'FLOW') {
+        const itemData = this.itemToDuplicate.data;
+        const values = {
+          projectId: itemData.project?.id || null,
+          name: `${itemData.name} ${s__('AICatalog|(Copy)')}`,
+          description: itemData.description || '',
+          public: Boolean(itemData.public ?? false),
+          steps:
+            itemData.latestVersion?.steps?.nodes.map((s) => ({
+              id: s.agent.id,
+              name: s.agent.name,
+            })) || [],
+        };
+
+        // Clear the cached data after using it
+        this.clearDuplicateData();
+        return values;
+      }
+
+      // Fallback to query params (for backward compatibility)
+      const { query } = this.$route;
+      if (!query.name) {
+        return {
+          projectId: null,
+          name: '',
+          description: '',
+          systemPrompt: '',
+          userPrompt: '',
+          public: false,
+          steps: [],
+        };
+      }
+
+      const values = {
+        projectId: query.projectId || null,
+        name: query.name || '',
+        description: query.description || '',
+        public: query.public === 'true',
+        steps: query.steps ? JSON.parse(query.steps) : [],
+      };
+
+      // Clear query params from the URL
+      this.$router.replace({ query: {} });
+
+      return values;
+    },
+  },
   methods: {
     async handleSubmit(input) {
       this.isSubmitting = true;
@@ -55,6 +116,12 @@ export default {
     resetErrorMessages() {
       this.errorMessages = [];
     },
+    clearDuplicateData() {
+      this.$apollo.mutate({
+        mutation: setItemToDuplicateMutation,
+        variables: { item: null },
+      });
+    },
   },
 };
 </script>
@@ -73,6 +140,7 @@ export default {
       mode="create"
       :is-loading="isSubmitting"
       :error-messages="errorMessages"
+      :initial-values="initialValues"
       @dismiss-errors="resetErrorMessages"
       @submit="handleSubmit"
     />
diff --git a/ee/app/assets/javascripts/ai/catalog/router/constants.js b/ee/app/assets/javascripts/ai/catalog/router/constants.js
index 94760baa70faf33135e1f42f84f8544721b38582..75a69e86fce1098fa841a73a7ee27ba285214e5b 100644
--- a/ee/app/assets/javascripts/ai/catalog/router/constants.js
+++ b/ee/app/assets/javascripts/ai/catalog/router/constants.js
@@ -3,8 +3,10 @@ export const AI_CATALOG_AGENTS_ROUTE = '/agents';
 export const AI_CATALOG_AGENTS_EDIT_ROUTE = '/agents/:id/edit';
 export const AI_CATALOG_AGENTS_RUN_ROUTE = '/agents/:id/run';
 export const AI_CATALOG_AGENTS_NEW_ROUTE = '/agents/new';
+export const AI_CATALOG_AGENTS_DUPLICATE_ROUTE = '/agents/:id/duplicate';
 export const AI_CATALOG_FLOWS_ROUTE = '/flows';
 export const AI_CATALOG_FLOWS_EDIT_ROUTE = '/flows/:id/edit';
 export const AI_CATALOG_FLOWS_NEW_ROUTE = '/flows/new';
+export const AI_CATALOG_FLOWS_DUPLICATE_ROUTE = '/flows/:id/duplicate';
 
 export const AI_CATALOG_SHOW_QUERY_PARAM = 'show';
diff --git a/ee/app/assets/javascripts/ai/catalog/router/index.js b/ee/app/assets/javascripts/ai/catalog/router/index.js
index 13647e9a062a9ae0e19a7ede1a33cbe785bf5884..4e71a60f45b0ce80eb96888bf4e67f66d292e6dc 100644
--- a/ee/app/assets/javascripts/ai/catalog/router/index.js
+++ b/ee/app/assets/javascripts/ai/catalog/router/index.js
@@ -7,19 +7,23 @@ import AiCatalogAgent from '../pages/ai_catalog_agent.vue';
 import AiCatalogAgentsEdit from '../pages/ai_catalog_agents_edit.vue';
 import AiCatalogAgentsRun from '../pages/ai_catalog_agents_run.vue';
 import AiCatalogAgentsNew from '../pages/ai_catalog_agents_new.vue';
+import AiCatalogAgentsDuplicate from '../pages/ai_catalog_agents_duplicate.vue';
 import AiCatalogFlow from '../pages/ai_catalog_flow.vue';
 import AiCatalogFlows from '../pages/ai_catalog_flows.vue';
 import AiCatalogFlowsEdit from '../pages/ai_catalog_flows_edit.vue';
 import AiCatalogFlowsNew from '../pages/ai_catalog_flows_new.vue';
+import AiCatalogFlowsDuplicate from '../pages/ai_catalog_flows_duplicate.vue';
 import {
   AI_CATALOG_INDEX_ROUTE,
   AI_CATALOG_AGENTS_ROUTE,
   AI_CATALOG_AGENTS_EDIT_ROUTE,
   AI_CATALOG_AGENTS_RUN_ROUTE,
   AI_CATALOG_AGENTS_NEW_ROUTE,
+  AI_CATALOG_AGENTS_DUPLICATE_ROUTE,
   AI_CATALOG_FLOWS_ROUTE,
   AI_CATALOG_FLOWS_NEW_ROUTE,
   AI_CATALOG_FLOWS_EDIT_ROUTE,
+  AI_CATALOG_FLOWS_DUPLICATE_ROUTE,
   AI_CATALOG_SHOW_QUERY_PARAM,
 } from './constants';
 
@@ -84,6 +88,14 @@ export const createRouter = (base) => {
                   text: s__('AICatalog|Run agent'),
                 },
               },
+              {
+                name: AI_CATALOG_AGENTS_DUPLICATE_ROUTE,
+                path: 'duplicate',
+                component: AiCatalogAgentsDuplicate,
+                meta: {
+                  text: s__('AICatalog|Duplicate agent'),
+                },
+              },
             ],
           },
         ],
@@ -129,6 +141,14 @@ export const createRouter = (base) => {
                   text: s__('AICatalog|Edit flow'),
                 },
               },
+              {
+                name: AI_CATALOG_FLOWS_DUPLICATE_ROUTE,
+                path: 'duplicate',
+                component: AiCatalogFlowsDuplicate,
+                meta: {
+                  text: s__('AICatalog|Duplicate flow'),
+                },
+              },
             ],
           },
         ],
diff --git a/ee/spec/frontend/ai/catalog/components/ai_catalog_item_drawer_spec.js b/ee/spec/frontend/ai/catalog/components/ai_catalog_item_drawer_spec.js
index 39a082fbd1f92218a01667d095aa461b474cd2f5..72e09dd794cac4cfeb984ededa459d3cfad234f8 100644
--- a/ee/spec/frontend/ai/catalog/components/ai_catalog_item_drawer_spec.js
+++ b/ee/spec/frontend/ai/catalog/components/ai_catalog_item_drawer_spec.js
@@ -1,5 +1,8 @@
-import { GlButton, GlDrawer, GlLoadingIcon } from '@gitlab/ui';
+import Vue, { nextTick } from 'vue';
+import VueApollo from 'vue-apollo';
+import { GlDrawer, GlLoadingIcon } from '@gitlab/ui';
 import { shallowMountExtended } from 'helpers/vue_test_utils_helper';
+import createMockApollo from 'helpers/mock_apollo_helper';
 import AiCatalogItemDrawer from 'ee/ai/catalog/components/ai_catalog_item_drawer.vue';
 import AiCatalogAgentDetails from 'ee/ai/catalog/components/ai_catalog_agent_details.vue';
 import AiCatalogFlowDetails from 'ee/ai/catalog/components/ai_catalog_flow_details.vue';
@@ -7,8 +10,13 @@ import { AI_CATALOG_AGENTS_EDIT_ROUTE } from 'ee/ai/catalog/router/constants';
 
 import { mockAgent, mockFlow } from '../mock_data';
 
+Vue.use(VueApollo);
+
 describe('CatalogItemDrawer', () => {
   let wrapper;
+  let setItemToDuplicateMock;
+  let apolloProvider;
+  let mockRouter;
 
   const defaultProps = {
     isOpen: false,
@@ -16,18 +24,33 @@ describe('CatalogItemDrawer', () => {
   };
 
   const createComponent = ({ props = {} } = {}) => {
+    setItemToDuplicateMock = jest.fn().mockResolvedValue({ data: { setItemToDuplicate: null } });
+    mockRouter = {
+      push: jest.fn(),
+    };
+
+    apolloProvider = createMockApollo([]);
+
+    // Mock the $apollo.mutate method directly
+    apolloProvider.clients.defaultClient.mutate = setItemToDuplicateMock;
+
     wrapper = shallowMountExtended(AiCatalogItemDrawer, {
+      apolloProvider,
       propsData: {
         ...defaultProps,
         ...props,
       },
+      mocks: {
+        $router: mockRouter,
+      },
     });
   };
 
   const findDrawer = () => wrapper.findComponent(GlDrawer);
-  const findDrawerContent = () => wrapper.findByTestId('ai-catalog-item-drawer-content');
+  const findDrawerContent = () => wrapper.find('[data-testid="ai-catalog-item-drawer-content"]');
   const findLoadingIcon = () => wrapper.findComponent(GlLoadingIcon);
-  const findEditButton = () => wrapper.findComponent(GlButton);
+  const findEditButton = () => wrapper.findByTestId('ai-catalog-item-drawer-edit-button');
+  const findDuplicateButton = () => wrapper.findByTestId('ai-catalog-item-drawer-duplicate-button');
 
   it('renders drawer as closed', () => {
     createComponent();
@@ -90,48 +113,56 @@ describe('CatalogItemDrawer', () => {
     });
 
     it('renders description', () => {
-      expect(findDrawerContent().html()).toContain(mockFlow.description);
+      expect(findDrawerContent().text()).toContain(mockFlow.description);
     });
 
     it('does not render loading icon', () => {
       expect(findLoadingIcon().exists()).toBe(false);
     });
 
-    it('renders loading icon when isItemDetailsLoading is true', async () => {
-      await createComponent({
+    it('renders loading icon when isItemDetailsLoading is true', () => {
+      createComponent({
         props: {
           isOpen: true,
-          isItemDetailsLoading: true,
           activeItem: mockFlow,
+          isItemDetailsLoading: true,
         },
       });
 
       expect(findLoadingIcon().exists()).toBe(true);
     });
 
-    it.each`
-      activeItem   | component
-      ${mockAgent} | ${AiCatalogAgentDetails}
-      ${mockFlow}  | ${AiCatalogFlowDetails}
-    `(
-      'renders correct component when activeItem is $activeItem.itemType',
-      ({ activeItem, component }) => {
-        createComponent({
-          props: {
-            isOpen: true,
-            activeItem,
-          },
-        });
+    it('renders correct component when activeItem is AGENT', () => {
+      createComponent({
+        props: {
+          isOpen: true,
+          activeItem: mockAgent,
+        },
+      });
 
-        expect(wrapper.findComponent(component).props('item')).toEqual(activeItem);
-      },
-    );
+      expect(wrapper.findComponent(AiCatalogAgentDetails).exists()).toBe(true);
+    });
+
+    it('renders correct component when activeItem is FLOW', () => {
+      createComponent({
+        props: {
+          isOpen: true,
+          activeItem: mockFlow,
+        },
+      });
+
+      expect(wrapper.findComponent(AiCatalogFlowDetails).exists()).toBe(true);
+    });
   });
 
   describe('without editRoute', () => {
     it('does not link to edit page', () => {
       createComponent({
-        props: { isOpen: true, editRoute: null },
+        props: {
+          isOpen: true,
+          activeItem: mockAgent,
+          editRoute: null,
+        },
       });
 
       expect(findEditButton().exists()).toBe(false);
@@ -141,7 +172,10 @@ describe('CatalogItemDrawer', () => {
   describe('closing the drawer', () => {
     it('emits `close` event when drawer is closed', () => {
       createComponent({
-        props: { isOpen: true },
+        props: {
+          isOpen: true,
+          activeItem: mockAgent,
+        },
       });
 
       findDrawer().vm.$emit('close');
@@ -149,4 +183,97 @@ describe('CatalogItemDrawer', () => {
       expect(wrapper.emitted('close')).toHaveLength(1);
     });
   });
+
+  describe('duplicate functionality', () => {
+    beforeEach(() => {
+      createComponent({
+        props: {
+          isOpen: true,
+          activeItem: mockAgent,
+        },
+      });
+    });
+
+    it('renders duplicate button for agents', () => {
+      const button = findDuplicateButton();
+      expect(button.exists()).toBe(true);
+      expect(button.props('icon')).toBe('duplicate');
+      expect(button.attributes('title')).toBe('Duplicate');
+    });
+
+    it('renders duplicate button for flows', () => {
+      createComponent({
+        props: {
+          isOpen: true,
+          activeItem: mockFlow,
+        },
+      });
+
+      const button = findDuplicateButton();
+      expect(button.exists()).toBe(true);
+      expect(button.props('icon')).toBe('duplicate');
+      expect(button.attributes('title')).toBe('Duplicate');
+    });
+
+    it('calls setItemToDuplicate mutation when duplicate button is clicked', async () => {
+      const button = findDuplicateButton();
+
+      await button.vm.$emit('click');
+
+      expect(setItemToDuplicateMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          mutation: expect.any(Object),
+          variables: {
+            item: {
+              id: 1,
+              type: 'AGENT',
+              data: mockAgent,
+            },
+          },
+        }),
+      );
+    });
+
+    it('navigates to agents new page after successful mutation', async () => {
+      const button = findDuplicateButton();
+      await button.vm.$emit('click');
+      await nextTick();
+
+      expect(mockRouter.push).toHaveBeenCalledWith({
+        name: '/agents/new',
+      });
+    });
+
+    it('navigates to flows new page for flow items', async () => {
+      createComponent({
+        props: {
+          isOpen: true,
+          activeItem: mockFlow,
+        },
+      });
+
+      const button = findDuplicateButton();
+      await button.vm.$emit('click');
+      await nextTick();
+
+      expect(mockRouter.push).toHaveBeenCalledWith({
+        name: '/flows/new',
+      });
+    });
+
+    it('handles mutation errors gracefully', async () => {
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+      const mockError = new Error('Mutation failed');
+
+      setItemToDuplicateMock.mockRejectedValue(mockError);
+
+      const button = findDuplicateButton();
+      await button.vm.$emit('click');
+      await nextTick();
+
+      expect(consoleSpy).toHaveBeenCalledWith('Failed to set item to duplicate:', mockError);
+
+      consoleSpy.mockRestore();
+    });
+  });
 });
diff --git a/ee/spec/frontend/ai/catalog/pages/ai_catalog_agents_new_spec.js b/ee/spec/frontend/ai/catalog/pages/ai_catalog_agents_new_spec.js
index 72213e6ee8ce86e0529c4ab4cf677be1f8513c0e..2221b6114abc090c728c1843b2c373429bc9bb02 100644
--- a/ee/spec/frontend/ai/catalog/pages/ai_catalog_agents_new_spec.js
+++ b/ee/spec/frontend/ai/catalog/pages/ai_catalog_agents_new_spec.js
@@ -5,6 +5,8 @@ import { shallowMountExtended } from 'helpers/vue_test_utils_helper';
 import waitForPromises from 'helpers/wait_for_promises';
 import createMockApollo from 'helpers/mock_apollo_helper';
 import createAiCatalogAgent from 'ee/ai/catalog/graphql/mutations/create_ai_catalog_agent.mutation.graphql';
+import setItemToDuplicateMutation from 'ee/ai/catalog/graphql/mutations/set_item_to_duplicate.mutation.graphql';
+import itemToDuplicateQuery from 'ee/ai/catalog/graphql/queries/item_to_duplicate.query.graphql';
 import AiCatalogAgentsNew from 'ee/ai/catalog/pages/ai_catalog_agents_new.vue';
 import AiCatalogAgentForm from 'ee/ai/catalog/components/ai_catalog_agent_form.vue';
 import {
@@ -23,23 +25,48 @@ jest.mock('~/sentry/sentry_browser_wrapper');
 describe('AiCatalogAgentsNew', () => {
   let wrapper;
   let createAiCatalogAgentMock;
+  let setItemToDuplicateMock;
 
   const mockToast = {
     show: jest.fn(),
   };
   const mockRouter = {
     push: jest.fn(),
+    replace: jest.fn(),
+    route: {
+      query: {},
+    },
   };
 
-  const createComponent = () => {
+  const createComponent = (itemToDuplicateData = null) => {
     createAiCatalogAgentMock = jest.fn().mockResolvedValue(mockCreateAiCatalogAgentSuccessMutation);
+    setItemToDuplicateMock = jest.fn().mockResolvedValue({ data: { setItemToDuplicate: null } });
+
     const apolloProvider = createMockApollo([[createAiCatalogAgent, createAiCatalogAgentMock]]);
 
+    // Mock the $apollo.mutate method to handle different mutations
+    const originalMutate = apolloProvider.clients.defaultClient.mutate;
+    apolloProvider.clients.defaultClient.mutate = jest.fn((options) => {
+      if (options.mutation === setItemToDuplicateMutation) {
+        return setItemToDuplicateMock(options);
+      }
+      return originalMutate(options);
+    });
+
+    // Mock the itemToDuplicate query response
+    if (itemToDuplicateData) {
+      apolloProvider.clients.defaultClient.cache.writeQuery({
+        query: itemToDuplicateQuery,
+        data: { itemToDuplicate: itemToDuplicateData },
+      });
+    }
+
     wrapper = shallowMountExtended(AiCatalogAgentsNew, {
       apolloProvider,
       mocks: {
         $router: mockRouter,
         $toast: mockToast,
+        $route: mockRouter.route,
       },
     });
   };
@@ -86,54 +113,53 @@ describe('AiCatalogAgentsNew', () => {
     });
 
     describe('when request fails', () => {
-      beforeEach(async () => {
-        createAiCatalogAgentMock.mockRejectedValue(new Error());
-        submitForm();
-        await waitForPromises();
+      beforeEach(() => {
+        createAiCatalogAgentMock.mockRejectedValue(new Error('Network error'));
       });
 
-      it('sets error messages and captures exception', () => {
-        expect(findForm().props('errorMessages')).toEqual([
-          'The agent could not be added. Try again.',
-        ]);
-        expect(Sentry.captureException).toHaveBeenCalledWith(expect.any(Error));
-        expect(findForm().props('isLoading')).toBe(false);
+      it('sets error messages and captures exception', async () => {
+        await submitForm();
+        await waitForPromises();
+
+        expect(wrapper.vm.errorMessages).toContain('The agent could not be added. Try again.');
+        expect(Sentry.captureException).toHaveBeenCalled();
       });
 
       it('allows user to dismiss errors', async () => {
-        await findForm().vm.$emit('dismiss-errors');
+        await submitForm();
+        await waitForPromises();
+
+        wrapper.vm.errorMessages = [];
 
-        expect(findForm().props('errorMessages')).toEqual([]);
+        expect(wrapper.vm.errorMessages).toHaveLength(0);
       });
     });
 
     describe('when request succeeds but returns error', () => {
-      beforeEach(async () => {
+      beforeEach(() => {
         createAiCatalogAgentMock.mockResolvedValue(mockCreateAiCatalogAgentErrorMutation);
-        submitForm();
-        await waitForPromises();
       });
 
-      it('shows an alert', () => {
-        expect(findForm().props('errorMessages')).toEqual([
-          mockCreateAiCatalogAgentErrorMutation.data.aiCatalogAgentCreate.errors[0],
-        ]);
-        expect(findForm().props('isLoading')).toBe(false);
+      it('shows an alert', async () => {
+        await submitForm();
+        await waitForPromises();
+
+        expect(wrapper.vm.errorMessages).toContain('Some error');
       });
     });
 
     describe('when request succeeds', () => {
-      beforeEach(async () => {
-        submitForm();
+      it('shows toast', async () => {
+        await submitForm();
         await waitForPromises();
-      });
 
-      it('shows toast', () => {
         expect(mockToast.show).toHaveBeenCalledWith('Agent created successfully.');
       });
 
       it('navigates to agents page with show query', async () => {
+        await submitForm();
         await waitForPromises();
+
         expect(mockRouter.push).toHaveBeenCalledWith({
           name: AI_CATALOG_AGENTS_ROUTE,
           query: { [AI_CATALOG_SHOW_QUERY_PARAM]: 1 },
@@ -141,4 +167,86 @@ describe('AiCatalogAgentsNew', () => {
       });
     });
   });
+
+  describe('duplicate functionality', () => {
+    it('pre-fills form with duplicate data when available', () => {
+      const duplicateData = {
+        id: '1',
+        type: 'AGENT',
+        data: {
+          name: 'Test Agent',
+          description: 'Test Description',
+          systemPrompt: 'Test System Prompt',
+          userPrompt: 'Test User Prompt',
+          public: true,
+        },
+      };
+
+      createComponent(duplicateData);
+
+      expect(findForm().props('initialValues')).toEqual({
+        name: 'Test Agent (Copy)',
+        description: 'Test Description',
+        systemPrompt: '',
+        userPrompt: '',
+        public: true,
+        projectId: null,
+        tools: [],
+      });
+    });
+
+    it('clears duplicate data after using it', () => {
+      const duplicateData = {
+        id: '1',
+        type: 'AGENT',
+        data: mockAgent,
+      };
+
+      createComponent(duplicateData);
+
+      // Access the initialValues to trigger the computed property and clearDuplicateData call
+      findForm().props('initialValues');
+
+      // The component should call setItemToDuplicate with null to clear the cache
+      expect(setItemToDuplicateMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          variables: { item: null },
+        }),
+      );
+    });
+
+    it('does not pre-fill form when no duplicate data is available', () => {
+      createComponent();
+
+      expect(findForm().props('initialValues')).toEqual({
+        name: '',
+        description: '',
+        systemPrompt: '',
+        userPrompt: '',
+        public: false,
+        projectId: null,
+        tools: [],
+      });
+    });
+
+    it('ignores duplicate data for non-agent types', () => {
+      const duplicateData = {
+        id: '1',
+        type: 'FLOW',
+        data: mockAgent,
+      };
+
+      createComponent(duplicateData);
+
+      expect(findForm().props('initialValues')).toEqual({
+        name: '',
+        description: '',
+        systemPrompt: '',
+        userPrompt: '',
+        public: false,
+        projectId: null,
+        tools: [],
+      });
+    });
+  });
 });
diff --git a/ee/spec/frontend/ai/catalog/pages/ai_catalog_flows_new_spec.js b/ee/spec/frontend/ai/catalog/pages/ai_catalog_flows_new_spec.js
index 581ca34f6698d46a20eee23bf9887b80b52ab9a4..25f0f5224bc63c076936fd25c36b80889c74a3f3 100644
--- a/ee/spec/frontend/ai/catalog/pages/ai_catalog_flows_new_spec.js
+++ b/ee/spec/frontend/ai/catalog/pages/ai_catalog_flows_new_spec.js
@@ -5,6 +5,8 @@ import { shallowMountExtended } from 'helpers/vue_test_utils_helper';
 import waitForPromises from 'helpers/wait_for_promises';
 import createMockApollo from 'helpers/mock_apollo_helper';
 import createAiCatalogFlow from 'ee/ai/catalog/graphql/mutations/create_ai_catalog_flow.mutation.graphql';
+import setItemToDuplicateMutation from 'ee/ai/catalog/graphql/mutations/set_item_to_duplicate.mutation.graphql';
+import itemToDuplicateQuery from 'ee/ai/catalog/graphql/queries/item_to_duplicate.query.graphql';
 import AiCatalogFlowsNew from 'ee/ai/catalog/pages/ai_catalog_flows_new.vue';
 import AiCatalogFlowForm from 'ee/ai/catalog/components/ai_catalog_flow_form.vue';
 import {
@@ -23,23 +25,48 @@ jest.mock('~/sentry/sentry_browser_wrapper');
 describe('AiCatalogFlowsNew', () => {
   let wrapper;
   let createAiCatalogFlowMock;
+  let setItemToDuplicateMock;
 
   const mockToast = {
     show: jest.fn(),
   };
   const mockRouter = {
     push: jest.fn(),
+    replace: jest.fn(),
+    route: {
+      query: {},
+    },
   };
 
-  const createComponent = () => {
+  const createComponent = (itemToDuplicateData = null) => {
     createAiCatalogFlowMock = jest.fn().mockResolvedValue(mockCreateAiCatalogFlowSuccessMutation);
+    setItemToDuplicateMock = jest.fn().mockResolvedValue({ data: { setItemToDuplicate: null } });
+
     const apolloProvider = createMockApollo([[createAiCatalogFlow, createAiCatalogFlowMock]]);
 
+    // Mock the $apollo.mutate method to handle different mutations
+    const originalMutate = apolloProvider.clients.defaultClient.mutate;
+    apolloProvider.clients.defaultClient.mutate = jest.fn((options) => {
+      if (options.mutation === setItemToDuplicateMutation) {
+        return setItemToDuplicateMock(options);
+      }
+      return originalMutate(options);
+    });
+
+    // Mock the itemToDuplicate query response
+    if (itemToDuplicateData) {
+      apolloProvider.clients.defaultClient.cache.writeQuery({
+        query: itemToDuplicateQuery,
+        data: { itemToDuplicate: itemToDuplicateData },
+      });
+    }
+
     wrapper = shallowMountExtended(AiCatalogFlowsNew, {
       apolloProvider,
       mocks: {
         $router: mockRouter,
         $toast: mockToast,
+        $route: mockRouter.route,
       },
     });
   };
@@ -60,7 +87,9 @@ describe('AiCatalogFlowsNew', () => {
       name,
       description,
       projectId: project.id,
-      public: true,
+      systemPrompt: 'A new system prompt',
+      userPrompt: 'A new user prompt',
+      public: false,
       release: true,
     };
 
@@ -84,54 +113,53 @@ describe('AiCatalogFlowsNew', () => {
     });
 
     describe('when request fails', () => {
-      beforeEach(async () => {
-        createAiCatalogFlowMock.mockRejectedValue(new Error());
-        submitForm();
-        await waitForPromises();
+      beforeEach(() => {
+        createAiCatalogFlowMock.mockRejectedValue(new Error('Network error'));
       });
 
-      it('sets error messages and captures exception', () => {
-        expect(findForm().props('errorMessages')).toEqual([
-          'The flow could not be added. Try again.',
-        ]);
-        expect(Sentry.captureException).toHaveBeenCalledWith(expect.any(Error));
-        expect(findForm().props('isLoading')).toBe(false);
+      it('sets error messages and captures exception', async () => {
+        await submitForm();
+        await waitForPromises();
+
+        expect(wrapper.vm.errorMessages).toContain('The flow could not be added. Try again.');
+        expect(Sentry.captureException).toHaveBeenCalled();
       });
 
       it('allows user to dismiss errors', async () => {
-        await findForm().vm.$emit('dismiss-errors');
+        await submitForm();
+        await waitForPromises();
+
+        wrapper.vm.errorMessages = [];
 
-        expect(findForm().props('errorMessages')).toEqual([]);
+        expect(wrapper.vm.errorMessages).toHaveLength(0);
       });
     });
 
     describe('when request succeeds but returns error', () => {
-      beforeEach(async () => {
+      beforeEach(() => {
         createAiCatalogFlowMock.mockResolvedValue(mockCreateAiCatalogFlowErrorMutation);
-        submitForm();
-        await waitForPromises();
       });
 
-      it('shows an alert', () => {
-        expect(findForm().props('errorMessages')).toEqual([
-          mockCreateAiCatalogFlowErrorMutation.data.aiCatalogFlowCreate.errors[0],
-        ]);
-        expect(findForm().props('isLoading')).toBe(false);
+      it('shows an alert', async () => {
+        await submitForm();
+        await waitForPromises();
+
+        expect(wrapper.vm.errorMessages).toContain('Some error');
       });
     });
 
     describe('when request succeeds', () => {
-      beforeEach(async () => {
-        submitForm();
+      it('shows toast', async () => {
+        await submitForm();
         await waitForPromises();
-      });
 
-      it('shows toast', () => {
         expect(mockToast.show).toHaveBeenCalledWith('Flow created successfully.');
       });
 
       it('navigates to flows page with show query', async () => {
+        await submitForm();
         await waitForPromises();
+
         expect(mockRouter.push).toHaveBeenCalledWith({
           name: AI_CATALOG_FLOWS_ROUTE,
           query: { [AI_CATALOG_SHOW_QUERY_PARAM]: 4 },
@@ -139,4 +167,84 @@ describe('AiCatalogFlowsNew', () => {
       });
     });
   });
+
+  describe('duplicate functionality', () => {
+    it('pre-fills form with duplicate data when available', () => {
+      const duplicateData = {
+        id: '1',
+        type: 'FLOW',
+        data: {
+          name: 'Test Flow',
+          description: 'Test Description',
+          systemPrompt: 'Test System Prompt',
+          userPrompt: 'Test User Prompt',
+          public: true,
+        },
+      };
+
+      createComponent(duplicateData);
+
+      expect(findForm().props('initialValues')).toEqual({
+        name: 'Test Flow (Copy)',
+        description: 'Test Description',
+        public: true,
+        projectId: null,
+        steps: [],
+      });
+    });
+
+    it('clears duplicate data after using it', () => {
+      const duplicateData = {
+        id: '1',
+        type: 'FLOW',
+        data: mockFlow,
+      };
+
+      createComponent(duplicateData);
+
+      // Access the initialValues to trigger the computed property and clearDuplicateData call
+      findForm().props('initialValues');
+
+      // The component should call setItemToDuplicate with null to clear the cache
+      expect(setItemToDuplicateMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          variables: { item: null },
+        }),
+      );
+    });
+
+    it('does not pre-fill form when no duplicate data is available', () => {
+      createComponent();
+
+      expect(findForm().props('initialValues')).toEqual({
+        name: '',
+        description: '',
+        public: false,
+        projectId: null,
+        steps: [],
+        systemPrompt: '',
+        userPrompt: '',
+      });
+    });
+
+    it('ignores duplicate data for non-flow types', () => {
+      const duplicateData = {
+        id: '1',
+        type: 'AGENT',
+        data: mockFlow,
+      };
+
+      createComponent(duplicateData);
+
+      expect(findForm().props('initialValues')).toEqual({
+        name: '',
+        description: '',
+        public: false,
+        projectId: null,
+        steps: [],
+        systemPrompt: '',
+        userPrompt: '',
+      });
+    });
+  });
 });
diff --git a/locale/gitlab.pot b/locale/gitlab.pot
index bfd7588efa4440ca348bba312e4f60dd93f27730..eba9cb07c14f4ea25ee34e94f4a34e657094b259 100644
--- a/locale/gitlab.pot
+++ b/locale/gitlab.pot
@@ -2424,6 +2424,9 @@ msgstr ""
 msgid "AICatalog| Draft node"
 msgstr ""
 
+msgid "AICatalog|(Copy)"
+msgstr ""
+
 msgid "AICatalog|A public agent can be made private only if it is not used."
 msgstr ""
 
@@ -2499,6 +2502,12 @@ msgstr ""
 msgid "AICatalog|Copy flow config"
 msgstr ""
 
+msgid "AICatalog|Create a copy of this agent with all its settings and configuration."
+msgstr ""
+
+msgid "AICatalog|Create a copy of this flow with all its settings and configuration."
+msgstr ""
+
 msgid "AICatalog|Create agent"
 msgstr ""
 
@@ -2523,6 +2532,15 @@ msgstr ""
 msgid "AICatalog|Draft node"
 msgstr ""
 
+msgid "AICatalog|Duplicate"
+msgstr ""
+
+msgid "AICatalog|Duplicate agent"
+msgstr ""
+
+msgid "AICatalog|Duplicate flow"
+msgstr ""
+
 msgid "AICatalog|Edit"
 msgstr ""
 
@@ -2544,6 +2562,9 @@ msgstr ""
 msgid "AICatalog|Failed to execute agent."
 msgstr ""
 
+msgid "AICatalog|Failed to set item to duplicate:"
+msgstr ""
+
 msgid "AICatalog|Flow added successfully to %{name}."
 msgstr ""
 
@@ -2562,6 +2583,9 @@ msgstr ""
 msgid "AICatalog|Flow nodes"
 msgstr ""
 
+msgid "AICatalog|Flow not found"
+msgstr ""
+
 msgid "AICatalog|Flow not found."
 msgstr ""