diff --git a/packages/bridge-status-controller/CHANGELOG.md b/packages/bridge-status-controller/CHANGELOG.md
index 1c56ee55eec..1001f8faddb 100644
--- a/packages/bridge-status-controller/CHANGELOG.md
+++ b/packages/bridge-status-controller/CHANGELOG.md
@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- No longer report `SUBMITTED` or finalized quote statuses to the quote status API for intent-based swaps, since the bridge backend observes intent settlement and owns those statuses ([#10171](https://github.com/MetaMask/core/pull/10171))
 - Bump `@metamask/profile-sync-controller` from `^32.0.0` to `^32.1.0` ([#10184](https://github.com/MetaMask/core/pull/10184))
 
 ## [76.1.0]
diff --git a/packages/bridge-status-controller/src/bridge-status-controller.intent.test.ts b/packages/bridge-status-controller/src/bridge-status-controller.intent.test.ts
index aa782fb2a18..7ce127fedb5 100644
--- a/packages/bridge-status-controller/src/bridge-status-controller.intent.test.ts
+++ b/packages/bridge-status-controller/src/bridge-status-controller.intent.test.ts
@@ -292,6 +292,8 @@ const setup = (options?: {
   clientId?: BridgeClientId;
   keyringType?: string;
   mockTxHistory?: any;
+  isQuoteStatusManagerEnabled?: () => boolean;
+  onQuoteStatusManagerError?: (error: unknown) => void;
 }) => {
   const accountAddress = '0xAccount1' as const;
   const { messenger, transactions } = createMessengerHarness(
@@ -312,6 +314,8 @@ const setup = (options?: {
     fetchFn: (...args: any[]) => mockFetchFn(...args),
     config: { customBridgeApiBaseUrl: 'http://localhost' },
     traceFn: (_req: any, fn?: any): any => fn?.(),
+    isQuoteStatusManagerEnabled: options?.isQuoteStatusManagerEnabled,
+    onQuoteStatusManagerError: options?.onQuoteStatusManagerError as any,
   });
 
   const startPollingSpy = jest
@@ -745,6 +749,56 @@ describe('BridgeStatusController (intent swaps)', () => {
     expect(stopPollingSpy).toHaveBeenCalledWith('poll-token-1');
   });
 
+  it.each([
+    { description: 'COMPLETED', orderStatus: IntentOrderStatus.COMPLETED },
+    { description: 'EXPIRED', orderStatus: IntentOrderStatus.EXPIRED },
+  ])(
+    'intent polling: does not report any quote status when the order reaches $description',
+    async ({ orderStatus }) => {
+      const onQuoteStatusManagerError = jest.fn();
+      const orderUid = 'order-uid-quote-status-1';
+      const { controller } = setup({
+        isQuoteStatusManagerEnabled: () => true,
+        onQuoteStatusManagerError,
+        mockTxHistory: {
+          [orderUid]: {
+            txMetaId: orderUid,
+            originalTransactionId: orderUid,
+            quoteId: 'intent-quote-1',
+            quote: minimalIntentQuoteResponse().quote,
+            account: '0xAccount1',
+            startTime: Date.now(),
+            status: {
+              status: StatusTypes.PENDING,
+              srcChain: { chainId: 1, txHash: '0xhash' },
+            },
+          },
+        },
+      });
+
+      jest
+        .spyOn(intentApi.IntentApiImpl.prototype, 'getOrderStatus')
+        .mockResolvedValue({
+          id: orderUid,
+          status: orderStatus,
+          txHash: '0xsettlementhash',
+          metadata: { txHashes: ['0xsettlementhash'] },
+        });
+
+      await controller._executePoll({ bridgeTxMetaId: orderUid });
+
+      // The backend owns the quote status of intent orders, so reaching a
+      // terminal order status must not create or update a tracking entry.
+      expect(controller.state.quoteUpdateStatusStore).toStrictEqual({});
+      expect(
+        controller.state.txHistory[orderUid]?.reportedSubmittedTxHash,
+      ).toBeUndefined();
+      expect(onQuoteStatusManagerError).not.toHaveBeenCalled();
+
+      controller.stopAllPolling();
+    },
+  );
+
   it('intent polling: stops polling when attempts reach MAX_ATTEMPTS', async () => {
     const orderUid = 'order-uid-3';
     const { controller, stopPollingSpy } = setup({
diff --git a/packages/bridge-status-controller/src/bridge-status-controller.test.ts b/packages/bridge-status-controller/src/bridge-status-controller.test.ts
index ea203de2361..0d02217df05 100644
--- a/packages/bridge-status-controller/src/bridge-status-controller.test.ts
+++ b/packages/bridge-status-controller/src/bridge-status-controller.test.ts
@@ -7334,6 +7334,153 @@ describe('BridgeStatusController', () => {
         );
       });
     });
+
+    describe('intent-based swaps', () => {
+      const INTENT_TX_META_ID = 'intentTxMetaId1';
+      const INTENT_SRC_TX_HASH = '0xintentSrcTxHash1';
+
+      /**
+       * Builds a history item for an intent-based order. The quote carries
+       * `intent` data, which is what marks the trade as backend-tracked.
+       *
+       * @param startTime - When the trade started, used to decide whether
+       * startup seeding considers the item.
+       * @returns The intent txHistory keyed by history id.
+       */
+      function buildIntentHistory(
+        startTime = 1729964825189,
+      ): Record<string, BridgeHistoryItem> {
+        const item = MockTxHistory.getPending({
+          txMetaId: INTENT_TX_META_ID,
+          srcTxHash: INTENT_SRC_TX_HASH,
+          startTime,
+        })[INTENT_TX_META_ID];
+
+        return {
+          [INTENT_TX_META_ID]: {
+            ...item,
+            quoteId: 'intent-quote-1',
+            quote: {
+              ...item.quote,
+              intent: {
+                protocol: 'cowswap',
+                order: {
+                  sellToken: '0x0000000000000000000000000000000000000001',
+                  buyToken: '0x0000000000000000000000000000000000000002',
+                  validTo: 1717027200,
+                  appData: 'some-app-data',
+                  appDataHash: '0xabcd',
+                  feeAmount: '100',
+                  kind: 'sell',
+                  partiallyFillable: false,
+                  sellAmount: '1000',
+                },
+                typedData: {
+                  types: {},
+                  primaryType: 'Order',
+                  domain: {},
+                  message: {},
+                },
+              },
+            },
+          },
+        };
+      }
+
+      const getIntentMessengerCall = () =>
+        jest.fn((...args: unknown[]) => {
+          const action = args[0] as string;
+          if (action === 'TransactionController:getState') {
+            return { transactions: [] };
+          }
+          if (action === 'AuthenticationController:getBearerToken') {
+            return Promise.resolve('auth-token');
+          }
+          return undefined;
+        });
+
+      it.each([
+        {
+          description: 'submitted',
+          status: TransactionStatus.submitted,
+          type: TransactionType.swap,
+        },
+        {
+          description: 'confirmed',
+          status: TransactionStatus.confirmed,
+          type: TransactionType.swap,
+        },
+        {
+          description: 'failed',
+          status: TransactionStatus.failed,
+          type: TransactionType.swap,
+        },
+      ])(
+        'does not report any quote status when the intent tx is $description',
+        async ({ status, type }) => {
+          const onQuoteStatusManagerError = jest.fn();
+
+          await withController(
+            {
+              options: {
+                isQuoteStatusManagerEnabled: () => true,
+                onQuoteStatusManagerError,
+                state: { txHistory: buildIntentHistory() },
+              },
+              mockMessengerCall: getIntentMessengerCall(),
+            },
+            async ({ controller, rootMessenger }) => {
+              rootMessenger.publish(
+                'TransactionController:transactionStatusUpdated',
+                {
+                  transactionMeta: {
+                    chainId: CHAIN_IDS.ARBITRUM,
+                    networkClientId: 'eth-id',
+                    time: Date.now(),
+                    txParams: {} as unknown as TransactionParams,
+                    type,
+                    status,
+                    id: INTENT_TX_META_ID,
+                    hash: INTENT_SRC_TX_HASH,
+                  },
+                },
+              );
+
+              // The backend owns the quote status of intent orders, so the
+              // client neither creates a tracking entry nor marks the history
+              // item as reported.
+              expect(controller.state.quoteUpdateStatusStore).toStrictEqual({});
+              expect(
+                controller.state.txHistory[INTENT_TX_META_ID]
+                  .reportedSubmittedTxHash,
+              ).toBeUndefined();
+              // Finalizing an untracked quote surfaces a "entry was not found"
+              // error, so silence here proves finalization was never attempted.
+              expect(onQuoteStatusManagerError).not.toHaveBeenCalled();
+            },
+          );
+        },
+      );
+
+      it('does not seed a quote status entry for an intent order on startup', async () => {
+        await withController(
+          {
+            options: {
+              isQuoteStatusManagerEnabled: () => true,
+              state: { txHistory: buildIntentHistory(Date.now()) },
+            },
+            mockMessengerCall: getIntentMessengerCall(),
+          },
+          async ({ controller }) => {
+            expect(controller.state.quoteUpdateStatusStore).toStrictEqual({});
+            expect(
+              controller.state.txHistory[INTENT_TX_META_ID]
+                .reportedSubmittedTxHash,
+            ).toBeUndefined();
+          },
+        );
+      });
+    });
   });
 
   describe('seeding quote status entries from history on startup', () => {
diff --git a/packages/bridge-status-controller/src/bridge-status-controller.ts b/packages/bridge-status-controller/src/bridge-status-controller.ts
index b07d91aa931..aea9171603f 100644
--- a/packages/bridge-status-controller/src/bridge-status-controller.ts
+++ b/packages/bridge-status-controller/src/bridge-status-controller.ts
@@ -384,6 +384,21 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
     );
   };
 
+  /**
+   * Whether a history item represents an intent-based order.
+   *
+   * The bridge backend observes intent settlement directly and owns the quote
+   * status of these orders, so the client must not report SUBMITTED or
+   * finalized quote-status updates for them.
+   *
+   * @param historyKey - The key of the history item in `txHistory`
+   * @returns `true` when the history item exists and carries intent data
+   */
+  readonly #isIntentHistoryItem = (historyKey?: string): boolean =>
+    historyKey
+      ? Boolean(this.state.txHistory[historyKey]?.quote.intent)
+      : false;
+
   readonly #onTransactionFailed = ({
     txMeta,
     historyKey,
@@ -396,9 +411,7 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
     const isHistoryItemAlreadyFailed = historyKey
       ? this.state.txHistory[historyKey]?.status.status === StatusTypes.FAILED
       : false;
-    const isIntent = historyKey
-      ? Boolean(this.state.txHistory[historyKey]?.quote.intent)
-      : false;
+    const isIntent = this.#isIntentHistoryItem(historyKey);
 
     this.#updateHistoryItem({
       historyKey,
@@ -426,8 +439,9 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
     // `hasNestedSwapTransactions` also covers batch/7702 swaps whose type may
     // still read as `batch` rather than `swap`.
     if (
-      (txMeta.type && isCrossChainTx(txMeta.type)) ||
-      hasNestedSwapTransactions(txMeta)
+      !isIntent &&
+      ((txMeta.type && isCrossChainTx(txMeta.type)) ||
+        hasNestedSwapTransactions(txMeta))
     ) {
       this.#quoteStatusManager.reportFinalised(
         txMeta.id,
@@ -464,9 +478,7 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
       historyKey,
       txHash: txMeta.hash,
     });
-    const isIntent = historyKey
-      ? Boolean(this.state.txHistory[historyKey]?.quote.intent)
-      : false;
+    const isIntent = this.#isIntentHistoryItem(historyKey);
 
     const isSwap =
       txMeta.type === TransactionType.swap || hasNestedSwapTransactions(txMeta);
@@ -478,29 +490,28 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
         completionTime: Date.now(),
       });
 
-      // For EVM intent-based swaps the synthetic tx transitions
-      // submitted→confirmed in a single update that carries the CoW
-      // settlement hash, so the submitted status handler never has a hash
-      // and reportSubmitted is never called. Call it here (before
-      // reportFinalised) so the deferred-queue entry is created.
-      const historyItem = historyKey
-        ? this.state.txHistory[historyKey]
-        : undefined;
-      if (
-        historyKey &&
-        historyItem &&
-        txMeta.hash &&
-        !isNonEvmChainId(historyItem.quote.srcChainId)
-      ) {
-        this.#reportSubmittedOnce(historyKey, txMeta.hash, txMeta.id);
-      }
-      this.#quoteStatusManager.reportFinalised(
-        txMeta.id,
-        true,
-        txMeta.chainId,
-        txMeta.hash,
-      );
       if (!isIntent) {
+        // Smart/batch transactions can be assigned their hash only once
+        // confirmed, so the submitted status handler never had one to report.
+        // Report it here (before reportFinalised) so the deferred-queue entry
+        // exists.
+        const historyItem = historyKey
+          ? this.state.txHistory[historyKey]
+          : undefined;
+        if (
+          historyKey &&
+          historyItem &&
+          txMeta.hash &&
+          !isNonEvmChainId(historyItem.quote.srcChainId)
+        ) {
+          this.#reportSubmittedOnce(historyKey, txMeta.hash, txMeta.id);
+        }
+        this.#quoteStatusManager.reportFinalised(
+          txMeta.id,
+          true,
+          txMeta.chainId,
+          txMeta.hash,
+        );
         this.#traceSwapOperationCompleted(
           historyKey,
           'success',
@@ -558,6 +569,8 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
    * into `txHistory`). In that case every quote is reported under the shared
    * source tx hash and `txMetaId`.
    *
+   * Intent-based orders are skipped: the backend owns their quote status.
+   *
    * @param historyKey - The key of the history item in `txHistory`
    * @param srcTxHash - The source chain transaction hash
    * @param txMetaId - The transaction meta id, used for finalization matching
@@ -568,7 +581,7 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
     txMetaId: string,
   ): void => {
     const historyItem = this.state.txHistory[historyKey];
-    if (!historyItem) {
+    if (!historyItem || historyItem.quote.intent) {
       return;
     }
 
@@ -994,12 +1007,14 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
     // permanently ends polling, so it's the correct and non-duplicative point
     // to emit the final status.
     const historyItem = this.state.txHistory[bridgeTxMetaId];
-    this.#quoteStatusManager.reportFinalised(
-      bridgeTxMetaId,
-      false,
-      historyItem?.quote.srcChainId,
-      historyItem?.status.srcChain.txHash,
-    );
+    if (!this.#isIntentHistoryItem(bridgeTxMetaId)) {
+      this.#quoteStatusManager.reportFinalised(
+        bridgeTxMetaId,
+        false,
+        historyItem?.quote.srcChainId,
+        historyItem?.status.srcChain.txHash,
+      );
+    }
     this.#deleteHistoryItem(bridgeTxMetaId);
   };
 
@@ -1043,17 +1058,6 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
           return;
         }
         status = intentTxStatus.bridgeStatus.status;
-
-        // Report SUBMITTED as soon as the intent's source/settlement hash is
-        // known at poll time, before the order reaches a terminal status.
-        const intentSrcTxHash = status.srcChain.txHash;
-        if (intentSrcTxHash) {
-          this.#reportSubmittedOnce(
-            bridgeTxMetaId,
-            intentSrcTxHash,
-            bridgeTxMetaId,
-          );
-        }
       } else {
         // We try here because we receive 500 errors from Bridge API if we try to fetch immediately after submitting the source tx
         // Oddly mostly happens on Optimism, never on Arbitrum. By the 2nd fetch, the Bridge API responds properly.
@@ -1146,23 +1150,25 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
           delete this.#pollingTokensByTxMetaId[bridgeTxMetaId];
         }
 
-        // Ensure a deferred entry exists before reportFinalised is called.
         const settlementTxHash = newBridgeHistoryItem.status.srcChain.txHash;
-        if (settlementTxHash) {
-          this.#reportSubmittedOnce(
+        if (!historyItem.quote.intent) {
+          // Ensure a deferred entry exists before reportFinalised is called.
+          if (settlementTxHash) {
+            this.#reportSubmittedOnce(
+              bridgeTxMetaId,
+              settlementTxHash,
+              bridgeTxMetaId,
+            );
+          }
+
+          this.#quoteStatusManager.reportFinalised(
             bridgeTxMetaId,
+            status.status === StatusTypes.COMPLETE,
+            historyItem.quote.srcChainId,
             settlementTxHash,
-            bridgeTxMetaId,
           );
         }
 
-        this.#quoteStatusManager.reportFinalised(
-          bridgeTxMetaId,
-          status.status === StatusTypes.COMPLETE,
-          historyItem.quote.srcChainId,
-          settlementTxHash,
-        );
-
         await this.#traceSwapOperationCompleted(
           bridgeTxMetaId,
           status.status === StatusTypes.COMPLETE ? 'success' : 'error',