diff --git a/ee/app/assets/javascripts/remote_development/components/common/get_project_details_query.vue b/ee/app/assets/javascripts/remote_development/components/common/get_project_details_query.vue
index 50510fe36d0561f3f4785e0a5509d337db4deb6b..f3a3b409debe008187f7fcda5520ba0e0384d949 100644
--- a/ee/app/assets/javascripts/remote_development/components/common/get_project_details_query.vue
+++ b/ee/app/assets/javascripts/remote_development/components/common/get_project_details_query.vue
@@ -1,10 +1,13 @@
 <script>
 import { uniqBy } from 'lodash';
 import { logError } from '~/lib/logger';
+import glFeatureFlagMixin from '~/vue_shared/mixins/gl_feature_flags_mixin';
 import getProjectDetailsQuery from '../../graphql/queries/get_project_details.query.graphql';
 import getGroupClusterAgentsQuery from '../../graphql/queries/get_group_cluster_agents.query.graphql';
+import getRemoteDevelopmentClusterAgents from '../../graphql/queries/get_remote_development_cluster_agents.query.graphql';
 
 export default {
+  mixins: [glFeatureFlagMixin()],
   props: {
     projectFullPath: {
       type: String,
@@ -51,37 +54,75 @@ export default {
           return;
         }
 
-        const groupFullPath = group.fullPath;
-        const groupFullPathParts = groupFullPath.split('/') || [];
-        const groupPathsFromRoot = groupFullPathParts.map((_, i, arr) =>
-          arr.slice(0, i + 1).join('/'),
-        );
-        const clusterAgentsResponses = await Promise.all(
-          groupPathsFromRoot.map(this.fetchClusterAgents),
-        );
+        const { clusterAgents, errors } = this.glFeatures
+          .remoteDevelopmentNamespaceAgentAuthorization
+          ? await this.fetchRemoteDevelopmentClusterAgents(group.fullPath)
+          : await this.fetchClusterAgentsForGroupHierarchy(group.fullPath);
 
-        const errors = clusterAgentsResponses.filter((response) => response.error);
-        if (errors.length > 0) {
-          errors.forEach((error) => logError(error.error));
+        if (Array.isArray(errors) && errors.length) {
+          errors.forEach((error) => logError(error));
           this.$emit('error');
           return;
         }
 
-        const clusterAgents = clusterAgentsResponses.flatMap((response) => response.result);
-        const uniqClusterAgents = uniqBy(clusterAgents, 'value');
-
         this.$emit('result', {
           id,
           fullPath: this.projectFullPath,
           nameWithNamespace,
-          clusterAgents: uniqClusterAgents,
+          clusterAgents,
           rootRef,
         });
       },
     },
   },
   methods: {
-    async fetchClusterAgents(groupPath) {
+    async fetchRemoteDevelopmentClusterAgents(namespace) {
+      try {
+        // noinspection JSCheckFunctionSignatures - TODO: Address in https://gitlab.com/gitlab-org/gitlab/-/issues/437600
+        const { data, error } = await this.$apollo.query({
+          query: getRemoteDevelopmentClusterAgents,
+          variables: { namespace },
+        });
+
+        if (error) {
+          // NOTE: It seems to be impossible to have test coverage for this line
+          //       with the current version of mock-apollo-client. Any type of
+          //       mock error is always thrown and caught below instead of
+          //       being returned.
+          return { errors: [error] };
+        }
+
+        return {
+          clusterAgents:
+            data.namespace?.remoteDevelopmentClusterAgents?.nodes.map(({ id, name, project }) => ({
+              value: id,
+              text: `${project.nameWithNamespace} / ${name}`,
+            })) || [],
+        };
+      } catch (error) {
+        return { errors: [error] };
+      }
+    },
+    async fetchClusterAgentsForGroupHierarchy(groupFullPath) {
+      const groupFullPathParts = groupFullPath.split('/') || [];
+      const groupPathsFromRoot = groupFullPathParts.map((_, i, arr) =>
+        arr.slice(0, i + 1).join('/'),
+      );
+      const clusterAgentsResponses = await Promise.all(
+        groupPathsFromRoot.map((groupPath) => this.fetchClusterAgentForGroup(groupPath)),
+      );
+
+      const errors = clusterAgentsResponses.map((response) => response.error).filter(Boolean);
+
+      if (errors.length > 0) {
+        return { errors };
+      }
+
+      const clusterAgents = clusterAgentsResponses.flatMap((response) => response.result);
+
+      return { clusterAgents: uniqBy(clusterAgents, 'value') };
+    },
+    async fetchClusterAgentForGroup(groupPath) {
       try {
         // noinspection JSCheckFunctionSignatures - TODO: Address in https://gitlab.com/gitlab-org/gitlab/-/issues/437600
         const { data, error } = await this.$apollo.query({
diff --git a/ee/app/assets/javascripts/remote_development/graphql/queries/get_remote_development_cluster_agents.query.graphql b/ee/app/assets/javascripts/remote_development/graphql/queries/get_remote_development_cluster_agents.query.graphql
new file mode 100644
index 0000000000000000000000000000000000000000..18279d27a33f1779342fccca5716cc7f37af96d2
--- /dev/null
+++ b/ee/app/assets/javascripts/remote_development/graphql/queries/get_remote_development_cluster_agents.query.graphql
@@ -0,0 +1,15 @@
+query getRemoteDevelopmentClusterAgents($namespace: ID!) {
+  namespace(fullPath: $namespace) {
+    id
+    remoteDevelopmentClusterAgents(filter: "AVAILABLE") @client {
+      nodes {
+        id
+        name
+        project {
+          id
+          nameWithNamespace
+        }
+      }
+    }
+  }
+}
diff --git a/ee/app/controllers/remote_development/workspaces_controller.rb b/ee/app/controllers/remote_development/workspaces_controller.rb
index f8fa2bc1d70a7563c617226ee2db448703d7bc4e..67971046f03b155226956ad9ff6cfdb51dc94fb7 100644
--- a/ee/app/controllers/remote_development/workspaces_controller.rb
+++ b/ee/app/controllers/remote_development/workspaces_controller.rb
@@ -3,6 +3,9 @@
 module RemoteDevelopment
   class WorkspacesController < ApplicationController
     before_action :authorize_remote_development!, only: [:index]
+    before_action do
+      push_frontend_feature_flag(:remote_development_namespace_agent_authorization, current_user)
+    end
 
     feature_category :remote_development
     urgency :low
diff --git a/ee/spec/features/remote_development/workspaces_spec.rb b/ee/spec/features/remote_development/workspaces_spec.rb
index 8f86a4cbb1d681f4d99cc6ece7210b38c5f08a4c..bb6c4fe9949db1caee552f219befc3b0fcdc198f 100644
--- a/ee/spec/features/remote_development/workspaces_spec.rb
+++ b/ee/spec/features/remote_development/workspaces_spec.rb
@@ -26,7 +26,6 @@
 
   before do
     stub_licensed_features(remote_development: true)
-
     allow(Gitlab::Kas).to receive(:verify_api_request).and_return(true)
 
     # rubocop:disable RSpec/AnyInstanceOf -- It's NOT the next instance...
@@ -38,224 +37,244 @@
     wait_for_requests
   end
 
-  describe 'workspaces' do
-    context 'when creating' do
-      it 'creates a workspace' do
-        # Tips:
-        # use live_debug to pause when WEBDRIVER_HEADLESS=0
-        # live_debug
+  shared_examples 'creates a workspace' do
+    it 'creates a workspace' do
+      # Tips:
+      # use live_debug to pause when WEBDRIVER_HEADLESS=0
+      # live_debug
 
-        # NAVIGATE TO WORKSPACES PAGE
+      # NAVIGATE TO WORKSPACES PAGE
 
-        visit remote_development_workspaces_path
-        wait_for_requests
+      visit remote_development_workspaces_path
+      wait_for_requests
 
-        # CREATE WORKSPACE
+      # CREATE WORKSPACE
 
-        click_link 'New workspace', match: :first
-        click_button 'Select a project'
-        find_by_testid("listbox-item-#{project.full_path}").click
-        wait_for_requests
-        # noinspection RubyMismatchedArgumentType - TODO: Try suggestions in https://youtrack.jetbrains.com/issue/RUBY-25400/Programmatically-defined-constants-always-produce-Unresolved-reference-error#focus=Comments-27-8161148.0-0
-        select agent.name, from: 'Cluster agent'
-        fill_in 'Workspace automatically terminates after', with: '20'
-        click_button 'Create workspace'
+      click_link 'New workspace', match: :first
+      click_button 'Select a project'
+      find_by_testid("listbox-item-#{project.full_path}").click
+      wait_for_requests
+      # noinspection RubyMismatchedArgumentType - TODO: Try suggestions in https://youtrack.jetbrains.com/issue/RUBY-25400/Programmatically-defined-constants-always-produce-Unresolved-reference-error#focus=Comments-27-8161148.0-0
+      select agent.name, from: 'Cluster agent'
+      fill_in 'Workspace automatically terminates after', with: '20'
+      click_button 'Create workspace'
 
-        # We look for the project GID because that's all we know about the workspace at this point. For the new UI,
-        # we will have to either expose this as a field on the new workspaces UI, or else come up
-        # with some more clever finder to assert on the workspace showing up in the list after a refresh.
-        page.find('td', text: project.name_with_namespace)
+      # We look for the project GID because that's all we know about the workspace at this point. For the new UI,
+      # we will have to either expose this as a field on the new workspaces UI, or else come up
+      # with some more clever finder to assert on the workspace showing up in the list after a refresh.
+      page.find('td', text: project.name_with_namespace)
 
-        # GET NAME AND NAMESPACE OF NEW WORKSPACE
-        workspaces = RemoteDevelopment::Workspace.all.to_a
-        expect(workspaces.length).to eq(1)
-        workspace = workspaces[0]
+      # GET NAME AND NAMESPACE OF NEW WORKSPACE
+      workspaces = RemoteDevelopment::Workspace.all.to_a
+      expect(workspaces.length).to eq(1)
+      workspace = workspaces[0]
 
-        # ASSERT ON NEW WORKSPACE IN LIST
-        page.find('td', text: workspace.name)
+      # ASSERT ON NEW WORKSPACE IN LIST
+      page.find('td', text: workspace.name)
 
-        # ASSERT WORKSPACE STATE BEFORE POLLING NEW STATES
-        expect_workspace_state_indicator('Creating')
+      # ASSERT WORKSPACE STATE BEFORE POLLING NEW STATES
+      expect_workspace_state_indicator('Creating')
 
-        # ASSERT TERMINATE BUTTON IS AVAILABLE
-        expect(page).to have_button('Terminate')
+      # ASSERT TERMINATE BUTTON IS AVAILABLE
+      expect(page).to have_button('Terminate')
 
-        # SIMULATE FIRST POLL FROM AGENTK TO PICK UP NEW WORKSPACE
-        simulate_first_poll(workspace: workspace)
+      # SIMULATE FIRST POLL FROM AGENTK TO PICK UP NEW WORKSPACE
+      simulate_first_poll(workspace: workspace)
 
-        # SIMULATE SECOND POLL FROM AGENTK TO UPDATE WORKSPACE TO RUNNING STATE
-        simulate_second_poll(workspace: workspace)
+      # SIMULATE SECOND POLL FROM AGENTK TO UPDATE WORKSPACE TO RUNNING STATE
+      simulate_second_poll(workspace: workspace)
 
-        # ASSERT WORKSPACE SHOWS RUNNING STATE IN UI AND UPDATES URL
-        expect_workspace_state_indicator(RemoteDevelopment::Workspaces::States::RUNNING)
-        expect(page).to have_selector('a', text: workspace.url)
+      # ASSERT WORKSPACE SHOWS RUNNING STATE IN UI AND UPDATES URL
+      expect_workspace_state_indicator(RemoteDevelopment::Workspaces::States::RUNNING)
+      expect(page).to have_selector('a', text: workspace.url)
 
-        # ASSERT ACTION BUTTONS ARE CORRECT FOR RUNNING STATE
-        expect(page).to have_button('Restart')
-        expect(page).to have_button('Stop')
-        expect(page).to have_button('Terminate')
+      # ASSERT ACTION BUTTONS ARE CORRECT FOR RUNNING STATE
+      expect(page).to have_button('Restart')
+      expect(page).to have_button('Stop')
+      expect(page).to have_button('Terminate')
 
-        click_button 'Stop'
+      click_button 'Stop'
 
-        # SIMULATE THIRD POLL FROM AGENTK TO UPDATE WORKSPACE TO STOPPING STATE
-        simulate_third_poll(workspace: workspace)
+      # SIMULATE THIRD POLL FROM AGENTK TO UPDATE WORKSPACE TO STOPPING STATE
+      simulate_third_poll(workspace: workspace)
 
-        # ASSERT WORKSPACE SHOWS STOPPING STATE IN UI
-        expect_workspace_state_indicator(RemoteDevelopment::Workspaces::States::STOPPING)
+      # ASSERT WORKSPACE SHOWS STOPPING STATE IN UI
+      expect_workspace_state_indicator(RemoteDevelopment::Workspaces::States::STOPPING)
 
-        # ASSERT ACTION BUTTONS ARE CORRECT FOR STOPPING STATE
-        # TODO: What other buttons are there?
-        expect(page).to have_button('Terminate')
+      # ASSERT ACTION BUTTONS ARE CORRECT FOR STOPPING STATE
+      # TODO: What other buttons are there?
+      expect(page).to have_button('Terminate')
 
-        # SIMULATE FOURTH POLL FROM AGENTK TO UPDATE WORKSPACE TO STOPPED STATE
-        simulate_fourth_poll(workspace: workspace)
+      # SIMULATE FOURTH POLL FROM AGENTK TO UPDATE WORKSPACE TO STOPPED STATE
+      simulate_fourth_poll(workspace: workspace)
 
-        # ASSERT WORKSPACE SHOWS STOPPED STATE IN UI
-        expect_workspace_state_indicator(RemoteDevelopment::Workspaces::States::STOPPED)
+      # ASSERT WORKSPACE SHOWS STOPPED STATE IN UI
+      expect_workspace_state_indicator(RemoteDevelopment::Workspaces::States::STOPPED)
 
-        # ASSERT ACTION BUTTONS ARE CORRECT FOR STOPPED STATE
-        expect(page).to have_button('Start')
-        expect(page).to have_button('Terminate')
-      end
+      # ASSERT ACTION BUTTONS ARE CORRECT FOR STOPPED STATE
+      expect(page).to have_button('Start')
+      expect(page).to have_button('Terminate')
+    end
 
-      def simulate_first_poll(workspace:)
-        # SIMULATE FIRST POLL REQUEST FROM AGENTK TO GET NEW WORKSPACE
+    def simulate_first_poll(workspace:)
+      # SIMULATE FIRST POLL REQUEST FROM AGENTK TO GET NEW WORKSPACE
 
-        reconcile_post_response = simulate_agentk_reconcile_post(workspace_agent_infos: [])
+      reconcile_post_response = simulate_agentk_reconcile_post(workspace_agent_infos: [])
 
-        # ASSERT ON RESPONSE TO FIRST POLL REQUEST CONTAINING NEW WORKSPACE
+      # ASSERT ON RESPONSE TO FIRST POLL REQUEST CONTAINING NEW WORKSPACE
 
-        expect(reconcile_post_response.code).to eq(HTTP::Status::CREATED)
-        infos = Gitlab::Json.parse(reconcile_post_response.body).deep_symbolize_keys[:workspace_rails_infos]
-        expect(infos.length).to eq(1)
-        info = infos.first
+      expect(reconcile_post_response.code).to eq(HTTP::Status::CREATED)
+      infos = Gitlab::Json.parse(reconcile_post_response.body).deep_symbolize_keys[:workspace_rails_infos]
+      expect(infos.length).to eq(1)
+      info = infos.first
 
-        expect(info.fetch(:name)).to eq(workspace.name)
-        expect(info.fetch(:namespace)).to eq(workspace.namespace)
-        expect(info.fetch(:desired_state)).to eq(RemoteDevelopment::Workspaces::States::RUNNING)
-        expect(info.fetch(:actual_state)).to eq(RemoteDevelopment::Workspaces::States::CREATION_REQUESTED)
-        expect(info.fetch(:deployment_resource_version)).to be_nil
+      expect(info.fetch(:name)).to eq(workspace.name)
+      expect(info.fetch(:namespace)).to eq(workspace.namespace)
+      expect(info.fetch(:desired_state)).to eq(RemoteDevelopment::Workspaces::States::RUNNING)
+      expect(info.fetch(:actual_state)).to eq(RemoteDevelopment::Workspaces::States::CREATION_REQUESTED)
+      expect(info.fetch(:deployment_resource_version)).to be_nil
 
-        expected_config_to_apply = create_config_to_apply(
-          workspace: workspace,
-          started: true,
-          include_all_resources: true
-        )
+      expected_config_to_apply = create_config_to_apply(
+        workspace: workspace,
+        started: true,
+        include_all_resources: true
+      )
 
-        config_to_apply = info.fetch(:config_to_apply)
-        expect(config_to_apply).to eq(expected_config_to_apply)
-      end
+      config_to_apply = info.fetch(:config_to_apply)
+      expect(config_to_apply).to eq(expected_config_to_apply)
+    end
 
-      def simulate_second_poll(workspace:)
-        # SIMULATE SECOND POLL REQUEST FROM AGENTK TO UPDATE WORKSPACE TO RUNNING STATE
-
-        resource_version = '1'
-        workspace_agent_info = create_workspace_agent_info_hash(
-          workspace: workspace,
-          previous_actual_state: RemoteDevelopment::Workspaces::States::STARTING,
-          current_actual_state: RemoteDevelopment::Workspaces::States::RUNNING,
-          workspace_exists: false,
-          resource_version: resource_version
-        )
-        reconcile_post_response =
-          simulate_agentk_reconcile_post(workspace_agent_infos: [workspace_agent_info])
-
-        # ASSERT ON RESPONSE TO SECOND POLL REQUEST
-
-        expect(reconcile_post_response.code).to eq(HTTP::Status::CREATED)
-        infos = Gitlab::Json.parse(reconcile_post_response.body).deep_symbolize_keys[:workspace_rails_infos]
-        expect(infos.length).to eq(1)
-        info = infos.first
-
-        expect(info.fetch(:name)).to eq(workspace.name)
-        expect(info.fetch(:namespace)).to eq(workspace.namespace)
-        expect(info.fetch(:desired_state)).to eq(RemoteDevelopment::Workspaces::States::RUNNING)
-        expect(info.fetch(:actual_state)).to eq(RemoteDevelopment::Workspaces::States::RUNNING)
-        expect(info.fetch(:deployment_resource_version)).to eq(resource_version)
-        expect(info.fetch(:config_to_apply)).to be_nil
-      end
+    def simulate_second_poll(workspace:)
+      # SIMULATE SECOND POLL REQUEST FROM AGENTK TO UPDATE WORKSPACE TO RUNNING STATE
+
+      resource_version = '1'
+      workspace_agent_info = create_workspace_agent_info_hash(
+        workspace: workspace,
+        previous_actual_state: RemoteDevelopment::Workspaces::States::STARTING,
+        current_actual_state: RemoteDevelopment::Workspaces::States::RUNNING,
+        workspace_exists: false,
+        resource_version: resource_version
+      )
+      reconcile_post_response =
+        simulate_agentk_reconcile_post(workspace_agent_infos: [workspace_agent_info])
+
+      # ASSERT ON RESPONSE TO SECOND POLL REQUEST
+
+      expect(reconcile_post_response.code).to eq(HTTP::Status::CREATED)
+      infos = Gitlab::Json.parse(reconcile_post_response.body).deep_symbolize_keys[:workspace_rails_infos]
+      expect(infos.length).to eq(1)
+      info = infos.first
+
+      expect(info.fetch(:name)).to eq(workspace.name)
+      expect(info.fetch(:namespace)).to eq(workspace.namespace)
+      expect(info.fetch(:desired_state)).to eq(RemoteDevelopment::Workspaces::States::RUNNING)
+      expect(info.fetch(:actual_state)).to eq(RemoteDevelopment::Workspaces::States::RUNNING)
+      expect(info.fetch(:deployment_resource_version)).to eq(resource_version)
+      expect(info.fetch(:config_to_apply)).to be_nil
+    end
 
-      def simulate_third_poll(workspace:)
-        # SIMULATE THIRD POLL REQUEST FROM AGENTK TO UPDATE WORKSPACE TO STOPPING STATE
-
-        resource_version = '1'
-        workspace_agent_info = create_workspace_agent_info_hash(
-          workspace: workspace,
-          previous_actual_state: RemoteDevelopment::Workspaces::States::RUNNING,
-          current_actual_state: RemoteDevelopment::Workspaces::States::STOPPING,
-          workspace_exists: true,
-          resource_version: resource_version
-        )
-        reconcile_post_response =
-          simulate_agentk_reconcile_post(workspace_agent_infos: [workspace_agent_info])
-
-        # ASSERT ON RESPONSE TO THIRD POLL REQUEST
-
-        expect(reconcile_post_response.code).to eq(HTTP::Status::CREATED)
-        infos = Gitlab::Json.parse(reconcile_post_response.body).deep_symbolize_keys[:workspace_rails_infos]
-        expect(infos.length).to eq(1)
-        info = infos.first
-
-        expect(info.fetch(:name)).to eq(workspace.name)
-        expect(info.fetch(:namespace)).to eq(workspace.namespace)
-        expect(info.fetch(:desired_state)).to eq(RemoteDevelopment::Workspaces::States::STOPPED)
-        expect(info.fetch(:actual_state)).to eq(RemoteDevelopment::Workspaces::States::STOPPING)
-        expect(info.fetch(:deployment_resource_version)).to eq(resource_version)
-
-        expected_config_to_apply = create_config_to_apply(workspace: workspace, started: false)
-
-        config_to_apply = info.fetch(:config_to_apply)
-        expect(config_to_apply).to eq(expected_config_to_apply)
-      end
+    def simulate_third_poll(workspace:)
+      # SIMULATE THIRD POLL REQUEST FROM AGENTK TO UPDATE WORKSPACE TO STOPPING STATE
+
+      resource_version = '1'
+      workspace_agent_info = create_workspace_agent_info_hash(
+        workspace: workspace,
+        previous_actual_state: RemoteDevelopment::Workspaces::States::RUNNING,
+        current_actual_state: RemoteDevelopment::Workspaces::States::STOPPING,
+        workspace_exists: true,
+        resource_version: resource_version
+      )
+      reconcile_post_response =
+        simulate_agentk_reconcile_post(workspace_agent_infos: [workspace_agent_info])
+
+      # ASSERT ON RESPONSE TO THIRD POLL REQUEST
+
+      expect(reconcile_post_response.code).to eq(HTTP::Status::CREATED)
+      infos = Gitlab::Json.parse(reconcile_post_response.body).deep_symbolize_keys[:workspace_rails_infos]
+      expect(infos.length).to eq(1)
+      info = infos.first
+
+      expect(info.fetch(:name)).to eq(workspace.name)
+      expect(info.fetch(:namespace)).to eq(workspace.namespace)
+      expect(info.fetch(:desired_state)).to eq(RemoteDevelopment::Workspaces::States::STOPPED)
+      expect(info.fetch(:actual_state)).to eq(RemoteDevelopment::Workspaces::States::STOPPING)
+      expect(info.fetch(:deployment_resource_version)).to eq(resource_version)
+
+      expected_config_to_apply = create_config_to_apply(workspace: workspace, started: false)
+
+      config_to_apply = info.fetch(:config_to_apply)
+      expect(config_to_apply).to eq(expected_config_to_apply)
+    end
 
-      def simulate_fourth_poll(workspace:)
-        # SIMULATE FOURTH POLL REQUEST FROM AGENTK TO UPDATE WORKSPACE TO STOPPED STATE
-
-        resource_version = '2'
-        workspace_agent_info = create_workspace_agent_info_hash(
-          workspace: workspace,
-          previous_actual_state: RemoteDevelopment::Workspaces::States::STOPPING,
-          current_actual_state: RemoteDevelopment::Workspaces::States::STOPPED,
-          workspace_exists: true,
-          resource_version: resource_version
-        )
-        reconcile_post_response =
-          simulate_agentk_reconcile_post(workspace_agent_infos: [workspace_agent_info])
-
-        # ASSERT ON RESPONSE TO THIRD POLL REQUEST
-
-        expect(reconcile_post_response.code).to eq(HTTP::Status::CREATED)
-        infos = Gitlab::Json.parse(reconcile_post_response.body).deep_symbolize_keys[:workspace_rails_infos]
-        expect(infos.length).to eq(1)
-        info = infos.first
-
-        expect(info.fetch(:name)).to eq(workspace.name)
-        expect(info.fetch(:namespace)).to eq(workspace.namespace)
-        expect(info.fetch(:desired_state)).to eq(RemoteDevelopment::Workspaces::States::STOPPED)
-        expect(info.fetch(:actual_state)).to eq(RemoteDevelopment::Workspaces::States::STOPPED)
-        expect(info.fetch(:deployment_resource_version)).to eq(resource_version)
-        expect(info.fetch(:config_to_apply)).to be_nil
-      end
+    def simulate_fourth_poll(workspace:)
+      # SIMULATE FOURTH POLL REQUEST FROM AGENTK TO UPDATE WORKSPACE TO STOPPED STATE
+
+      resource_version = '2'
+      workspace_agent_info = create_workspace_agent_info_hash(
+        workspace: workspace,
+        previous_actual_state: RemoteDevelopment::Workspaces::States::STOPPING,
+        current_actual_state: RemoteDevelopment::Workspaces::States::STOPPED,
+        workspace_exists: true,
+        resource_version: resource_version
+      )
+      reconcile_post_response =
+        simulate_agentk_reconcile_post(workspace_agent_infos: [workspace_agent_info])
+
+      # ASSERT ON RESPONSE TO THIRD POLL REQUEST
+
+      expect(reconcile_post_response.code).to eq(HTTP::Status::CREATED)
+      infos = Gitlab::Json.parse(reconcile_post_response.body).deep_symbolize_keys[:workspace_rails_infos]
+      expect(infos.length).to eq(1)
+      info = infos.first
+
+      expect(info.fetch(:name)).to eq(workspace.name)
+      expect(info.fetch(:namespace)).to eq(workspace.namespace)
+      expect(info.fetch(:desired_state)).to eq(RemoteDevelopment::Workspaces::States::STOPPED)
+      expect(info.fetch(:actual_state)).to eq(RemoteDevelopment::Workspaces::States::STOPPED)
+      expect(info.fetch(:deployment_resource_version)).to eq(resource_version)
+      expect(info.fetch(:config_to_apply)).to be_nil
+    end
+
+    def expect_workspace_state_indicator(state)
+      indicator = find_by_testid('workspace-state-indicator')
+
+      expect(indicator).to have_text(state)
+    end
 
-      def expect_workspace_state_indicator(state)
-        indicator = find_by_testid('workspace-state-indicator')
+    def simulate_agentk_reconcile_post(workspace_agent_infos:)
+      post_params = {
+        update_type: 'partial',
+        workspace_agent_infos: workspace_agent_infos
+      }
+
+      # Note: HTTParty doesn't handle empty arrays right, so we have to be explicit with content type and send JSON.
+      #       See https://github.com/jnunemaker/httparty/issues/494
+      HTTParty.post(
+        reconcile_url,
+        headers: { 'Content-Type' => 'application/json' },
+        body: post_params.compact.to_json
+      )
+    end
+  end
 
-        expect(indicator).to have_text(state)
+  describe 'workspaces' do
+    context 'when creating' do
+      # TODO Unskip feature spec once the Agent mapping GraphQL API is implemented
+      # https://gitlab.com/gitlab-org/gitlab/-/issues/455214
+      describe 'when the remote_development_namespace_agent_authorization feature flag is on', :skip do
+        before do
+          stub_feature_flags(remote_development_namespace_agent_authorization: true)
+        end
+
+        it_behaves_like 'creates a workspace'
       end
 
-      def simulate_agentk_reconcile_post(workspace_agent_infos:)
-        post_params = {
-          update_type: 'partial',
-          workspace_agent_infos: workspace_agent_infos
-        }
-
-        # Note: HTTParty doesn't handle empty arrays right, so we have to be explicit with content type and send JSON.
-        #       See https://github.com/jnunemaker/httparty/issues/494
-        HTTParty.post(
-          reconcile_url,
-          headers: { 'Content-Type' => 'application/json' },
-          body: post_params.compact.to_json
-        )
+      describe 'when the remote_development_namespace_agent_authorization feature flag is off' do
+        before do
+          stub_feature_flags(remote_development_namespace_agent_authorization: false)
+        end
+
+        it_behaves_like 'creates a workspace'
       end
     end
   end
diff --git a/ee/spec/frontend/remote_development/components/common/get_project_details_query_spec.js b/ee/spec/frontend/remote_development/components/common/get_project_details_query_spec.js
index ea87a6556abd764e6140efe06fc113015c3e21e7..2cfcbb6ac29f51ede3fa3c73562bd3951207987c 100644
--- a/ee/spec/frontend/remote_development/components/common/get_project_details_query_spec.js
+++ b/ee/spec/frontend/remote_development/components/common/get_project_details_query_spec.js
@@ -4,6 +4,7 @@ import { cloneDeep } from 'lodash';
 import { logError } from '~/lib/logger';
 import getProjectDetailsQuery from 'ee/remote_development/graphql/queries/get_project_details.query.graphql';
 import getGroupClusterAgentsQuery from 'ee/remote_development/graphql/queries/get_group_cluster_agents.query.graphql';
+import getRemoteDevelopmentClusterAgentsQuery from 'ee/remote_development/graphql/queries/get_remote_development_cluster_agents.query.graphql';
 import GetProjectDetailsQuery from 'ee/remote_development/components/common/get_project_details_query.vue';
 import { shallowMountExtended } from 'helpers/vue_test_utils_helper';
 import createMockApollo from 'helpers/mock_apollo_helper';
@@ -15,6 +16,8 @@ import {
   GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_NO_AGENT,
   GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_ONE_AGENT,
   GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_DUPLICATES_ROOTGROUP,
+  GET_REMOTE_DEVELOPMENT_CLUSTER_AGENTS_QUERY_RESULT_TWO_AGENTS,
+  GET_REMOTE_DEVELOPMENT_CLUSTER_AGENTS_QUERY_RESULT_NO_AGENTS,
 } from '../../mock_data';
 
 Vue.use(VueApollo);
@@ -24,6 +27,8 @@ jest.mock('~/lib/logger');
 describe('remote_development/components/create/get_project_details_query', () => {
   let getProjectDetailsQueryHandler;
   let getGroupClusterAgentsQueryHandler;
+  let getRemoteDevelopmentClusterAgentsQueryHandler;
+  let glFeatures;
   let wrapper;
   const projectFullPathFixture = 'gitlab-org/gitlab';
 
@@ -43,15 +48,23 @@ describe('remote_development/components/create/get_project_details_query', () =>
     });
   };
 
+  const setupRemoteDevelopmentClusterAgentsQueryHandler = (responses) => {
+    getRemoteDevelopmentClusterAgentsQueryHandler.mockResolvedValueOnce(responses);
+  };
+
   const buildWrapper = async ({ projectFullPath = projectFullPathFixture } = {}) => {
     const apolloProvider = createMockApollo([
       [getProjectDetailsQuery, getProjectDetailsQueryHandler],
       [getGroupClusterAgentsQuery, getGroupClusterAgentsQueryHandler],
+      [getRemoteDevelopmentClusterAgentsQuery, getRemoteDevelopmentClusterAgentsQueryHandler],
     ]);
 
     // noinspection JSCheckFunctionSignatures - TODO: Address in https://gitlab.com/gitlab-org/gitlab/-/issues/437600
     wrapper = shallowMountExtended(GetProjectDetailsQuery, {
       apolloProvider,
+      provide: {
+        glFeatures,
+      },
       propsData: {
         projectFullPath,
       },
@@ -60,9 +73,29 @@ describe('remote_development/components/create/get_project_details_query', () =>
     await waitForPromises();
   };
 
+  const transformGroupClusterAgentGraphQLResultToClusterAgents = (clusterAgentsGraphQLResult) =>
+    clusterAgentsGraphQLResult.data.group.clusterAgents.nodes.map(({ id, name, project }) => ({
+      text: `${project.nameWithNamespace} / ${name}`,
+      value: id,
+    }));
+
+  const transformRemoveDevelopmentClusterAgentGraphQLResultToClusterAgents = (
+    clusterAgentsGraphQLResult,
+  ) =>
+    clusterAgentsGraphQLResult.data.namespace.remoteDevelopmentClusterAgents.nodes.map(
+      ({ id, name, project }) => ({
+        text: `${project.nameWithNamespace} / ${name}`,
+        value: id,
+      }),
+    );
+
   beforeEach(() => {
+    glFeatures = { remoteDevelopmentNamespaceAgentAuthorization: false };
     getProjectDetailsQueryHandler = jest.fn();
     getGroupClusterAgentsQueryHandler = jest.fn();
+    getRemoteDevelopmentClusterAgentsQueryHandler = jest.fn();
+
+    logError.mockReset();
 
     getProjectDetailsQueryHandler.mockResolvedValueOnce(GET_PROJECT_DETAILS_QUERY_RESULT);
     setupGroupClusterAgentsQueryHandler([]);
@@ -103,17 +136,11 @@ describe('remote_development/components/create/get_project_details_query', () =>
       await buildWrapper();
 
       const expectedClusterAgents = [
-        ...GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_ROOTGROUP_ONE_AGENT.data.group.clusterAgents.nodes.map(
-          ({ id, name, project }) => ({
-            text: `${project.nameWithNamespace} / ${name}`,
-            value: id,
-          }),
+        ...transformGroupClusterAgentGraphQLResultToClusterAgents(
+          GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_ROOTGROUP_ONE_AGENT,
         ),
-        ...GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_ONE_AGENT.data.group.clusterAgents.nodes.map(
-          ({ id, name, project }) => ({
-            text: `${project.nameWithNamespace} / ${name}`,
-            value: id,
-          }),
+        ...transformGroupClusterAgentGraphQLResultToClusterAgents(
+          GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_ONE_AGENT,
         ),
       ];
 
@@ -152,11 +179,8 @@ describe('remote_development/components/create/get_project_details_query', () =>
       await buildWrapper();
 
       expect(wrapper.emitted('result')[0][0]).toEqual({
-        clusterAgents: GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_ONE_AGENT.data.group.clusterAgents.nodes.map(
-          ({ id, name, project }) => ({
-            text: `${project.nameWithNamespace} / ${name}`,
-            value: id,
-          }),
+        clusterAgents: transformGroupClusterAgentGraphQLResultToClusterAgents(
+          GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_ONE_AGENT,
         ),
         id: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.id,
         rootRef: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.repository.rootRef,
@@ -220,17 +244,11 @@ describe('remote_development/components/create/get_project_details_query', () =>
 
       expect(wrapper.emitted('result')[0][0]).toEqual({
         clusterAgents: [
-          ...GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_ROOTGROUP_ONE_AGENT.data.group.clusterAgents.nodes.map(
-            ({ id, name, project }) => ({
-              text: `${project.nameWithNamespace} / ${name}`,
-              value: id,
-            }),
+          ...transformGroupClusterAgentGraphQLResultToClusterAgents(
+            GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_ROOTGROUP_ONE_AGENT,
           ),
-          ...GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_ONE_AGENT.data.group.clusterAgents.nodes.map(
-            ({ id, name, project }) => ({
-              text: `${project.nameWithNamespace} / ${name}`,
-              value: id,
-            }),
+          ...transformGroupClusterAgentGraphQLResultToClusterAgents(
+            GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_ONE_AGENT,
           ),
         ],
         id: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.id,
@@ -425,4 +443,100 @@ describe('remote_development/components/create/get_project_details_query', () =>
       expect(wrapper.emitted('error')).toEqual([[]]);
     });
   });
+
+  describe('when remote_development_namespace_agent_authorization feature flag is enabled', () => {
+    beforeEach(() => {
+      glFeatures.remoteDevelopmentNamespaceAgentAuthorization = true;
+    });
+
+    describe('when the project belongs to a group', () => {
+      beforeEach(async () => {
+        await buildWrapper();
+      });
+
+      it('executes getRemoteDevelopmentClusterAgents query', () => {
+        expect(getRemoteDevelopmentClusterAgentsQueryHandler).toHaveBeenCalledTimes(1);
+        expect(getRemoteDevelopmentClusterAgentsQueryHandler).toHaveBeenCalledWith({
+          namespace: 'gitlab-org/subgroup',
+        });
+      });
+
+      it('does not execute getRemoteDevelopmentClusterAgents', () => {
+        expect(getGroupClusterAgentsQueryHandler).toHaveBeenCalledTimes(0);
+      });
+    });
+
+    describe('when getRemoteDevelopmentClusterAgents query contains one or more cluster agents', () => {
+      beforeEach(async () => {
+        setupRemoteDevelopmentClusterAgentsQueryHandler(
+          GET_REMOTE_DEVELOPMENT_CLUSTER_AGENTS_QUERY_RESULT_TWO_AGENTS,
+        );
+        await buildWrapper();
+      });
+
+      it('emits result event with the cluster agents', async () => {
+        await waitForPromises();
+
+        expect(wrapper.emitted('result')[0][0]).toEqual({
+          clusterAgents: transformRemoveDevelopmentClusterAgentGraphQLResultToClusterAgents(
+            GET_REMOTE_DEVELOPMENT_CLUSTER_AGENTS_QUERY_RESULT_TWO_AGENTS,
+          ),
+          id: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.id,
+          rootRef: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.repository.rootRef,
+          fullPath: projectFullPathFixture,
+          nameWithNamespace: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.nameWithNamespace,
+        });
+      });
+    });
+
+    describe('when getRemoteDevelopmentClusterAgents query does not contain cluster agents', () => {
+      beforeEach(async () => {
+        setupRemoteDevelopmentClusterAgentsQueryHandler(
+          GET_REMOTE_DEVELOPMENT_CLUSTER_AGENTS_QUERY_RESULT_NO_AGENTS,
+        );
+        await buildWrapper();
+      });
+
+      it('emits result event with the cluster agents', async () => {
+        await waitForPromises();
+
+        expect(wrapper.emitted('result')[0][0]).toEqual({
+          clusterAgents: [],
+          id: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.id,
+          rootRef: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.repository.rootRef,
+          fullPath: projectFullPathFixture,
+          nameWithNamespace: GET_PROJECT_DETAILS_QUERY_RESULT.data.project.nameWithNamespace,
+        });
+      });
+    });
+
+    describe('when getRemoteDevelopmentClusterAgents query fails', () => {
+      const error = new Error();
+
+      beforeEach(() => {
+        getRemoteDevelopmentClusterAgentsQueryHandler.mockReset();
+        getRemoteDevelopmentClusterAgentsQueryHandler.mockRejectedValueOnce(error);
+      });
+
+      it('logs the error', async () => {
+        expect(logError).not.toHaveBeenCalled();
+
+        await buildWrapper();
+
+        expect(logError).toHaveBeenCalledWith(error);
+      });
+
+      it('does not emit result event', async () => {
+        await buildWrapper();
+
+        expect(wrapper.emitted('result')).toBe(undefined);
+      });
+
+      it('emits error event', async () => {
+        await buildWrapper();
+
+        expect(wrapper.emitted('error')).toEqual([[]]);
+      });
+    });
+  });
 });
diff --git a/ee/spec/frontend/remote_development/mock_data/index.js b/ee/spec/frontend/remote_development/mock_data/index.js
index c31bb4ee4c9387caaa1e9ad9fa683c3ac3a778bd..9a185e1aaa1e2b4a003080ba236bf0afd0ef20e2 100644
--- a/ee/spec/frontend/remote_development/mock_data/index.js
+++ b/ee/spec/frontend/remote_development/mock_data/index.js
@@ -295,6 +295,47 @@ export const GET_GROUP_CLUSTER_AGENTS_QUERY_RESULT_SUBGROUP_DUPLICATES_ROOTGROUP
   },
 };
 
+export const GET_REMOTE_DEVELOPMENT_CLUSTER_AGENTS_QUERY_RESULT_NO_AGENTS = {
+  data: {
+    namespace: {
+      id: 'gid://gitlab/Group/81',
+      fullPath: 'gitlab-org/subgroup',
+      remoteDevelopmentClusterAgents: {
+        nodes: [],
+      },
+    },
+  },
+};
+
+export const GET_REMOTE_DEVELOPMENT_CLUSTER_AGENTS_QUERY_RESULT_TWO_AGENTS = {
+  data: {
+    namespace: {
+      id: 'gid://gitlab/Group/81',
+      fullPath: 'gitlab-org/subgroup',
+      remoteDevelopmentClusterAgents: {
+        nodes: [
+          {
+            id: 'gid://gitlab/Clusters::Agent/1',
+            name: 'rootgroup-agent',
+            project: {
+              id: 'gid://gitlab/Project/101',
+              nameWithNamespace: 'GitLab Org / GitLab Agent One',
+            },
+          },
+          {
+            id: 'gid://gitlab/Clusters::Agent/2',
+            name: 'rootgroup-agent-2',
+            project: {
+              id: 'gid://gitlab/Project/102',
+              nameWithNamespace: 'GitLab Org / GitLab Agent Two',
+            },
+          },
+        ],
+      },
+    },
+  },
+};
+
 export const WORKSPACE_CREATE_MUTATION_RESULT = {
   data: {
     workspaceCreate: {